53de7e3 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

53de7e3 — Peter John 2026-11-03T21:43:41+05:30

Pure scene graph on enums: Node record + Kind enum, Custom(actor: Actor)

Files changed (24) hide show

docs/plans/2026-11-03-pure-scene-enums.incidents.jsonl +55 -0
docs/plans/2026-11-03-pure-scene-enums.md +277 -0
docs/plans/2026-11-03-pure-scene-enums.progress.md +52 -0
docs/plans/2026-11-03-pure-scene-enums.report.json +418 -0
docs/plans/2026-11-03-pure-scene-enums.report.md +59 -0
docs/plans/2026-11-03-state-view-parity.review.md +6 -0
plum-checker/src/lib.rs +24 -1
plum-checker/src/ownership.rs +154 -6
plum-checker/tests/fixtures/custom_actor_probe2.plum +58 -0
plum-checker/tests/fixtures/g3_generic_funstar.plum +34 -0
plum-checker/tests/optional_unpinned_tests.rs +1 -1
plum-checker/tests/ownership_moves_test.rs +67 -0
plum-checker/tests/ownership_trait_args_test.rs +73 -0
plum-checker/tests/variant_pattern_tests.rs +47 -0
plum-core/src/union_lower.rs +3 -2
plum-core/tests/forwarder_own_test.rs +51 -0
plum-examples/game_pure_scene.plum +129 -145
plum-game/web-test/fixtures/stress_pure_scene.plum +33 -45
plum-std/game/Actions.plum +63 -57
plum-std/game/PureScene.plum +212 -161
plum-std/game/SceneInput.plum +23 -30
plum-std/game/SceneTree.plum +94 -89
plum-wasm-codegen/src/lib.rs +12 -0
plum-wasm-codegen/tests/empty_record_embed_e2e_test.rs +76 -0

docs/plans/2026-11-03-pure-scene-enums.incidents.jsonl ADDED Viewed

@@ -0,0 +1,55 @@
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo test -p plum-checker 21 | grep -E  FAILED|failed;  | grep -v   0"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo build --quiet 21|tail -3; ./target/debug/plum test .superlite/re"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "20:43:44"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo test -p plum-checker --test ownership_trait_args_test 21 | tail "}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; D=/private/tmp/claude-501/-Users-pyrossh-Code-plum/7471cdc3-437e-41b8-9"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; D=/private/tmp/claude-501/-Users-pyrossh-Code-plum/7471cdc3-437e-41b8-9"}
+{"file": "plum-std/game/SceneTree.plum", "line": 242, "context": "T2: bare variant-name pattern (MoveBy =>) on an inline-variant enum with a payload compiles but never matches; should match or be a compile error", "agent": "coordinator", "time": "20:44:46"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; D=/private/tmp/claude-501/-Users-pyrossh-Code-plum/7471cdc3-437e-41b8-9"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; D=/private/tmp/claude-501/-Users-pyrossh-Code-plum/7471cdc3-437e-41b8-9"}
+{"kind":"rule-block","agent":"coordinator","tool":"Bash","target":"> MEMORY.md"}
+{"file": "-", "line": 0, "context": "exit code 1: For more information, try '--help'.", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "20:51:19"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo test -p plum-checker --test ownership_trait_args_test 21 | tail "}
+{"file": "", "line": 0, "context": "verified: seam T1↔T3", "agent": "pt_review", "kind": "verified", "time": "20:56:59"}
+{"file": "plum-core/", "line": 0, "context": "T3: change outside Owns blocked by checkpoint; nothing saved: 1 files under plum-core/, first 1: plum-core/src/union_lower.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "20:57:29"}
+{"file": "plum-core/", "line": 0, "context": "T3: change outside Owns blocked by checkpoint; nothing saved: 2 files under plum-core/, first 2: plum-core/src/union_lower.rs, plum-core/tests/forwarder_own_test.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "20:58:28"}
+{"file": "plum-core/", "line": 0, "context": "T4: change outside Owns blocked by checkpoint; nothing saved: 2 files under plum-core/, first 2: plum-core/src/union_lower.rs, plum-core/tests/forwarder_own_test.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "20:58:28"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo test -p plum-checker -p plum-core 21 | grep -E  ^test result|FAI"}
+{"file": "docs/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:06:32"}
+{"file": "plum-core/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 2 files under plum-core/, first 2: plum-core/src/union_lower.rs, plum-core/tests/forwarder_own_test.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:06:32"}
+{"file": "docs/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:06:35"}
+{"file": "plum-core/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 2 files under plum-core/, first 2: plum-core/src/union_lower.rs, plum-core/tests/forwarder_own_test.rs", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:06:35"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; sed -i 's/                                cx.tys.insert(n, t);/        "}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; sed -i '588s/cx.tys.insert(n, t);/let _ = (n, t);/' plum-checker/src/ow"}
+{"file": "docs/", "line": 0, "context": "T1: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:19:58"}
+{"file": "docs/", "line": 0, "context": "T8: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:19:58"}
+{"file": "docs/", "line": 0, "context": "T3: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:19:58"}
+{"file": "docs/", "line": 0, "context": "T4: change outside Owns blocked by checkpoint; nothing saved: 1 files under docs/, first 1: docs/plans/2026-11-03-state-view-parity.review.md", "agent": "checkpoint", "kind": "exception", "resolution": "open", "time": "21:19:58"}
+{"file": "", "line": 0, "context": "verified: seam T1↔T3", "agent": "pt_review", "kind": "verified", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.childrenOf: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.custom: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.drawTree: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.localMatrix: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.group: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.sprite: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.label: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.button: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.custom: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 128, "context": "seam T3↔T4: T3 Produces: PureScene.hit: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:20:05"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T6: T4 Produces: SceneTree.findHit: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:21:40"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T6: T4 Produces: SceneTree.idAt: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:21:40"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T6: T4 Produces: SceneTree.findPath: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:21:40"}
+{"file": ".superlite/repros/empty_record_embed.plum", "line": 6, "context": "field-less record embedding trait: Panel() -> codegen unknown class 'Panel' (Panel__new). Workaround: dummy field", "agent": "T5", "kind": "workaround", "resolution": "dummy field in Panel", "confidence": "high", "time": "21:22:09"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T5: T4 Produces: SceneTree.findHit: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:22:46"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T5: T4 Produces: SceneTree.idAt: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:22:46"}
+{"file": "docs/plans/2026-11-03-pure-scene-enums.md", "line": 152, "context": "seam T4↔T5: T4 Produces: SceneTree.findPath: no module found (file missing)", "agent": "pt_review", "kind": "exception", "confidence": "high", "resolution": "open", "time": "21:22:46"}
+{"file": "-", "line": 0, "context": "generic_funstar_wired: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "21:29:07"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum/plum-checker/tests; sed -i '' 's# /../.superlite/repros/g3_generic_funst"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; grep -n  fixtures  plum-checker/tests/*.rs | head; cargo test -q -p plu"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; touch plum-checker/src/lib.rs; cargo build --quiet 21 | tail -5; cargo"}
+{"kind":"rule-block","agent":"subagent","tool":"Bash","target":"full suite: cd /Users/pyrossh/Code/plum; cargo build -q -p plum-cli 21 | tail -5; ./target/debug/plum test plum"}
+{"file": "plum-checker/src/ownership.rs", "line": 1, "context": "residual after F-FR-3: an alias returned from a call (c := first(n)) into an own value is not tracked as a view; using c after moving n is not rejected; needs lifetime inference (candidate for the su…", "agent": "coordinator", "time": "21:36:21"}
+{"file": "-", "line": 0, "context": "filter_form_no_closure: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "21:41:05"}
+{"file": "-", "line": 0, "context": "one_copy_per_distinct_type: failed", "agent": "run_tests", "kind": "test-failure", "resolution": "open", "time": "21:41:05"}
+{"kind":"rule-block","agent":"coordinator","tool":"Bash","target":"rm target/master-check"}
+{"kind":"rule-block","agent":"coordinator","tool":"Bash","target":"rm /Users/pyrossh/Code/plum/target/master-check"}

docs/plans/2026-11-03-pure-scene-enums.md ADDED Viewed

@@ -0,0 +1,277 @@
+# Pure scene graph on enums
+**Review plan:** docs/plans/2026-11-03-pure-scene-enums.review.md
+**Goal:** move std/game PureScene, SceneTree, SceneInput and Actions, plus `game_pure_scene.plum` and its stress fixture, from a 14-field `own trait Actor` and record unions to `own record Node` + `enum Kind`, with `Custom(actor: Actor)` (behaviour-only trait, like Rust's `Box<dyn Actor>`) for game kinds; fix the ownership gap the probe found.
+**Architecture:** T1 checker ownership fix (borrowed arg to a trait method's borrowed param). T2 Actions: `record Action(elapsed, current, kind: ActionKind)`. T3 PureScene: Node/Kind/Actor, builders, draw, hit, Button input. T4 SceneTree + SceneInput over Node. T5 game, T6 stress fixture, T7 README + host checks + headed benchmark.
+**Tech stack:** Rust workspace (plum-checker), Plum std (plum-std/game), plum-game host tests, playwright-rs web-test.
+**Spec:** docs/plans/2026-11-03-pure-scene-enums.review.md
+**Detail:** contracts
+**Target-min:** 25
+**Budget-usd:** 40
+Global constraints:
+- Language: Plum (std/examples) and Rust (checker). Fast Plum tests: `cargo build --quiet && ./target/debug/plum test <file.plum>` from the repo root; `touch` edited .rs files before building (cargo can skip recompiles). Rust: `cargo test -p plum-checker --test <file>`.
+- Baselines: `./target/debug/plum test plum-std plum-examples` 632 passed; host: `cargo test --manifest-path plum-game/Cargo.toml --test host_test` 17 passed.
+- Shapes (exact):
+  - `record Transform(x: Float, y: Float, width: Float, height: Float, originX: Float, originY: Float, scaleX: Float, scaleY: Float, rotation: Float)` with `fun localMatrix(self) -> Affine` and `fun contains(self, p: Vec2) -> Bool` (box test in local coords).
+  - `own record Node(Transform(x, y, width, height, originX, originY, scaleX, scaleY, rotation), id: Int, color: Color, visible: Bool, touchable: Touchable, actions: Slice[Action], kind: Kind)` (embedding: `n.x`, `n.localMatrix()` work directly).
+  - Child lists and test trees are built with variadic init, `Slice(a, b, c)` / `List(a, b)`, never `Slice[T]()` + push chains; there is no `[a, b]` literal.
+  - `enum Kind = | Group(children: Slice[Node]) | Sprite(tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) | Label(text: Str, size: Float) | Button(text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool) | Custom(actor: Actor)`
+  - `trait Actor =` no fields; `fun act(self, own n: Node, dt: Float) -> Node = n` and `fun draw(self, n: Node, m: Affine, tint: Color) = return` (defaults).
+  - `record Action(elapsed: Float, current: Action?, kind: ActionKind)`; `enum ActionKind = | MoveBy(dx: Float, dy: Float, duration: Float) | RotateBy(radians: Float, duration: Float) | Delay(duration: Float) | Sequence(steps: Slice[Action]) | Parallel(steps: Slice[Action]) | Forever(template: Action)`.
+- Inline-variant fields can't be assigned: `n.kind = Button(...)` rebuilds a kind; Action keeps `elapsed`/`current` on the record.
+- Plum: `test "name"` + `assert`; an assignment in a match arm and a nested `match` each go on their own line.
+- Plum modules can't be stubbed: a module compiling against one still being rewritten may fail transiently; retry, don't edit it.
+- Every existing test keeps its name and asserted values; local test helpers may change.
+- Never `plum format` a real file (rewrites in place).
+- Out of scope: std/game/Scene, game_scene.plum, scene.plum, trait_scene.plum, traits.plum, Picture, game_state_view; generic traits.
+- A compiler gap hit while porting: `incident add`, report BLOCKED with a minimal repro in `.superlite/repros/`; never work around silently.
+## Main diagram
+```mermaid
+flowchart LR
+  OW["T1 ownership.rs: trait-method borrowed args"] --> PS["T3 PureScene: Node, Kind, Actor"]
+  AC["T2 Actions: Action + ActionKind"] --> PS
+  PS --> ST["T4 SceneTree + SceneInput"]
+  ST --> G["T5 game_pure_scene.plum"]
+  ST --> F["T6 stress_pure_scene fixture"]
+  G --> D["T7 README, host checks, benchmark"]
+  F --> D
+```
+## File structure
+Each task's `Owns` line is its file list; one responsibility per file as today.
+Spec map: The new shape -> T2-T5; What you will get -> T3-T7; What will be built -> T1-T7; How it fits together -> main diagram; Decisions you can change -> defaults taken (box hit; Action record + enum); Risks -> T1 + incidents; How we will know it works -> task tests + T7; Rough time and cost -> schedule.
+## Task graph
+```mermaid
+flowchart LR
+  T1[ownership fix]
+  T2[Actions]
+  T3[PureScene]
+  T4[SceneTree SceneInput]
+  T5[game]
+  T6[fixture]
+  T7[docs bench]
+  %% taskgraph
+  T1 --> T3
+  T3 --> T4
+  T4 --> T5
+  T4 --> T6
+  T5 --> T7
+  T6 --> T7
+```
+Ruling: sequential - T3..T7 are Plum modules that import each other and Plum has no stubs, so each one's tests compile the previous module - cost if wrong: ~10 min.
+## Predicted schedule
+Generated by `superlite-cli plan_tools lint`.
+## Checker
+### T1 ownership: borrowed argument to a trait method · Complexity 4 (O-1) · Est. context 40k
+**Owns:** plum-checker/src/ownership.rs, plum-checker/tests/ownership_trait_args_test.rs
+**Components:** 1
+**LOC owned:** 90
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 3 min
+**Consumes:** none
+**Produces:** ownership check accepts a borrowed `own` value passed to a borrowed param of a method called on a trait value
+**Review Focus:** state: the fix must not let a borrowed value reach an `own` param or a stored field.
+**Test code (named, exact):**
+- `trait_method_borrowed_arg_ok`: the source of `.superlite/repros/custom_actor_probe2.plum` checks with no errors (`a.score(n)` where `score(self, n: Node)` and `n` is borrowed).
+- `trait_method_own_arg_moves`: in the same program, a fn `fun g(own n: Node, a: Actor) -> Float = { m := a.act(n, 0.1); n.x }` reports `"n" used after it was moved`.
+- `borrowed_to_own_trait_param_rejected`: `fun h(n: Node, a: Actor) -> Node = a.act(n, 0.1)` (borrowed `n` to `own` param) reports `cannot store borrowed "n"`.
+- `plain_fn_borrowed_arg_still_ok`: an unchanged plain-fn borrowed call still checks clean.
+**Steps:** 1 failing tests, 2 FAIL, 3 find why a trait-method call treats a borrowed param as a store (method param modes are not looked up through the trait / its embedders) and fix, 4 PASS, 5 `cargo test -p plum-checker` green.
+**Notes:** the error comes from the "cannot store borrowed" path near ownership.rs:799-822; param modes for a call on a trait value should come from the trait's method declaration.
+### T8 trait forwarder keeps `own` (follow-up to T1, finding F-T1-1) · Complexity 3 (O-1) · Est. context 30k
+**Owns:** plum-core/src/union_lower.rs, plum-core/tests/forwarder_own_test.rs
+**Components:** 1
+**LOC owned:** 40
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2 min
+**Consumes:** none
+**Produces:** synthesized trait forwarders copy `own` / `own self` from the trait method declaration
+**Review Focus:** state: forwarder params carry the declared mode.
+**Test code:** `forwarder_own_test.rs`: the lowered forwarder of `fun act(self, own n: Node, dt: Float) -> Node` has `n.isOwn == true`.
+**Steps:** done by the F-T1-1 fixer; recorded here so its files have an owner.
+### T9 field-less record embedding a trait (compiler gap found by T5) · Complexity 4 (O-1) · Est. context 40k
+**Owns:** plum-wasm-codegen/src/lib.rs, plum-core/src/embeds.rs, plum-core/src/ctors.rs, plum-wasm-codegen/tests/empty_record_embed_e2e_test.rs, plum-examples/game_pure_scene.plum
+**Components:** 1
+**LOC owned:** 60
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 3 min
+**Consumes:** none
+**Produces:** `record Panel(Actor)` (no own fields, embeds a field-less trait) constructs with `Panel()` and dispatches its trait methods
+**Review Focus:** state: zero-field struct type in wasm-gc; trait dispatch to it.
+**Test code:** `empty_record_embed_e2e_test.rs`: `.superlite/repros/empty_record_embed.plum` runs and passes; a `List`/`Slice` of `Actor` mixing `Panel()` and a record with fields dispatches `draw` to each.
+**Steps:** fix "codegen: unknown class or enum variant 'Panel' (in 'Panel__new')"; then remove the `tag: Int` workaround field from `Panel` in game_pure_scene.plum (tests unchanged).
+### T10 tracked test fixtures (final review F-FR-1) · Complexity 2 (O-1) · Est. context 25k
+**Owns:** plum-checker/tests/fixtures/custom_actor_probe2.plum, plum-checker/tests/fixtures/g3_generic_funstar.plum, plum-checker/tests/optional_unpinned_tests.rs, plum-checker/tests/ownership_trait_args_test.rs
+**Components:** 1
+**LOC owned:** 40
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2 min
+**Consumes:** none
+**Produces:** checker tests no longer read git-ignored `.superlite/repros` files
+**Review Focus:** file: fixtures tracked, paths relative to the test file.
+**Test code:** `generic_funstar_wired` and the 7 ownership_trait_args tests pass from fixtures.
+**Steps:** see .superlite/fixes/F-FR-1.md.
+### T11 bare pattern on a payload variant is an error (final review F-FR-2) · Complexity 4 (O-1) · Est. context 45k
+**Owns:** plum-checker/src/lib.rs, plum-core/src/union_lower.rs, plum-checker/tests/variant_pattern_tests.rs
+**Components:** 1
+**LOC owned:** 60
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 3 min
+**Consumes:** none
+**Produces:** `MoveBy =>` on a variant with fields is a positioned compile error; unit variants and union-enum members unchanged
+**Review Focus:** deep: nested patterns; union-enum narrowing still works.
+**Test code:** `bare_payload_variant_pattern_rejected`, `bare_unit_variant_pattern_ok`.
+**Steps:** see .superlite/fixes/F-FR-2.md.
+### T12 ownership: projections after a move (final review F-FR-3) · Complexity 3 (O-1) · Est. context 35k
+**Owns:** plum-checker/src/ownership.rs, plum-checker/tests/ownership_moves_test.rs
+**Components:** 1
+**LOC owned:** 40
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2 min
+**Consumes:** none
+**Produces:** negative tests prove no own projection survives a move; non-own reads before a move stay legal
+**Review Focus:** state: soundness of moves.
+**Test code:** `own_field_used_after_move_rejected`, `own_child_projection_after_move_rejected`, `non_own_value_read_before_move_ok`.
+**Steps:** see .superlite/fixes/F-FR-3.md.
+## Std modules
+**Probe entry:** run=./target/debug/plum test plum-std/game
+Package: library/evaluator; categories: state, numeric, deep.
+### T2 Actions on Action + ActionKind · Complexity 5 (O-1) · Est. context 45k
+**Owns:** plum-std/game/Actions.plum
+**Components:** 1
+**LOC owned:** 150
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 4 min
+**Consumes:** none
+**Produces:** Actions.moveBy(dx: Float, dy: Float, secs: Float) -> Action
+e.g. Actions.moveBy(10.0, 0.0, 1.0) -> Action(elapsed: 0.0, current: null, kind: MoveBy(dx: 10.0, dy: 0.0, duration: 1.0))
+e.g. Actions.moveBy(0.0, 5.0, 0.0) -> Action(elapsed: 0.0, current: null, kind: MoveBy(dx: 0.0, dy: 5.0, duration: 0.0))
+**Produces:** Actions.stepAll(p: Pose, acts: Slice[Action], dt: Float) -> Step
+(rotateBy/delay/sequence/parallel/forever keep their current signatures)
+e.g. Actions.stepAll(Pose(x: 0.0, y: 0.0, rotation: 0.0, scaleX: 1.0, scaleY: 1.0), [Actions.moveBy(10.0, 0.0, 1.0)], 0.5) -> Step(pose.x: 5.0, spare: 0.0, done: false)
+e.g. same list stepped again with 0.6 -> pose.x 10.0 (cumulative), done: true, list now empty
+**Review Focus:** numeric: zero-length actions finish at once (no 0/0); Forever with a zero-length template terminates; state: stepping stays in place (`step_all_no_alloc_steady_state` keeps passing).
+**Test code:** all 13 existing tests keep names and values, including `actions_golden_values` (GoldRun rows unchanged in value; GoldRun may stay a record).
+**Steps:** port types to the global-constraint shapes; `fresh` rebuilds an unstarted Action; Forever keeps the template in its kind and the running lap in `current`; run `plum test plum-std/game/Actions.plum`.
+### T3 PureScene on Node, Kind, Actor · Complexity 6 (O-1) · Est. context 50k
+**Owns:** plum-std/game/PureScene.plum
+**Components:** 1
+**LOC owned:** 180
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 5 min
+**Consumes:** Actions.moveBy(dx: Float, dy: Float, secs: Float) -> Action (T2)
+**Produces:** PureScene.childrenOf(n: Node) -> Slice[Node]?
+e.g. PureScene.childrenOf(PureScene.group(1, 0.0, 0.0, 10.0, 10.0, Slice(sprite))) -> Slice(sprite)
+e.g. PureScene.childrenOf(PureScene.label(2, "a", 0.0, 0.0, 12.0)) -> null
+**Produces:** PureScene.custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node
+e.g. PureScene.custom(7, 1.0, 2.0, 32.0, 32.0, ship) -> Node(id: 7, x: 1.0, y: 2.0, width: 32.0, height: 32.0, scale 1, rotation 0, color White, visible true, touchable Disabled, actions Slice[Action](), kind: Custom(actor: ship))
+**Produces:** PureScene.drawTree(n: Node, parent: Affine, tint: Color)
+e.g. PureScene.drawTree(custom node, Affine.Identity, Color.White) -> calls actor.draw(node, local matrix, White) once
+**Produces:** PureScene.localMatrix(n: Node) -> Affine
+**Produces:** PureScene.group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Node]) -> Node · PureScene.sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Node · PureScene.label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Node · PureScene.button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Node · PureScene.custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node
+**Produces:** PureScene.hit(n: Node, p: Vec2) -> Bool · PureScene.onPointer(own n: Node, e: Pointer) -> Handled · `own record Handled(node: Node, events: Slice[UiEvent])` with `fun intoNode(own self) -> Node`
+e.g. PureScene.hit(PureScene.sprite(1, 0, 0.0, 0.0, 10.0, 10.0) with touchable Enabled, Vec2(x: 5.0, y: 5.0)) -> true; Vec2(x: 11.0, y: 5.0) -> false
+e.g. onPointer(button, Pointer(kind: Down, over: true)) -> events [UiEvent(id, Press)], node kind Button(pressed: true, over: true)
+**Review Focus:** state: Button press/release/enter/exit/click sequence unchanged; deep: drawTree over nested groups.
+**Test code:** existing 5 tests keep names and values; add `custom_actor_act_and_draw_dispatch`: a test record embedding `Actor` whose `act` adds 1.0 to `n.x`, a `custom` node at x 2.0, `act` via the node's kind -> x 3.0; `draw` reached once (counter field on the record).
+**Steps:** Transform/Node/Kind/Actor per Global constraints (Node embeds Transform; localMatrix and the box hit move onto Transform); drawing matches on kind (Sprite/Label/Button paint, Group recurses, Custom calls `actor.draw`); `hit` is the old box test; onPointer handles Button by rebuilding its kind, everything else returns no events; run `plum test plum-std/game/PureScene.plum`.
+### T4 SceneTree and SceneInput over Node · Complexity 6 (O-1) · Est. context 55k
+**Owns:** plum-std/game/SceneTree.plum, plum-std/game/SceneInput.plum
+**Components:** 2
+**LOC owned:** 170
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 5 min
+**Consumes:** PureScene.childrenOf(n: Node) -> Slice[Node]? (T3) · PureScene.onPointer(own n: Node, e: Pointer) -> Handled (T3) · Actions.stepAll(p: Pose, acts: Slice[Action], dt: Float) -> Step (T2)
+**Produces:** SceneTree.update(own n: Node, dt: Float) -> Node
+e.g. SceneTree.update(custom node x 1.0 whose actor adds 1.0 to n.x, 0.016) -> same node, x 2.0
+e.g. SceneTree.update(group with child moveBy(10, 0, 1), 0.5) -> child x +5.0
+**Produces:** SceneInput.stage(own root: Node) -> Stage
+e.g. SceneInput.stage(root) -> Stage(root: root, camera: Affine.Identity, captured: null)
+**Produces:** SceneTree.findHit(n: Node, parent: Affine, p: Vec2) -> Slice[Int]? · SceneTree.idAt(n: Node, path: Slice[Int], depth: Int) -> Int · SceneTree.findPath(n: Node, id: Int) -> Slice[Int]? · SceneTree.modify(own n: Node, id: Int, f: fn(Node) -> Node) -> Node · SceneTree.route(own n: Node, path: Slice[Int], depth: Int, e: Pointer) -> Handled
+`own record Stage(root: Node, camera: Affine, captured: Capture?)` keeps input/frame/draw names and args.
+**Review Focus:** state: in-place update (`update_changes_tree_in_place`, `input_changes_stage_in_place`); deep: routing through nested groups; numeric: rotated/scaled hit agrees with routing.
+**Test code:** all 14 SceneTree and 10 SceneInput tests keep names and values.
+**Steps:** update = `actor.act` for Custom, then actions on the pose, then Group children via `mapInPlace`; findHit/route match `Group(ks)`; run `plum test plum-std/game/SceneTree.plum plum-std/game/SceneInput.plum`.
+## Game and fixture
+**Probe entry:** run=./target/debug/plum test plum-examples/game_pure_scene.plum
+Package: data pipeline (game rules); categories: state, numeric.
+### T5 Orb Run on Node · Complexity 5 (O-1) · Est. context 55k
+**Owns:** plum-examples/game_pure_scene.plum
+**Components:** 1
+**LOC owned:** 190
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 5 min
+**Consumes:** SceneTree.update(own n: Node, dt: Float) -> Node (T4) · SceneInput.stage(own root: Node) -> Stage (T4) · PureScene.custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node (T3)
+**Produces:** none
+**Review Focus:** state: orbs respawn, ship flashes on hit, restart button click; numeric: drift and wrap unchanged.
+**Test code:** every existing `test` keeps name and values.
+**Steps:** `Panel`, `Ship`, `Orb`, `Mine`, `Star` become records embedding `Actor` with only their own fields (clock, vx, vy, phase, spin, seed, tex, colour if needed); position/size live on the Node; `create` builders return Node via `PureScene.custom`; `act` moves `n.x`/`n.y`/`n.rotation`; helpers like `cx(a)` take Node; build layers and child lists with `Slice(a, b, ...)`; run the file's tests.
+### T6 stress_pure_scene on Node · Complexity 3 (O-1) · Est. context 35k
+**Owns:** plum-game/web-test/fixtures/stress_pure_scene.plum
+**Components:** 1
+**LOC owned:** 120
+**Tests:** fast
+**Model:** sonnet
+**Est. time:** 2.5 min
+**Consumes:** SceneTree.update(own n: Node, dt: Float) -> Node (T4) · PureScene.drawTree(n: Node, parent: Affine, tint: Color) (T3)
+**Produces:** none
+**Review Focus:** numeric: same entity count and draw count per frame as before.
+**Test code:** `./target/debug/plum compile plum-game/web-test/fixtures/stress_pure_scene.plum` (or `plum check`) succeeds; any `test` blocks keep values.
+**Steps:** port the same way as T5; keep entity counts and per-frame behaviour.
+## Docs and benchmark
+**Probe entry:** run=cargo test --manifest-path plum-game/Cargo.toml --test host_test
+Package: file/generator (docs) + host checks; categories: protocol.
+### T7 README, host checks, benchmark · Complexity 3 (O-1) · Est. context 40k
+**Status:** draft
+**Owns:** README.md, plum-game/tests/host_test.rs, docs/plans/2026-11-03-pure-scene-enums.benchmark.md
+**Components:** 2
+**LOC owned:** 90
+**Tests:** slow
+**Model:** sonnet
+**Est. time:** 4 min
+**Consumes:** none
+**Produces:** none
+**Review Focus:** protocol: `pureSceneExampleRunsFrames`, `pureSceneMatchesSceneDrawCounts` and web check `pure_scene_renders_and_animates` pass.
+**Test code:** `cargo test --manifest-path plum-game/Cargo.toml --test host_test` all pass; `cargo test --manifest-path plum-game/web-test/Cargo.toml --test web_check pure_scene` passes.
+**Steps:** README "Pure scene graph" section and its example: Node + Kind, `Custom(actor: Actor)` with a short record example; headed benchmark: `cargo build --manifest-path plum-game/web-test/Cargo.toml` then `plum-game/web-test/target/debug/plum-web-test <fixture> --headed --uncapped --measure 10 --frames-wait 6 --json` for `stress_scene.plum` and `stress_pure_scene.plum` in the same session; write a table (avg, p95, update, draw) and the bar verdict (avg within +10%, p95 within +15% of mutable) to the benchmark file. If headed Chromium can't open, report DONE_WITH_CONCERNS with headless numbers labelled as such.
+## Review Focus
+Per package lines above; checker: ownership stays sound.
+## Self-review
+Every spec section maps (Spec map); Consumes match Produces; T5/T6 own distinct files.

docs/plans/2026-11-03-pure-scene-enums.progress.md ADDED Viewed

@@ -0,0 +1,52 @@
+- start ad3ec48
+- unblocked: dispatched T0 T1 at 20:41:23; waiting on fixes: T2 T3 T4 T5 T6 T7
+- Ruling: T0 skipped - every stub file already exists and Plum modules can't be stubbed; real modules stand in - cost if wrong: none
+- checkpoint T0 68b81bc54e Wave 0 skeleton
+- Ruling: T4-T7 held as draft until their Plum dependencies checkpoint - lint drops the edges because examples exist, but Plum modules have no stubs, so a dependent compiles the real half-rewritten module - cost if wrong: ~10 min longer wall clock
+- unblocked: dispatched T2 at 20:43:24; waiting on fixes: none (T4-T7 draft hold)
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- Ruling: SceneTree helper ttActKind updated by T4 (owner) - T2 changed Action's shape - cost if wrong: none
+- checkpoint T2 1a816dd148 Actions on Action + ActionKind
+- tests fast passed=1 failed=0 skipped=0 seconds=271.1
+- tests fast passed=0 failed=1 skipped=0 seconds=0.0
+- Ruling: [scope] user asked (mid-run) for Node to embed a Transform record and for variadic Slice(...)/List(...) construction instead of push chains in pure code and example; there is no [a, b] literal - applies to T3-T7, not yet dispatched - cost if wrong: none
+- unblocked: dispatched T3 at 20:55:11 (reused T2 agent); waiting on fixes: none (T4-T7 draft hold)
+- tests fast passed=1 failed=0 skipped=0 seconds=261.0
+- checkpoint T1 1c6b96eb2d ownership: borrowed argument to a trait method
+- checkpoint T3 c473382748 PureScene on Node, Kind, Actor
+- unblocked: dispatched T4 (reused T2/T3 agent), F-T1-1 fixer, T3 review at 20:56:59; waiting on fixes: none (T5-T7 draft hold)
+- T3 reviewed: no defects; +3 tests (enter/exit, non-button onPointer, invisible skip); 11 passed
+- Ruling: [scope] T7 (README, host checks, headed benchmark) dropped by the user - PureScene may be retired after a state/view parity plan; T5-T6 still run so the tree compiles - cost if wrong: README pure-scene section stale until then
+- tests fast passed=1 failed=0 skipped=0 seconds=263.3
+- tests fast passed=1 failed=0 skipped=0 seconds=0.7
+- tests fast passed=1 failed=0 skipped=0 seconds=0.4
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- Ruling: T8 added for F-T1-1's plum-core files (union_lower.rs forwarder own flags + test) - T1's Owns block is frozen - cost if wrong: none
+- tests fast passed=1 failed=0 skipped=0 seconds=280.1
+- tests fast passed=1 failed=0 skipped=0 seconds=305.7
+- tests fast passed=1 failed=0 skipped=0 seconds=0.9
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- checkpoint T8 ef98109949 trait forwarder keeps `own` (follow-up to T1, finding F-T1-1)
+- checkpoint T3 52d52baeec PureScene on Node, Kind, Actor
+- checkpoint T4 562509426a SceneTree and SceneInput over Node
+- unblocked: dispatched T5 T6 at 21:20:44 (fresh; old agents evicted >80k); T1 T3 T4 T8 checkpointed; T7 dropped
+- checkpoint T6 97e883c0a2 stress_pure_scene on Node
+- tests fast passed=1 failed=0 skipped=0 seconds=0.9
+- checkpoint T5 4cb7ef4fbb Orb Run on Node
+- Ruling: T9 added - T5 hit a codegen gap (field-less record embedding a trait: unknown variant 'Panel__new'); fix in the compiler and drop T5's visible tag-field workaround - cost if wrong: ~5 min
+- unblocked: dispatched T9 (fixer) at 21:23:06; T5 T6 checkpointed
+- tests fast passed=1 failed=0 skipped=0 seconds=221.8
+- checkpoint T9 85f9e7d84d field-less record embedding a trait (compiler gap found by T5)
+- tests full passed=80 failed=1 skipped=0 seconds=15.2
+- tests fast passed=1 failed=0 skipped=0 seconds=0.4
+- tests fast passed=1 failed=0 skipped=0 seconds=0.3
+- Ruling: final review CHANGES_REQUESTED - findings 2 and 4 stale (T9 fixed Panel; union_lower checkpointed under T8); real: F-FR-1 test fixtures in git-ignored .superlite (T10), F-FR-2 bare payload-variant pattern silently never matches -> compile error (T11), F-FR-3 negative move/projection tests (T12); run_tests --fast filters cargo by path (runs ~nothing) so fixers run cargo directly - cost if wrong: ~15 min
+- F-FR-3 fixed: views map (pattern/element projections of own roots) now error after move; residual call-result aliases logged
+- checkpoint T10 20527fe08e tracked test fixtures (final review F-FR-1)
+- checkpoint T11 b32e36ab14 bare pattern on a payload variant is an error (final review F-FR-2)
+- checkpoint T12 5f840f27dc ownership: projections after a move (final review F-FR-3)
+- tests full passed=609 failed=2 skipped=0 seconds=276.6
+- Ruling: codegen_tests filter_form_no_closure + one_copy_per_distinct_type fail on clean master too (pre-existing since closure specialisation, merged 8d9b551); not caused by this run; follow-up offered - cost if wrong: none

docs/plans/2026-11-03-pure-scene-enums.report.json ADDED Viewed

@@ -0,0 +1,418 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-03T20:41:17 (plan edited since)",
+ "headline": {
+  "wall_min": {
+   "projected": 43.834,
+   "actual": 40.875
+  },
+  "cost_usd_agents": {
+   "projected": 1.105389,
+   "actual": 3.029868
+  },
+  "task_min": {
+   "projected": 58.138,
+   "actual": 6.813
+  },
+  "agents": {
+   "projected": 7,
+   "actual": 30
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 1.156554,
+  "rework_usd": 1.873314,
+  "coordinator_usd": 14.923822,
+  "total_usd": 17.95369
+ },
+ "concurrency": {
+  "peak": 2,
+  "projected_peak": 2
+ },
+ "critical_path": {
+  "actual": [
+   "T3",
+   "T4",
+   "T5"
+  ],
+  "projected": [
+   "T1",
+   "T3",
+   "T4",
+   "T5",
+   "T7"
+  ],
+  "projected_min": 43.834
+ },
+ "model_mix": {
+  "unknown": {
+   "tasks": 5,
+   "cost_usd": 1.873314
+  },
+  "sonnet": {
+   "tasks": 5,
+   "cost_usd": 1.156554
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 14.923822
+ },
+ "quality": {
+  "tests": {
+   "passed": 609,
+   "failed": 2,
+   "skipped": 0,
+   "seconds": 276.6,
+   "mode": "full",
+   "failures": [
+    "-::filter_form_no_closure: failed",
+    "-::one_copy_per_distinct_type: failed"
+   ],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 0,
+  "rework_dispatches": 6,
+  "open_incidents": 34
+ },
+ "tasks": [
+  {
+   "task": "T5",
+   "model": "sonnet",
+   "pred_min": 11.385,
+   "actual_min": 1.963,
+   "delta": {
+    "abs": -9.4217,
+    "pct": -82.8
+   },
+   "cost_usd": 0.351123,
+   "first_time_pass": null
+  },
+  {
+   "task": "T4",
+   "model": "sonnet",
+   "pred_min": 10.615,
+   "actual_min": 1.357,
+   "delta": {
+    "abs": -9.2583,
+    "pct": -87.2
+   },
+   "cost_usd": 0.195004,
+   "first_time_pass": null
+  },
+  {
+   "task": "T3",
+   "model": "sonnet",
+   "pred_min": 10.615,
+   "actual_min": 1.452,
+   "delta": {
+    "abs": -9.1633,
+    "pct": -86.3
+   },
+   "cost_usd": 0.292406,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 9.076,
+   "actual_min": 1.135,
+   "delta": {
+    "abs": -7.941,
+    "pct": -87.5
+   },
+   "cost_usd": 0.176055,
+   "first_time_pass": null
+  },
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": 5.228,
+   "actual_min": 0.907,
+   "delta": {
+    "abs": -4.3213,
+    "pct": -82.7
+   },
+   "cost_usd": 0.141966,
+   "first_time_pass": null
+  },
+  {
+   "task": "T1",
+   "model": null,
+   "pred_min": 4.074,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": -4.074,
+    "pct": -100.0
+   },
+   "cost_usd": 1.061078,
+   "first_time_pass": null
+  },
+  {
+   "task": "T10",
+   "model": null,
+   "pred_min": null,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.141179,
+   "first_time_pass": null
+  },
+  {
+   "task": "T11",
+   "model": null,
+   "pred_min": null,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.224343,
+   "first_time_pass": null
+  },
+  {
+   "task": "T12",
+   "model": null,
+   "pred_min": null,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.281546,
+   "first_time_pass": null
+  },
+  {
+   "task": "T9",
+   "model": null,
+   "pred_min": null,
+   "actual_min": 0.0,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.165168,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 3.247,
+  "tokens": 8480136,
+  "wall_min": 568011343.9345,
+  "rows": [
+   {
+    "agent": "a1a960c040d23e232",
+    "model": "sonnet",
+    "wall_min": 0.924,
+    "tokens": 207294,
+    "usd": 0.142
+   },
+   {
+    "agent": "a27dd2c4b62114365",
+    "model": "sonnet",
+    "wall_min": 3.9581,
+    "tokens": 486765,
+    "usd": 0.2815
+   },
+   {
+    "agent": "a39ba404785fc1b21",
+    "model": "sonnet",
+    "wall_min": 2.3132,
+    "tokens": 360848,
+    "usd": 0.1412
+   },
+   {
+    "agent": "a3c01abfc2bde8c78",
+    "model": "sonnet",
+    "wall_min": 5.7162,
+    "tokens": 392705,
+    "usd": 0.1652
+   },
+   {
+    "agent": "a50a134039ef9862d",
+    "model": "sonnet",
+    "wall_min": 29895337.9274,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a5e546c8e19deafd2",
+    "model": "sonnet",
+    "wall_min": 29895365.5444,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a6ac27873b5a7d513",
+    "model": "sonnet",
+    "wall_min": 4.33,
+    "tokens": 574372,
+    "usd": 0.2243
+   },
+   {
+    "agent": "a78c56b4db21c27c4",
+    "model": "sonnet",
+    "wall_min": 29895325.359,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a7dc4ab6ebd2288db",
+    "model": "sonnet",
+    "wall_min": 14.2417,
+    "tokens": 1721696,
+    "usd": 0.4792
+   },
+   {
+    "agent": "a7f4019524006638c",
+    "model": "sonnet",
+    "wall_min": 29895361.9656,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a816dca9d1e31f8ac",
+    "model": "sonnet",
+    "wall_min": 15.0172,
+    "tokens": 1499690,
+    "usd": 0.5796
+   },
+   {
+    "agent": "a85fd2e6c24d170b0",
+    "model": "sonnet",
+    "wall_min": 1.9766,
+    "tokens": 745714,
+    "usd": 0.3511
+   },
+   {
+    "agent": "a897f89c2a7bcb3ba",
+    "model": "sonnet",
+    "wall_min": 29895331.2866,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a8d31035bcea62a1b",
+    "model": "sonnet",
+    "wall_min": 29895304.8965,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a916e3bfe065e33ca",
+    "model": "sonnet",
+    "wall_min": 29895308.043,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a91f7f59b51d17204",
+    "model": "sonnet",
+    "wall_min": 29895316.4158,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "aa647f9c93fa5b7b1",
+    "model": "sonnet",
+    "wall_min": 29895329.8664,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "aa83af5df90f57224",
+    "model": "opus",
+    "wall_min": 0.5738,
+    "tokens": 45856,
+    "usd": 0.2171
+   },
+   {
+    "agent": "abf8945d7b644a1d5",
+    "model": "sonnet",
+    "wall_min": 0.3868,
+    "tokens": 111302,
+    "usd": 0.0839
+   },
+   {
+    "agent": "aca9f95e013875bcb",
+    "model": "sonnet",
+    "wall_min": 29895313.8694,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ad6209113dcffa8c6",
+    "model": "sonnet",
+    "wall_min": 29895307.0034,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "adc378a5bab157e94",
+    "model": "sonnet",
+    "wall_min": 29895335.7,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "adcb4dcfc908bc785",
+    "model": "sonnet",
+    "wall_min": 29895309.2257,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "adf67542c96687e8a",
+    "model": "sonnet",
+    "wall_min": 29895353.2172,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ae54f4cfa8b37d20b",
+    "model": "sonnet",
+    "wall_min": 29895351.7776,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ae555f72c936ddec4",
+    "model": "sonnet",
+    "wall_min": 22.8393,
+    "tokens": 2333894,
+    "usd": 0.5819
+   },
+   {
+    "agent": "ae670ac54bcd2838c",
+    "model": "sonnet",
+    "wall_min": 29895314.8372,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ae76a82a935523db2",
+    "model": "sonnet",
+    "wall_min": 29895335.1586,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "af8f810c7141bc774",
+    "model": "sonnet",
+    "wall_min": 29895359.1034,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "afc0910dfeb3a2d5d",
+    "model": "sonnet",
+    "wall_min": 29895310.4604,
+    "tokens": 0,
+    "usd": 0.0
+   }
+  ]
+ }
+}

docs/plans/2026-11-03-pure-scene-enums.report.md ADDED Viewed

@@ -0,0 +1,59 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-03T20:41:17 (plan edited since)
+                         Projected    Actual  Delta
+wall-clock (min)              43.8      40.9  -3.0 (-7%)
+agent cost (USD, +rework)      1.11      3.03  +1.92 (+174%)
+task-minutes                  58.1       6.8  -51.3 (-88%)
+agents                           7        30  +23 (+329%)
+cost split: agents $1.16, rework $1.87, coordinator $14.92, total $17.95
+concurrency: peak 2 at once (projected 2); critical path actual T3 T4 T5; projected T1 > T3 > T4 > T5 > T7 (43.8 min)
+model mix: sonnet 5 tasks $1.16, unknown 5 tasks $1.87, coordinator opus $14.92
+quality: tests 609 passed, 2 failed; first-time pass n/a; rework dispatches 6; open incidents 34
+task  model      pred  actual  delta             cost
+T5    sonnet     11.4     2.0  -9.4 (-83%)     $0.351
+T4    sonnet     10.6     1.4  -9.3 (-87%)     $0.195
+T3    sonnet     10.6     1.5  -9.2 (-86%)     $0.292
+T2    sonnet      9.1     1.1  -7.9 (-88%)     $0.176
+T6    sonnet      5.2     0.9  -4.3 (-83%)     $0.142
+(+5 smaller misses; `superlite-cli report --json` lists all)
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a1a960c040d23e232 | sonnet | 0.924 | 207294 | 0.142 |
+| a27dd2c4b62114365 | sonnet | 3.9581 | 486765 | 0.2815 |
+| a39ba404785fc1b21 | sonnet | 2.3132 | 360848 | 0.1412 |
+| a3c01abfc2bde8c78 | sonnet | 5.7162 | 392705 | 0.1652 |
+| a50a134039ef9862d | sonnet | 29895337.9274 | 0 | 0.0 |
+| a5e546c8e19deafd2 | sonnet | 29895365.5444 | 0 | 0.0 |
+| a6ac27873b5a7d513 | sonnet | 4.33 | 574372 | 0.2243 |
+| a78c56b4db21c27c4 | sonnet | 29895325.359 | 0 | 0.0 |
+| a7dc4ab6ebd2288db | sonnet | 14.2417 | 1721696 | 0.4792 |
+| a7f4019524006638c | sonnet | 29895361.9656 | 0 | 0.0 |
+| a816dca9d1e31f8ac | sonnet | 15.0172 | 1499690 | 0.5796 |
+| a85fd2e6c24d170b0 | sonnet | 1.9766 | 745714 | 0.3511 |
+| a897f89c2a7bcb3ba | sonnet | 29895331.2866 | 0 | 0.0 |
+| a8d31035bcea62a1b | sonnet | 29895304.8965 | 0 | 0.0 |
+| a916e3bfe065e33ca | sonnet | 29895308.043 | 0 | 0.0 |
+| a91f7f59b51d17204 | sonnet | 29895316.4158 | 0 | 0.0 |
+| aa647f9c93fa5b7b1 | sonnet | 29895329.8664 | 0 | 0.0 |
+| aa83af5df90f57224 | opus | 0.5738 | 45856 | 0.2171 |
+| abf8945d7b644a1d5 | sonnet | 0.3868 | 111302 | 0.0839 |
+| aca9f95e013875bcb | sonnet | 29895313.8694 | 0 | 0.0 |
+| ad6209113dcffa8c6 | sonnet | 29895307.0034 | 0 | 0.0 |
+| adc378a5bab157e94 | sonnet | 29895335.7 | 0 | 0.0 |
+| adcb4dcfc908bc785 | sonnet | 29895309.2257 | 0 | 0.0 |
+| adf67542c96687e8a | sonnet | 29895353.2172 | 0 | 0.0 |
+| ae54f4cfa8b37d20b | sonnet | 29895351.7776 | 0 | 0.0 |
+| ae555f72c936ddec4 | sonnet | 22.8393 | 2333894 | 0.5819 |
+| ae670ac54bcd2838c | sonnet | 29895314.8372 | 0 | 0.0 |
+| ae76a82a935523db2 | sonnet | 29895335.1586 | 0 | 0.0 |
+| af8f810c7141bc774 | sonnet | 29895359.1034 | 0 | 0.0 |
+| afc0910dfeb3a2d5d | sonnet | 29895310.4604 | 0 | 0.0 |
+| totals |  | 568011343.9345 | 8480136 | 3.247 |
+cost source: est
+takeaway: ran 7% faster than projected; cost 174% over; biggest miss T5

docs/plans/2026-11-03-state-view-parity.review.md CHANGED Viewed

@@ -47,6 +47,11 @@ The mutable examples (`game.plum`, `game_scene.plum`, `scene.plum`, `trait_scene
     - capture is dropped when the captured id is no longer in the picture.
   - Button visuals come from the UI state: `Ui.pressed(ui, id)`, `Ui.hovered(ui, id)`. `Ui.button(id, label, rect, ui)` builds the button's `SceneNode`.
   - Events are `UiEvent(id, kind)`, as in PureScene, and the game handles them in `step`.
+- **Static subtree reuse (user, 2026-11-03).** Parts of a picture that never change are built once and returned as the same value every frame. Examples: a starfield's layout, terrain tiles, HUD frames, panel backgrounds.
+  - `view` places them as-is (`Group(.., children: Cons(s.staticBg, ...))`), so they cost no allocation per frame. Only the moving parts are rebuilt.
+  - Anything that varies over time is applied around the shared subtree, not inside it: a twinkle via `Filter(Alpha(..), child: staticStar)`, a scroll via `Group(Translate(..), child: staticMap)`.
+  - Stored in `State` (built in `newState`), or as a module-level constant when it depends on nothing.
+  - Test: a wasmparser/allocation count shows the static part adds no `struct.new` per frame. `game_state_view`'s starfield becomes static (positions fixed, twinkle as a per-frame alpha wrapper).
 - **The game shell stays thin.** `update` reads input into a `Msg`, then calls `step`, then `Ui.step` against `view(state)`, then `step` again for each `UiEvent`. Sound remains the only side effect.
 ## What you will get
@@ -68,6 +73,7 @@ The mutable examples (`game.plum`, `game_scene.plum`, `scene.plum`, `trait_scene
 | Picture tags | `Tagged(id, child)`, `hitId`, draw/bounds pass-through; tests | S |
 | Ui | `UiState`, `Ui.step`, events, capture, `pressed`/`hovered`, `button`; PureScene-equivalent tests | M |
 | Orb Run state/view | restart via Ui, Anim for the title and hit flash; tests unchanged plus Ui/Anim cases | M |
+| Static subtrees | starfield built once in `State`, twinkle as an alpha wrapper; allocation test | S |
 | Stress fixture | tags, buttons, animations in `stress_state_view.plum` | S |
 | Benchmark + README | headed table, "Functional scenes" section | S |

plum-checker/src/lib.rs CHANGED Viewed

@@ -3906,6 +3906,12 @@ fn liftInlineVariant(
     Ok(lifted)
 }
+thread_local! {
+    /// Address of a top-level `if X := v` pattern, where a bare inline-variant name
+    /// narrows `v` instead of matching a value.
+    static ALLOW_BARE_TOP: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
 /// Checks a single case pattern against the type of the subject it matches, binding any
 /// new names it introduces into `env`. Constructor-payload sub-patterns (`Next(x)`) bind
 /// against that variant's declared field types (see `EnumVariantInfo::field_types`).
@@ -3932,6 +3938,20 @@ pub(crate) fn checkPattern(
             }
         }
     }
+    // An inline variant with fields is never matched bare (Rust semantics): the bare
+    // name would narrow to the hidden member and silently never match as written.
+    if let ast::CasePattern::Name(n) = pat {
+        let allowed = ALLOW_BARE_TOP.with(|c| c.get()) == pat as *const ast::CasePattern as usize;
+        if let (false, Some(owner), Some(subject)) =
+            (allowed, unions::inlineOwner(n), nominalName(subject_ty))
+        {
+            if owner == subject {
+                return Err(format!(
+                    "{n} has fields; match it with one pattern per field, e.g. {n}(_, _)"
+                ));
+            }
+        }
+    }
     if let Some(r) = unions::checkMemberPattern(pat, subject_ty, env, ctx) {
         return r;
     }
@@ -4637,7 +4657,10 @@ fn bindCondEnv(cond: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<TypeEn
         }
         pat => {
             let narrow = unions::narrowTarget(&b.value, pat, &ty, env, ctx);
+            ALLOW_BARE_TOP.with(|c| c.set(pat as *const ast::CasePattern as usize));
-            checkPattern(pat, &ty, &mut benv, ctx)?;
+            let r = checkPattern(pat, &ty, &mut benv, ctx);
+            ALLOW_BARE_TOP.with(|c| c.set(0));
+            r?;
             unions::applyNarrow(narrow, &b.case, &mut benv, ctx);
         }
     }

plum-checker/src/ownership.rs CHANGED Viewed

@@ -85,6 +85,7 @@ pub fn checkOwnership(src: &Source) -> Vec<CheckError> {
         selfTy: None,
         tys: HashMap::new(),
         elems: HashMap::new(),
+        views: HashMap::new(),
         traits: HashMap::new(),
         dead: false,
         loops: Vec::new(),
@@ -159,6 +160,9 @@ struct Cx<'a> {
     tys: HashMap<String, String>,
     /// `Slice[T]` locals whose element type `T` is known.
     elems: HashMap<String, String>,
+    /// Borrowed projections of an owned binding (pattern binders / element views
+    /// holding own data), mapped to the root binding: moving the root kills them.
+    views: HashMap<String, String>,
     traits: HashMap<String, &'a TraitDecl>,
     /// The current path ended in return/crash/break/continue.
     dead: bool,
@@ -214,6 +218,7 @@ impl<'a> Cx<'a> {
         self.selfTy = selfTy;
         self.tys = HashMap::new();
         self.elems = HashMap::new();
+        self.views = HashMap::new();
         self.dead = false;
         self.loops = Vec::new();
         self.swap = None;
@@ -257,6 +262,29 @@ impl<'a> Cx<'a> {
         None
     }
+    /// Receiver type unknown (e.g. bound by a pattern): a method called `name`, but
+    /// only when EVERY method of that name in the program (trait methods, required
+    /// methods, record/enum methods) takes `self` and each param the same way, so
+    /// the call's modes do not depend on which type the receiver turns out to be.
+    /// Otherwise `None`, and the caller consumes every argument.
+    fn uniqueTraitMethod(&self, name: &str) -> Option<&'a Fn> {
+        let all = self
+            .traits
+            .values()
+            .flat_map(|t| t.methods.iter().chain(t.required.iter()))
+            .chain(self.methods.values().copied())
+            .filter(|f| f.name == name);
+        let mut found: Option<&'a Fn> = None;
+        for f in all {
+            match found {
+                None => found = Some(f),
+                Some(g) if sameModes(g, f) => {}
+                Some(_) => return None,
+            }
+        }
+        found
+    }
     /// `xs.at(i)` and friends on a `List[Own]`: a borrowed view of an element.
     fn elemRead(&self, e: &Expr) -> Option<(String, String)> {
         let Expr::Attribute(a) = e else { return None };
@@ -269,6 +297,61 @@ impl<'a> Cx<'a> {
         Some((format!("{}.{}", recv, c.name), el.clone()))
     }
+    /// The owned binding a `match` subject / element read is rooted in, looking
+    /// through views (`n.kind`, `n`, `ks.at(0)` where `ks` is a view of `n`).
+    fn viewRoot(&self, e: &Expr) -> Option<String> {
+        let r = match e {
+            Expr::Paren(i) => return self.viewRoot(i),
+            Expr::Attribute(a) if matches!(a.attr, AttrKind::Method(_)) => {
+                return self.elemViewRoot(e).or_else(|| self.viewRoot(&a.object));
+            }
+            Expr::Attribute(a) => return self.viewRoot(&a.object),
+            _ => nameOf(e)?,
+        };
+        if let Some(root) = self.views.get(&r) {
+            return Some(root.clone());
+        }
+        self.env.contains_key(&r).then_some(r)
+    }
+    /// `ks.at(i)` where `ks` is a view into an owned binding: that binding.
+    fn elemViewRoot(&self, e: &Expr) -> Option<String> {
+        let Expr::Attribute(a) = e else { return None };
+        let AttrKind::Method(c) = &a.attr else { return None };
+        if !matches!(c.name.as_str(), "at" | "get" | "first" | "last") {
+            return None;
+        }
+        self.viewRoot(&a.object)
+    }
+    /// Names a pattern binds to own data: an own-typed field or a `Slice[Own]`.
+    fn viewBinds(&self, p: &CasePattern, out: &mut Vec<String>) {
+        let CasePattern::Class { name, fields } = p else { return };
+        let owner = self.enums.get(name).copied().or_else(|| {
+            self.enums
+                .values()
+                .copied()
+                .find(|e| e.variants.iter().any(|v| &v.name == name))
+        });
+        let Some(v) = owner.and_then(|e| e.variants.iter().find(|v| &v.name == name)) else {
+            return;
+        };
+        for (i, f) in fields.iter().enumerate() {
+            let holdsOwn = match v.fields.get(i) {
+                Some(t) => {
+                    self.own.contains(&t.name)
+                        || (t.name == "Slice" && t.generics.iter().any(|g| self.own.contains(&g.name)))
+                }
+                None => false,
+            };
+            match f {
+                CasePattern::Name(n) if holdsOwn => out.push(n.clone()),
+                CasePattern::Class { .. } => self.viewBinds(f, out),
+                _ => {}
+            }
+        }
+    }
     fn isOwnTy(&self, ty: &Option<String>) -> bool {
         ty.as_ref().is_some_and(|t| self.own.contains(t))
     }
@@ -395,10 +478,16 @@ impl<'a> Cx<'a> {
     /// Names a pattern binds to a value of own type, with that type. `ty` is the
     /// type of the value the pattern matches.
+    fn patternBinds(
+        &self,
+        p: &CasePattern,
+        ty: Option<String>,
+        onlyOwn: bool,
-    fn patternBinds(&self, p: &CasePattern, ty: Option<String>, out: &mut Vec<(String, String)>) {
+        out: &mut Vec<(String, String)>,
+    ) {
         match p {
             CasePattern::Name(n) => {
-                if let Some(t) = ty.filter(|t| self.own.contains(t)) {
+                if let Some(t) = ty.filter(|t| !onlyOwn || self.own.contains(t)) {
                     out.push((n.clone(), t));
                 }
             }
@@ -419,7 +508,7 @@ impl<'a> Cx<'a> {
                         (None, Some(t)) if i == 0 => Some(t.name.clone()),
                         _ => None,
                     };
-                    self.patternBinds(f, fty, out);
+                    self.patternBinds(f, fty, onlyOwn, out);
                 }
             }
             _ => {}
@@ -520,7 +609,7 @@ impl<'a> Cx<'a> {
                     for (i, p) in c.patterns.iter().enumerate() {
                         let ty = m.subjects.get(i).and_then(|e| self.typeOf(e));
                         let mut found = Vec::new();
-                        self.patternBinds(p, ty, &mut found);
+                        self.patternBinds(p, ty, true, &mut found);
                         if modes.get(i) == Some(&Some(Mode::Owned)) && !found.is_empty() {
                             consumes = true;
                         }
@@ -548,12 +637,40 @@ impl<'a> Cx<'a> {
                         for n in names {
                             cx.env.remove(&n);
                             cx.tys.remove(&n);
+                            cx.views.remove(&n);
+                        }
+                        // Binders holding own data read out of an owned binding are
+                        // views into it: they die when it is moved. (`match n` itself
+                        // consumes `n`, so its binders are moved out, not views.)
+                        let subjectRoot = m.subjects.iter().find_map(|e| match e {
+                            Expr::Var(_) | Expr::Self_ => nameOf(e)
+                                .and_then(|n| cx.views.get(&n).cloned()),
+                            e => cx.viewRoot(e),
+                        });
+                        if let Some(root) = subjectRoot {
+                            let mut vs = Vec::new();
+                            for p in &c.patterns {
+                                cx.viewBinds(p, &mut vs);
+                            }
+                            for n in vs {
+                                cx.views.insert(n, root.clone());
+                            }
+                        }
+                        // Every binder gets its declared type (own or not), so a method
+                        // call on it resolves to its real type's method.
+                        for (i, p) in c.patterns.iter().enumerate() {
+                            let ty = m.subjects.get(i).and_then(|e| cx.typeOf(e));
+                            let mut all = Vec::new();
+                            cx.patternBinds(p, ty, false, &mut all);
+                            for (n, t) in all {
+                                cx.tys.insert(n, t);
+                            }
                         }
                         for (i, p) in c.patterns.iter().enumerate() {
                             let Some(Some(mode)) = modes.get(i).copied() else { continue };
                             let ty = m.subjects.get(i).and_then(|e| cx.typeOf(e));
                             let mut found = Vec::new();
-                            cx.patternBinds(p, ty, &mut found);
+                            cx.patternBinds(p, ty, true, &mut found);
                             for (n, t) in found {
                                 cx.tys.insert(n.clone(), t.clone());
                                 cx.env.insert(
@@ -674,6 +791,10 @@ impl<'a> Cx<'a> {
                 AssignTarget::Var(x) => {
                     let val = a.values.get(i).or(a.values.first());
                     let view = val.and_then(|v| self.elemRead(v));
+                    self.views.remove(x);
+                    if let Some(root) = val.and_then(|v| self.elemViewRoot(v)) {
+                        self.views.insert(x.clone(), root);
+                    }
                     let valTy = match &view {
                         Some((_, el)) => Some(el.clone()),
                         None => val.and_then(|v| self.typeOf(v)),
@@ -733,6 +854,19 @@ impl<'a> Cx<'a> {
     // ---- expressions -------------------------------------------------------
     fn checkLive(&mut self, name: &str) {
+        if let Some(root) = self.views.get(name).cloned() {
+            if let Some((l, c)) = self.env.get(&root).and_then(|b| b.moved) {
+                self.views.remove(name); // report once
+                let p = self.pos;
+                self.err(
+                    p,
+                    format!(
+                        "\"{}\" used after it was moved at {}:{} (it is a view into \"{}\")",
+                        name, l, c, root
+                    ),
+                );
+            }
+        }
         let Some(b) = self.env.get_mut(name) else { return };
         if let Some((l, c)) = b.moved {
             b.moved = None; // report once
@@ -932,7 +1066,9 @@ impl<'a> Cx<'a> {
                         Expr::TypeName(t) => Some(t.clone()),
                         o => self.typeOf(o),
                     };
+                    let callee = recvTy
-                    let callee = recvTy.and_then(|t| self.findMethod(&t, &c.name, 0));
+                        .and_then(|t| self.findMethod(&t, &c.name, 0))
+                        .or_else(|| self.uniqueTraitMethod(&c.name));
                     if c.line != 0 {
                         self.pos = (c.line, c.column);
                     }
@@ -959,6 +1095,7 @@ impl<'a> Cx<'a> {
                 patternNames(b.pattern(), &mut names);
                 for n in names {
                     self.env.remove(&n);
+                    self.views.remove(&n);
                 }
                 if let Some(g) = &b.case.guard {
                     self.walk(g);
@@ -987,6 +1124,17 @@ impl<'a> Cx<'a> {
 }
 /// Param `i`, clamped to a trailing variadic param.
+/// Two methods take `self` and every param in the same way (as a call site sees it).
+fn sameModes(a: &Fn, b: &Fn) -> bool {
+    let takes = |p: &Param| {
+        p.isOwn
+            || matches!(&p.ty, ParamType::Type(t) | ParamType::Variadic(t) if isGeneric(&t.name))
+    };
+    a.ownSelf == b.ownSelf
+        && a.params.len() == b.params.len()
+        && a.params.iter().zip(&b.params).all(|(x, y)| takes(x) == takes(y))
+}
 fn paramAt(f: &Fn, i: usize) -> Option<&Param> {
     f.params.get(i).or_else(|| {
         f.params

plum-checker/tests/fixtures/custom_actor_probe2.plum ADDED Viewed

@@ -0,0 +1,58 @@
+import std/Int
+import std/Float
+import std/Str
+import std/Slice
+own record Node(id: Int, x: Float, y: Float, kind: Kind)
+enum Kind =
+  | Group(children: Slice[Node])
+  | Label(text: Str, size: Float)
+  | Custom(actor: Actor)
+# Behaviour only: the game's records embed it, like Box<dyn Actor>.
+trait Actor =
+  fun act(self, own n: Node, dt: Float) -> Node
+  fun score(self, n: Node) -> Float
+record Ship(Actor, clock: Float) =
+  override fun act(self, own n: Node, dt: Float) -> Node =
+    self.clock = self.clock + dt
+    n
+  override fun score(self, n: Node) -> Float = self.clock
+record Orb(Actor, vx: Float) =
+  override fun act(self, own n: Node, dt: Float) -> Node =
+    n.x = n.x + self.vx * dt
+    n
+  override fun score(self, n: Node) -> Float = n.x
+fun actorOf(n: Node) -> Actor? = match n.kind
+  Custom(a) => a
+  _ => null
+fun update(own n: Node, dt: Float) -> Node =
+  if a := actorOf(n)
+    return a.act(n, dt)
+  match n.kind
+    Group(ks) =>
+      _ := ks.mapInPlace(|k| update(k, dt))
+    _ => 0
+  n
+fun total(n: Node) -> Float = match n.kind
+  Group(ks) =>
+    s := 0.0
+    for i := range ks.length()
+      s = s + total(ks.at(i))
+    s
+  Custom(a) => a.score(n)
+  Label(_, _) => 0.0
+test "custom_actor"
+  ks := Slice[Node]()
+  ks.push(Node(id: 1, x: 1.0, y: 0.0, kind: Custom(actor: Orb(vx: 2.0))))
+  ks.push(Node(id: 2, x: 0.0, y: 0.0, kind: Custom(actor: Ship(clock: 0.0))))
+  root := Node(id: 0, x: 0.0, y: 0.0, kind: Group(children: ks))
+  r := update(root, 0.5)
+  assert total(r) == 2.0 + 0.5

plum-checker/tests/fixtures/g3_generic_funstar.plum ADDED Viewed

@@ -0,0 +1,34 @@
+module g3
+enum Link[T] =
+  | Nil
+  | Cons(head: T, tail: Link[T])
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun* items(self) *T =
+    cur := self
+    while true
+      if Cons(h, t) := cur
+        cur = t
+        yield h
+      else
+        break
+fun* collect(xs: Link[T]) *T -> Link[T] =
+  out: Link[T] := Nil
+  for x := range xs.items()
+    v := yield x
+    out = Cons(head: v, tail: out)
+  out
+fun both() -> Int =
+  a: Link[Int] := Cons(head: 1, tail: Cons(head: 2, tail: Nil))
+  b: Link[Str] := Cons(head: "x", tail: Nil)
+  ints := for x := range collect(a)
+    x
+  strs := for s := range collect(b)
+    s
+  ints.length() + strs.length()

plum-checker/tests/optional_unpinned_tests.rs CHANGED Viewed

@@ -55,7 +55,7 @@ fn annotated_bare_tag_ok() {
 #[test]
 fn generic_funstar_wired() {
-    let src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/../.superlite/repros/g3_generic_funstar.plum")).unwrap();
+    let src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/g3_generic_funstar.plum")).unwrap();
     let mut parser = tree_sitter::Parser::new();
     parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
     let tree = parser.parse(&src, None).unwrap();

plum-checker/tests/ownership_moves_test.rs CHANGED Viewed

@@ -163,3 +163,70 @@ fn alias_borrowed_param_rejected() {
     let t = texts("fun f(s: Sprite) -> Float =\n  t := s\n  t.x\n");
     assert!(t.iter().any(|m| m.starts_with("cannot store borrowed \"s\"")), "{t:?}");
 }
+const NODE_DEFS: &str = "\
+import std/Float
+import std/Slice
+own record Node(id: Int, x: Float, kind: Kind)
+enum Kind =
+  | Group(children: Slice[Node])
+  | Custom(actor: Actor)
+trait Actor =
+  fun act(self, own n: Node, dt: Float) -> Node
+fun consume(own n: Node) -> Node = n
+fun look(n: Node) -> Float = n.x
+fun first(n: Node) -> Node? = match n.kind
+  Group(ks) => ks.at(0)
+  _ => null
+fun actorOf(n: Node) -> Actor? = match n.kind
+  Custom(a) => a
+  _ => null
+";
+fn node_texts(body: &str) -> Vec<String> {
+    checkOwnership(&parse(&format!("{NODE_DEFS}\n{body}\n")))
+        .into_iter()
+        .map(|e| e.message)
+        .collect()
+}
+#[test]
+fn own_field_used_after_move_rejected() {
+    let t = node_texts("fun f(own n: Node) -> Float =\n  m := consume(n)\n  n.x\n");
+    assert!(t.iter().any(|m| m.starts_with("\"n\" used after it was moved")), "{t:?}");
+}
+#[test]
+fn own_child_projection_after_move_rejected() {
+    let t = node_texts(
+        "fun f(own n: Node) -> Float =\n  match n.kind\n    Group(ks) =>\n      m := consume(n)\n      ks.len()\n    _ => 0.0\n",
+    );
+    assert!(t.iter().any(|m| m.contains("used after it was moved")), "{t:?}");
+    // An element read out of the child slice is a view too.
+    let t2 = node_texts(
+        "fun f(own n: Node) -> Float =\n  match n.kind\n    Group(ks) =>\n      c := ks.at(0)\n      m := consume(n)\n      look(c)\n    _ => 0.0\n",
+    );
+    assert!(t2.iter().any(|m| m.contains("used after it was moved")), "{t2:?}");
+    // An own-typed payload binder is a view into the scrutinee's root.
+    let defs = "own record Cell(id: Int, kind: Shape)\nenum Shape =\n  | Pair(first: Cell)\n  | Leaf(x: Float)\nfun eat(own n: Cell) -> Cell = n\nfun peek(n: Cell) -> Int = n.id\n";
+    let body = "fun f(own n: Cell) -> Int =\n  match n.kind\n    Pair(k) =>\n      m := eat(n)\n      peek(k)\n    _ => 0\n";
+    let t3: Vec<String> = checkOwnership(&parse(&format!("{defs}\n{body}\n"))).into_iter().map(|e| e.message).collect();
+    assert!(t3.iter().any(|m| m.contains("used after it was moved")), "{t3:?}");
+    let ok = "fun f(own n: Cell) -> Int =\n  match n.kind\n    Pair(k) =>\n      v := peek(k)\n      m := eat(n)\n      v\n    _ => 0\n";
+    let t4: Vec<String> = checkOwnership(&parse(&format!("{defs}\n{ok}\n"))).into_iter().map(|e| e.message).collect();
+    assert!(t4.is_empty(), "{t4:?}");
+}
+#[test]
+fn non_own_value_read_before_move_ok() {
+    let t = node_texts(
+        "fun f(own n: Node, dt: Float) -> Node =\n  if a := actorOf(n)\n    return a.act(n, dt)\n  n\n",
+    );
+    assert!(t.is_empty(), "{t:?}");
+    let t2 = node_texts("fun g(own n: Node) -> Float =\n  v := n.x\n  m := consume(n)\n  v\n");
+    assert!(t2.is_empty(), "{t2:?}");
+}

plum-checker/tests/ownership_trait_args_test.rs ADDED Viewed

@@ -0,0 +1,73 @@
+#![allow(non_snake_case)]
+use plum_checker::ownership::checkOwnership;
+use plum_core::{ast::Source, AstParser};
+fn parse(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(
+        !tree.root_node().has_error(),
+        "embedded test source has parse errors:\n{src}"
+    );
+    AstParser::new(src).parseSource(tree.root_node())
+}
+const PROBE: &str = include_str!("fixtures/custom_actor_probe2.plum");
+fn texts(body: &str) -> Vec<String> {
+    checkOwnership(&parse(&format!("{PROBE}\n{body}\n")))
+        .into_iter()
+        .map(|e| e.message)
+        .collect()
+}
+#[test]
+fn trait_method_borrowed_arg_ok() {
+    let t = texts("");
+    assert!(t.is_empty(), "{t:?}");
+}
+#[test]
+fn trait_method_own_arg_moves() {
+    let t = texts("fun g(own n: Node, a: Actor) -> Float =\n  m := a.act(n, 0.1)\n  n.x\n");
+    assert!(t.iter().any(|m| m.starts_with("\"n\" used after it was moved")), "{t:?}");
+}
+#[test]
+fn borrowed_to_own_trait_param_rejected() {
+    let t = texts("fun h(n: Node, a: Actor) -> Node = a.act(n, 0.1)\n");
+    assert!(t.iter().any(|m| m.contains("cannot store borrowed \"n\"")), "{t:?}");
+}
+#[test]
+fn plain_fn_borrowed_arg_still_ok() {
+    let t = texts("fun look(n: Node) -> Float = n.x\nfun k(n: Node) -> Float = look(n)\n");
+    assert!(t.is_empty(), "{t:?}");
+}
+#[test]
+fn same_name_method_modes_disagree_is_conservative() {
+    let t = texts(
+        "trait Probe =\n  fun f(self, n: Node) -> Float\n\nrecord Sq(Probe, w: Float) =\n  override fun f(self, n: Node) -> Float = n.x\n\nrecord Other(w: Float) =\n  fun f(self, own n: Node) -> Float = n.x\n\nfun u(n: Node) -> Float = match n.kind\n  Custom(a) => a.f(n)\n  _ => 0.0\n",
+    );
+    assert!(t.iter().any(|m| m.contains("cannot store borrowed \"n\"")), "{t:?}");
+}
+#[test]
+fn same_name_method_modes_agree_uses_them() {
+    let t = texts(
+        "record Other(w: Float) =\n  fun score(self, n: Node) -> Float = n.x\n\nfun u(n: Node) -> Float = match n.kind\n  Custom(a) => a.score(n)\n  _ => 0.0\n",
+    );
+    assert!(t.is_empty(), "{t:?}");
+}
+#[test]
+fn pattern_bound_trait_receiver_resolves_despite_same_name_method() {
+    let t = texts(
+        "trait Drawer =\n  fun draw(self, n: Node) -> Float\n\nrecord Pen(Drawer, w: Float) =\n  override fun draw(self, n: Node) -> Float = n.x\n\nrecord Stage2(w: Float) =\n  fun draw(self) -> Float = self.w\n\nenum Hold =\n  | Mine(d: Drawer)\n\nown record Item(h: Hold)\n\nfun u(i: Item, n: Node) -> Float = match i.h\n  Mine(d) => d.draw(n)\n",
+    );
+    assert!(t.is_empty(), "{t:?}");
+}

plum-checker/tests/variant_pattern_tests.rs ADDED Viewed

@@ -0,0 +1,47 @@
+#![allow(non_snake_case)]
+//! A bare variant name in a pattern: valid for payload-less variants and union-enum
+//! members, a positioned error for an inline variant that has fields.
+use plum_checker::checkSource;
+use plum_core::unions::{beginPlan, hoistInlineVariants, resolveMembers, takePlan};
+use plum_core::AstParser;
+const DEFS: &str = "\
+enum Act = Stop | MoveBy(dx: Int, dy: Int)
+record Circle(r: Float)
+record Dot(x: Int)
+enum Shape = Circle | Dot
+";
+fn run(body: &str) -> Result<(), Vec<String>> {
+    let src = format!("{DEFS}\n{body}\n");
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(&src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
+    let mut source = AstParser::new(&src).parseSource(tree.root_node());
+    let errs = hoistInlineVariants(&mut source);
+    assert!(errs.is_empty(), "{errs:?}");
+    let errs = resolveMembers(&mut source);
+    assert!(errs.is_empty(), "{errs:?}");
+    beginPlan();
+    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
+    takePlan();
+    r
+}
+#[test]
+fn bare_payload_variant_pattern_rejected() {
+    let e = run("fun f(a: Act) -> Int =\n  match a\n    MoveBy => 1\n    _ => 0")
+        .expect_err("bare payload variant must be rejected")
+        .join(" | ");
+    assert!(e.contains("MoveBy has fields"), "{e}");
+    run("fun f(a: Act) -> Int =\n  match a\n    MoveBy(_, _) => 1\n    _ => 0").unwrap();
+}
+#[test]
+fn bare_unit_variant_pattern_ok() {
+    run("fun f(a: Act) -> Int =\n  match a\n    Stop => 1\n    _ => 0").unwrap();
+    run("fun f(s: Shape) -> Int =\n  match s\n    Circle => 1\n    Dot => 2").unwrap();
+}

plum-core/src/union_lower.rs CHANGED Viewed

@@ -677,7 +677,8 @@ fn synthesize(
         .params
         .iter()
         .map(|p| Param {
+            // The forwarder hands the value straight on, so it takes it exactly as declared.
-isOwn: false,
+            isOwn: p.isOwn,
             name: p.name.clone(),
             ty: substParam(&p.ty, &map),
             default: p.default.clone(),
@@ -715,7 +716,7 @@ isOwn: false,
         })
         .collect();
     Some(Fn {
-ownSelf: false,
+        ownSelf: decl.ownSelf,
         name: method.to_string(),
         file: decl.file.clone(),
         line: 0,

plum-core/tests/forwarder_own_test.rs ADDED Viewed

@@ -0,0 +1,51 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::union_lower::applyPlan;
+use plum_core::unions::UnionPlan;
+use plum_core::AstParser;
+fn parse(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "{}", tree.root_node().to_sexp());
+    AstParser::new(src).parseSource(tree.root_node())
+}
+const SRC: &str = "struct Circle(r: Float) =\n  fun grow(self, own c: Circle, k: Float) -> Float = 1.0\nstruct Square(w: Float) =\n  fun grow(self, own c: Circle, k: Float) -> Float = 2.0\nenum Shape = Circle | Square\nfun f(s: Shape, c: Circle) -> Float =\n  s.grow(c, 1.0)\n";
+#[test]
+fn synthesized_forwarder_copies_own_flags() {
+    let mut s = parse(SRC);
+    let call = s
+        .items
+        .iter()
+        .find_map(|i| match i {
+            Item::Fn(f) if f.name == "f" => match &f.body {
+                FnBody::Block(b) => match &b.stmts[0] {
+                    Stmt::Expr(e, ..) => Some(e as *const Expr as usize),
+                    _ => None,
+                },
+                _ => None,
+            },
+            _ => None,
+        })
+        .unwrap();
+    let mut plan = UnionPlan::default();
+    plan.dispatches
+        .insert(call, vec!["Shape__Circle".into(), "Shape__Square".into()]);
+    applyPlan(&mut s, &plan);
+    let g = s
+        .items
+        .iter()
+        .find_map(|i| match i {
+            Item::Fn(f) if f.name == "grow" && f.type_param.as_deref() == Some("Shape") => Some(f),
+            _ => None,
+        })
+        .expect("no synthesized grow");
+    let own: Vec<bool> = g.params.iter().map(|p| p.isOwn).collect();
+    assert_eq!(own, vec![true, false]);
+    assert!(!g.ownSelf);
+}

plum-examples/game_pure_scene.plum CHANGED Viewed

@@ -5,9 +5,10 @@
 # restarts after the game is over.
 #
 # What differs from game_scene.plum. There, actors are mutable objects that point at
-# their parent and `stage.act` changes them in place. Here every actor (`Ship`, `Orb`,
+# their parent and `stage.act` changes them in place. Here the scene is made of `Node` values
+# (std `Group`, `Sprite`, `Label`, `Button` kinds, and `Custom` nodes whose behaviour is a
-# `Mine`, `Star`, `Panel` and the std `Group`, `Sprite`, `Label`, `Button`) is a value:
+# record embedding `Actor`: `Ship`, `Orb`, `Mine`, `Star`, `Panel`):
-# `act` returns the next actor, `Stage.frame` returns a new `Stage`, and a change from the
+# `act` returns the next node, `Stage.frame` returns a new `Stage`, and a change from the
 # rules ("this orb is collected", "show the game-over panel") is a `SceneTree.modify`
 # on an actor id that returns a new tree. The `World` record below is the mutable shell the
 # host talks to: it keeps the current `Stage` and the run's state (score, lives, the ship's
@@ -141,232 +142,217 @@ fun shipStep(s: ShipState, ax: Float, ay: Float, dt: Float) -> ShipState =
 fun newShip() -> ShipState =
   ShipState(x: Rules.ArenaW / 2.0, y: Rules.ArenaH / 2.0, vx: 0.0, vy: 0.0, rotation: 0.0, hurt: 0.0)
-# The centre of an actor drawn as a sprite-sized box.
+# The centre of a node drawn as a sprite-sized box.
-fun cx(a: Actor) -> Float =
+fun cx(n: Node) -> Float =
-  a.x + a.width / 2.0
+  n.x + n.width / 2.0
-fun cy(a: Actor) -> Float =
+fun cy(n: Node) -> Float =
-  a.y + a.height / 2.0
+  n.y + n.height / 2.0
+# Actor kinds of this game. Each holds only its own fields; position and size live on
-# Actor kinds of this game. Each is a sprite-sized actor; `create` takes the centre.
+# the `Node`. Each `create` returns a sprite-sized node; it takes the centre.
-# A filled rectangle.
+# A filled rectangle; its colour is the node's.
-own record Panel(
+record Panel(Actor) =
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions)) =
-  fun create(id: Int, x: Float, y: Float, w: Float, h: Float, c: Color) -> Panel =
+  fun create(id: Int, x: Float, y: Float, w: Float, h: Float, c: Color) -> Node =
-    Panel(
-      id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
-      touchable: Disabled, actions: Slice[Action]())
+    n := PureScene.custom(id, x, y, w, h, Panel())
+    n.color = c
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
     p := m.apply(Vec2(x: 0.0, y: 0.0))
-    drawRect(p.x, p.y, self.width * m.scaleX(), self.height * m.scaleY(), tint)
+    drawRect(p.x, p.y, n.width * m.scaleX(), n.height * m.scaleY(), tint)
 # The player: only a picture that follows `ShipState`; `act` runs its animation clock.
-own record Ship(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  clock: Float, tex: Int) =
+record Ship(Actor, clock: Float, tex: Int) =
-  fun create(sheet: Int, s: ShipState) -> Ship =
-    Ship(
-      id: Id.Ship, x: s.x - Rules.Half, y: s.y - Rules.Half, width: Rules.Size, height: Rules.Size,
-      originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
-      clock: 0.0, tex: sheet)
+  fun create(sheet: Int, s: ShipState) -> Node =
+    n := PureScene.custom(Id.Ship, s.x - Rules.Half, s.y - Rules.Half, Rules.Size, Rules.Size, Ship(clock: 0.0, tex: sheet))
+    n.originX = Rules.Half
+    n.originY = Rules.Half
+    n
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
     self.clock = self.clock + dt
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
-    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
+    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
     drawCircle(c.x, c.y, 17.0 * m.scaleX(), Color(r: 0.4, g: 0.8, b: 1.0, a: 0.12 * tint.a))
     frame := Float(frameOf(self.clock, 4, 14.0))
-    pureDrawSprite(m, tint, self.width, self.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
+    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 0.0, Rules.Cell, Rules.Cell)
 # A glowing orb drifting about. `phase` offsets its animation from the other orbs.
-own record Orb(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
+record Orb(Actor, vx: Float, vy: Float, phase: Float, clock: Float, tex: Int) =
-  fun create(sheet: Int, phase: Float, id: Int, at: Motion) -> Orb =
-    Orb(
-      id: id, x: at.x - Rules.Half, y: at.y - Rules.Half, width: Rules.Size, height: Rules.Size,
-      originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
-      vx: at.vx, vy: at.vy, phase: phase, clock: 0.0, tex: sheet)
+  fun create(sheet: Int, phase: Float, id: Int, at: Motion) -> Node =
+    Orb.createAt(sheet, phase, id, at, 0.0)
+  # An orb that carries on an animation `clock`, so a respawn or freeze never jumps a frame.
-  fun motion(self) -> Motion =
+  fun createAt(sheet: Int, phase: Float, id: Int, at: Motion, clock: Float) -> Node =
-    Motion(x: self.x + Rules.Half, y: self.y + Rules.Half, vx: self.vx, vy: self.vy)
+    n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
+      Orb(vx: at.vx, vy: at.vy, phase: phase, clock: clock, tex: sheet))
+    n.originX = Rules.Half
+    n.originY = Rules.Half
+    n
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
-    m := driftOf(self.motion(), Rules.OrbRadius, dt)
+    m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.OrbRadius, dt)
     self.clock = self.clock + dt
-    self.x = m.x - Rules.Half
+    n.x = m.x - Rules.Half
-    self.y = m.y - Rules.Half
+    n.y = m.y - Rules.Half
     self.vx = m.vx
     self.vy = m.vy
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
-    c := m.apply(Vec2(x: self.width / 2.0, y: self.height / 2.0))
+    c := m.apply(Vec2(x: n.width / 2.0, y: n.height / 2.0))
     k := m.scaleX()
     blendMode(Blend.Add)
     drawCircle(c.x, c.y, 26.0 * k, Color(r: 0.35, g: 0.22, b: 0.0, a: 0.5 * tint.a))
     drawCircle(c.x, c.y, 17.0 * k, Color(r: 0.6, g: 0.4, b: 0.05, a: 0.5 * tint.a))
     blendMode(Blend.Normal)
     frame := Float(frameOf(self.clock + self.phase, 4, 8.0))
-    pureDrawSprite(m, tint, self.width, self.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
+    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, Rules.Cell, Rules.Cell, Rules.Cell)
 # A mine drifting about, turning `spin` radians per second (0 once the game is over).
-own record Mine(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  vx: Float, vy: Float, spin: Float, clock: Float, tex: Int) =
+record Mine(Actor, vx: Float, vy: Float, spin: Float, clock: Float, tex: Int) =
-  fun create(sheet: Int, id: Int, at: Motion, spin: Float) -> Mine =
+  fun create(sheet: Int, id: Int, at: Motion, spin: Float) -> Node =
-    Mine(
-      id: id, x: at.x - Rules.Half, y: at.y - Rules.Half, width: Rules.Size, height: Rules.Size,
-      originX: Rules.Half, originY: Rules.Half, scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
-      color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
-      vx: at.vx, vy: at.vy, spin: spin, clock: 0.0, tex: sheet)
+    Mine.createAt(sheet, id, at, spin, 0.0)
+  fun createAt(sheet: Int, id: Int, at: Motion, spin: Float, clock: Float) -> Node =
+    n := PureScene.custom(id, at.x - Rules.Half, at.y - Rules.Half, Rules.Size, Rules.Size,
+      Mine(vx: at.vx, vy: at.vy, spin: spin, clock: clock, tex: sheet))
+    n.originX = Rules.Half
+    n.originY = Rules.Half
+    n
-  fun motion(self) -> Motion =
-    Motion(x: self.x + Rules.Half, y: self.y + Rules.Half, vx: self.vx, vy: self.vy)
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
-    m := driftOf(self.motion(), Rules.MineRadius, dt)
+    m := driftOf(Motion(x: n.x + Rules.Half, y: n.y + Rules.Half, vx: self.vx, vy: self.vy), Rules.MineRadius, dt)
     self.clock = self.clock + dt
-    self.x = m.x - Rules.Half
+    n.x = m.x - Rules.Half
-    self.y = m.y - Rules.Half
+    n.y = m.y - Rules.Half
     self.vx = m.vx
     self.vy = m.vy
-    self.rotation = self.rotation + self.spin * dt
+    n.rotation = n.rotation + self.spin * dt
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
     frame := Float(frameOf(self.clock, 4, 4.0))
-    pureDrawSprite(m, tint, self.width, self.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
+    pureDrawSprite(m, tint, n.width, n.height, self.tex, frame * Rules.Cell, 2.0 * Rules.Cell, Rules.Cell, Rules.Cell)
 # A background star that twinkles.
-own record Star(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  seed: Float, clock: Float) =
+record Star(Actor, seed: Float, clock: Float) =
-  fun create(i: Int) -> Star =
+  fun create(i: Int) -> Node =
     r := 1.0 + Float(i % 3) * 0.5
-    Star(
-      id: Id.Star + i, x: Float({i * 7919} % 800) - r, y: Float({i * 104729} % 600) - r,
+    PureScene.custom(Id.Star + i, Float({i * 7919} % 800) - r, Float({i * 104729} % 600) - r, r * 2.0, r * 2.0,
-      width: r * 2.0, height: r * 2.0, originX: 0.0, originY: 0.0, scaleX: 1.0, scaleY: 1.0,
-      rotation: 0.0, color: Color.White, visible: true, touchable: Disabled, actions: Slice[Action](),
-      seed: Float(i), clock: 0.0)
+      Star(seed: Float(i), clock: 0.0))
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
     self.clock = self.clock + dt
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
     twinkle := 0.25 + 0.2 * Math.sin(self.clock * 2.0 + self.seed)
-    r := self.width / 2.0
+    r := n.width / 2.0
     c := m.apply(Vec2(x: r, y: r))
     drawCircle(c.x, c.y, r * m.scaleX(), Color(r: 0.7, g: 0.8, b: 1.0, a: twinkle * tint.a))
 # --- reading and changing the tree ---
 # The child of `a` reached by `path` (not empty), borrowed from the tree.
-fun nodeAt(a: Actor, path: Slice[Int], depth: Int) -> Actor =
+fun nodeAt(a: Node, path: Slice[Int], depth: Int) -> Node =
   ks := kidsOf(a)
   i := path.at(depth)
   if depth + 1 >= path.length()
     return ks.at(i)
   nodeAt(ks.at(i), path, depth + 1)
-# The actor with `id` below `root`, searched depth first, borrowed from the tree.
+# The node with `id` below `root`, searched depth first, borrowed from the tree.
-fun find(root: Actor, id: Int) -> Actor =
+fun find(root: Node, id: Int) -> Node =
   path := SceneTree.findPath(root, id) ?: crash "no such actor"
   nodeAt(root, path, 0)
-fun kidsOf(a: Actor) -> Slice[Actor] =
+fun kidsOf(n: Node) -> Slice[Node] =
-  a.kids() ?: crash "not a group"
+  PureScene.childrenOf(n) ?: crash "not a group"
-fun setVisible(own a: Actor, v: Bool) -> Actor =
+fun setVisible(own n: Node, v: Bool) -> Node =
-  a.visible = v
+  n.visible = v
-  a
+  n
 # The group `g` with `k` added as its last child.
-fun addKid(own g: Actor, own k: Actor) -> Actor =
+fun addKid(own g: Node, own k: Node) -> Node =
   ks := kidsOf(g)
   ks.push(k)
   g
-fun clockOf(a: Actor) -> Float =
+fun actorClock(a: Actor) -> Float =
   match a
-    Mine(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, clock, _) => clock
+    Mine(_, _, _, clock, _) => clock
-    Orb(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, clock, _) => clock
+    Orb(_, _, _, clock, _) => clock
-    Star(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, clock) => clock
+    Star(_, clock) => clock
     _ => 0.0
+fun clockOf(n: Node) -> Float =
+  match n.kind
+    Custom(a) => actorClock(a)
+    _ => 0.0
-fun textOf(a: Actor) -> Str =
+fun textOf(n: Node) -> Str =
-  match a
+  match n.kind
-    Label(_, _, _, _, _, _, _, _, _, _, _, _, _, _, text, _) => text
+    Label(text, _) => text
     _ => ""
-fun hudLabel(id: Int, text: Str, x: Float, y: Float, size: Float, c: Color) -> Actor =
+fun hudLabel(id: Int, text: Str, x: Float, y: Float, size: Float, c: Color) -> Node =
   l := PureScene.label(id, text, x, y, size)
   l.color = c
   l
-fun icon(sheet: Int, i: Int) -> Actor =
+fun icon(sheet: Int, i: Int) -> Node =
   s := PureScene.sprite(Id.Icon + i, sheet, Rules.ArenaW - 40.0 - Float(i) * 36.0, 12.0, 32.0, 32.0)
-  s.srcX = 0.0
-  s.srcY = 0.0
-  s.srcW = Rules.Cell
+  s.kind = Sprite(tex: sheet, srcX: 0.0, srcY: 0.0, srcW: Rules.Cell, srcH: Rules.Cell)
-  s.srcH = Rules.Cell
   s
 # The whole scene: backdrop, stars, mines, orbs, ship and HUD layers, in drawing order.
 # The layer groups are 0 x 0 so they never swallow a click; the HUD holds the
 # game-over overlay with its restart button.
-fun buildRoot(rng: Random, sheet: Int, best: Int) -> Actor =
+fun buildRoot(rng: Random, sheet: Int, best: Int) -> Node =
   ship := newShip()
-  stars := Slice[Actor]()
+  stars := Slice[Node]()
   for i := range 40
     stars.push(Star.create(i))
-  mines := Slice[Actor]()
+  mines := Slice[Node]()
-  orbs := Slice[Actor]()
+  orbs := Slice[Node]()
   for i := range Rules.OrbCount
     orbs.push(Orb.create(sheet, Float(i) * 0.1, Id.Orb + i, spawn(rng, ship.x, ship.y, 120.0, 40.0)))
   for i := range mineCount(0)
     mines.push(Mine.create(sheet, Id.Mine + i, spawn(rng, ship.x, ship.y, 220.0, 90.0), 2.0))
-  over := Slice[Actor]()
-  over.push(Panel.create(Id.OverlayPanel, 0.0, 230.0, Rules.ArenaW, 170.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)))
-  over.push(hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red))
-  over.push(hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White))
   btn := PureScene.button(Id.Restart, "Again", sheet, sheet, 340.0, 342.0, 120.0, 44.0)
   btn.color = Color(r: 0.5, g: 0.8, b: 1.0, a: 0.9)
   btn.visible = false
-  over.push(btn)
+  over := Slice(
+    Panel.create(Id.OverlayPanel, 0.0, 230.0, Rules.ArenaW, 170.0, Color(r: 0.0, g: 0.0, b: 0.0, a: 0.6)),
+    hudLabel(Id.OverTitle, "Game over", 300.0, 244.0, 48.0, Color.Red),
+    hudLabel(Id.OverHint, "Press Enter to play again", 270.0, 300.0, 24.0, Color.White),
+    btn)
   overlay := PureScene.group(Id.Overlay, 0.0, 0.0, 0.0, 0.0, over)
   overlay.visible = false
-  hud := Slice[Actor]()
+  hud := Slice(
-  hud.push(hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White))
+    hudLabel(Id.Score, "Score 0", 16.0, 12.0, 28.0, Color.White),
-  hud.push(hudLabel(Id.Best, "Best {best}", 16.0, 44.0, 20.0, Color.Yellow))
+    hudLabel(Id.Best, "Best {best}", 16.0, 44.0, 20.0, Color.Yellow))
   for i := range Rules.StartLives
     hud.push(icon(sheet, i))
   hud.push(overlay)
-  layers := Slice[Actor]()
+  layers := Slice(
-  layers.push(Panel.create(Id.Backdrop, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)))
+    Panel.create(Id.Backdrop, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, Color.rgb(0.07, 0.08, 0.16)),
-  layers.push(PureScene.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars))
+    PureScene.group(Id.StarLayer, 0.0, 0.0, 0.0, 0.0, stars),
-  layers.push(PureScene.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines))
+    PureScene.group(Id.MineLayer, 0.0, 0.0, 0.0, 0.0, mines),
-  layers.push(PureScene.group(Id.OrbLayer, 0.0, 0.0, 0.0, 0.0, orbs))
+    PureScene.group(Id.OrbLayer, 0.0, 0.0, 0.0, 0.0, orbs),
-  layers.push(Ship.create(sheet, ship))
+    Ship.create(sheet, ship),
-  layers.push(PureScene.group(Id.Hud, 0.0, 0.0, 0.0, 0.0, hud))
+    PureScene.group(Id.Hud, 0.0, 0.0, 0.0, 0.0, hud))
   PureScene.group(Id.Root, 0.0, 0.0, Rules.ArenaW, Rules.ArenaH, layers)
 # --- the world ---
@@ -398,7 +384,7 @@ fun newWorld(seed: Int, sheet: Int) -> World =
     lives: Rules.StartLives, over: false, clock: 0.0, wasDown: false, sheet: sheet,
     pickupSound: -1, hitSound: -1, overSound: -1, musicSound: -1)
-fun swap(w: World, id: Int, f: fn(Actor) -> Actor) =
+fun swap(w: World, id: Int, f: fn(Node) -> Node) =
   w.stage.root = SceneTree.modify(w.stage.root, id, f)
 # Starts a fresh game, keeping the best score, the camera and the random stream.
@@ -436,32 +422,29 @@ fun freeze(w: World) =
     sheet := w.sheet
     swap(w, id, |a| stillMine(sheet, id, a))
-fun orbActor(sheet: Int, phase: Float, id: Int, at: Motion) -> Actor =
+fun orbActor(sheet: Int, phase: Float, id: Int, at: Motion) -> Node =
   Orb.create(sheet, phase, id, at)
 # A new orb that carries on `old`'s animation clock, so a respawn or freeze never jumps a frame.
-fun orbKeepClock(sheet: Int, phase: Float, id: Int, at: Motion, old: Actor) -> Actor =
+fun orbKeepClock(sheet: Int, phase: Float, id: Int, at: Motion, old: Node) -> Node =
-  o := Orb.create(sheet, phase, id, at)
+  Orb.createAt(sheet, phase, id, at, clockOf(old))
-  o.clock = clockOf(old)
-  o
-fun mineActor(sheet: Int, id: Int, at: Motion, spin: Float) -> Actor =
+fun mineActor(sheet: Int, id: Int, at: Motion, spin: Float) -> Node =
   Mine.create(sheet, id, at, spin)
-fun stillMine(sheet: Int, id: Int, a: Actor) -> Actor =
+fun stillMine(sheet: Int, id: Int, a: Node) -> Node =
-  m := Mine.create(sheet, id, Motion(x: cx(a), y: cy(a), vx: 0.0, vy: 0.0), 0.0)
+  m := Mine.createAt(sheet, id, Motion(x: cx(a), y: cy(a), vx: 0.0, vy: 0.0), 0.0, clockOf(a))
   m.rotation = a.rotation
-  m.clock = clockOf(a)
   m
-# Moves the ship actor to the ship state; it blinks while it is hurt, and is hidden once the game is over.
+# Moves the ship node to the ship state; it blinks while it is hurt, and is hidden once the game is over.
 fun showShip(w: World) =
   blink := w.ship.hurt > 0.0 && frameOf(w.clock, 2, 10.0) == 0
   visible := !w.over && !blink
   s := w.ship
   swap(w, Id.Ship, |a| shipActor(a, s, visible))
-fun shipActor(own a: Actor, s: ShipState, visible: Bool) -> Actor =
+fun shipActor(own a: Node, s: ShipState, visible: Bool) -> Node =
   a.x = s.x - Rules.Half
   a.y = s.y - Rules.Half
   a.rotation = s.rotation
@@ -662,12 +645,13 @@ test "drifters bounce off the walls"
   b := driftOf(Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0), Rules.OrbRadius, 0.1)
   assert b.vx == -100.0
   assert b.x == Rules.ArenaW - 10.0
-  orb := Orb.create(-1, 0.0, Id.Orb, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0)).act(0.1)
+  orb := Orb.create(-1, 0.0, Id.Orb, Motion(x: 795.0, y: 300.0, vx: 100.0, vy: 0.0))
+  moved := SceneTree.update(orb, 0.1)
-  assert near(cx(orb), Rules.ArenaW - 10.0)
+  assert near(cx(moved), Rules.ArenaW - 10.0)
 test "a mine spins as it drifts"
   mine := Mine.create(-1, Id.Mine, Motion(x: 400.0, y: 300.0, vx: 10.0, vy: 0.0), 2.0)
-  next := mine.act(0.5)
+  next := SceneTree.update(mine, 0.5)
   assert near(next.rotation, 1.0)
   assert near(cx(next), 405.0)

plum-game/web-test/fixtures/stress_pure_scene.plum CHANGED Viewed

@@ -1,7 +1,7 @@
 # The stress scene of stress_scene.plum on the PURE scene graph (std/game/PureScene):
 # 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
 # 1x1 white texture), 50 texts with a changing number, drawn through a camera. Every
-# actor is an own value: each frame changes the tree in place with SceneTree.update. Group and
+# node is an own value: each frame changes the tree in place with SceneTree.update. Group and
 # sprite spin comes from `forever(rotateBy(...))` actions; drifting and counting
 # actors do theirs in `act`.
 module stress_pure_scene
@@ -43,71 +43,60 @@ fun caption(m: Affine, tint: Color, s: Str, size: Float) =
   drawText(s, p.x, p.y, size * m.scaleY(), tint)
 # A square of the white texture that moves by (dx, dy) per frame and wraps.
-own record Drifter(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  tex: Int, dx: Float, dy: Float) =
+record Drifter(Actor, tex: Int, dx: Float, dy: Float) =
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
-    self.x = self.x + self.dx
+    n.x = n.x + self.dx
-    self.y = self.y + self.dy
+    n.y = n.y + self.dy
-    if self.x > Float(Counts.WorldW)
+    if n.x > Float(Counts.WorldW)
-      self.x = self.x - Float(Counts.WorldW)
+      n.x = n.x - Float(Counts.WorldW)
-    if self.y > Float(Counts.WorldH)
+    if n.y > Float(Counts.WorldH)
-      self.y = self.y - Float(Counts.WorldH)
+      n.y = n.y - Float(Counts.WorldH)
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
-    quad(m, tint, self.width, self.height, self.tex, 0.0, 0.0, 0.0, 0.0)
+    quad(m, tint, n.width, n.height, self.tex, 0.0, 0.0, 0.0, 0.0)
 # Shows "n <count>" and counts up each frame.
-own record CountLabel(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  n: Int, text: Str) =
+record CountLabel(Actor, n: Int, text: Str) =
-  override fun act(own self, dt: Float) -> Actor =
+  override fun act(self, own n: Node, dt: Float) -> Node =
     self.n = self.n + 1
     self.text = "n {self.n}"
-    self
+    n
-  override fun draw(self, m: Affine, tint: Color) =
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
     caption(m, tint, self.text, 14.0)
-fun drifter(id: Int, tex: Int, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Actor =
+fun drifter(id: Int, tex: Int, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Node =
-  d := Drifter(
-    id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-    scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: c, visible: true,
-    touchable: Disabled, actions: Slice[Action](), tex: tex, dx: dx, dy: dy)
+  d := Drifter(tex: tex, dx: dx, dy: dy)
   me: Actor := d
+  n := PureScene.custom(id, x, y, w, h, me)
+  n.color = c
-  me
+  n
-fun countLabel(id: Int, n: Int, x: Float, y: Float) -> Actor =
+fun countLabel(id: Int, n: Int, x: Float, y: Float) -> Node =
-  l := CountLabel(
-    id: id, x: x, y: y, width: 60.0, height: 14.0, originX: 0.0, originY: 0.0,
-    scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-    touchable: Disabled, actions: Slice[Action](), n: n, text: "n {n}")
+  l := CountLabel(n: n, text: "n {n}")
   me: Actor := l
-  me
+  PureScene.custom(id, x, y, 60.0, 14.0, me)
 fun spinning(rate: Float) -> Slice[Action] =
   acts := Slice[Action]()
   acts.push(Actions.forever(Actions.rotateBy(rate, 1.0)))
   acts
-fun dancer(id: Int, sheet: Int, j: Int, i: Int) -> Actor =
+fun dancer(id: Int, sheet: Int, j: Int, i: Int) -> Node =
   s := PureScene.sprite(id, sheet, Float({j * j * 13 + j * 37} % 150), Float({j * j * 29 + j * 53} % 170), 16.0, 16.0)
   s.originX = 8.0
   s.originY = 8.0
   s.rotation = Float(i)
-  s.srcX = Float(i % 4 * 16)
+  s.kind = Sprite(tex: sheet, srcX: Float(i % 4 * 16), srcY: 0.0, srcW: 16.0, srcH: 16.0)
-  s.srcW = 16.0
-  s.srcH = 16.0
   s.actions = spinning(1.2)
-  me: Actor := s
-  me
+  s
 fun buildWorld(sheet: Int, white: Int) -> World =
-  root := Slice[Actor]()
+  root := Slice[Node]()
   per := Counts.Sprites / Counts.Groups
   for gi := range Counts.Groups
-    kids := Slice[Actor]()
+    kids := Slice[Node]()
     for j := range per
       i := gi * per + j
       kids.push(dancer(1000 + i, sheet, j, i))
@@ -115,15 +104,14 @@ fun buildWorld(sheet: Int, white: Int) -> World =
     g.originX = 75.0
     g.originY = 85.0
     g.actions = spinning(0.24)
-    me: Actor := g
-    root.push(me)
+    root.push(g)
   for i := range Counts.Rects
     root.push(drifter(10000 + i, white, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
   for i := range Counts.Circles
     root.push(drifter(20000 + i, white, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
   for i := range Counts.Texts
     root.push(countLabel(30000 + i, i, Float(i * 30 % Counts.WorldW), Float(i * 17 % Counts.WorldH)))
-  top: Actor := PureScene.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
+  top := PureScene.group(1, 0.0, 0.0, Float(Counts.WorldW), Float(Counts.WorldH), root)
   cam := Affine(a: 0.8, b: 0.0, c: 0.0, d: 0.8, e: 0.0, f: 0.0)
   World(sheet: sheet, stage: Stage(root: top, camera: cam, captured: null))
@@ -151,7 +139,7 @@ test "ten frames of update run"
   w := buildWorld(0, 0)
   for i := range 10
     update(w, 0.016)
-  if k := w.stage.root.kids()
+  if k := PureScene.childrenOf(w.stage.root)
     assert k.length() == 50 + 500 + 200 + 50
     assert {k.at(50).x - 20.0}.abs() < 0.000001
   else

plum-std/game/Actions.plum CHANGED Viewed

@@ -14,20 +14,18 @@ import std/Float
 # The animated part of an actor's transform.
 struct Pose(x: Float, y: Float, rotation: Float, scaleX: Float, scaleY: Float)
+# One action. `elapsed` and `current` (the running lap of a `Forever`, null
+# before it starts) are the mutable state; `kind` is the immutable description.
+# A `Forever`'s `template` is the pristine action restarted each lap.
+record Action(elapsed: Float, current: Action?, kind: ActionKind)
+enum ActionKind =
-record MoveBy(dx: Float, dy: Float, duration: Float, elapsed: Float)
+  | MoveBy(dx: Float, dy: Float, duration: Float)
-record RotateBy(radians: Float, duration: Float, elapsed: Float)
+  | RotateBy(radians: Float, duration: Float)
-record Delay(duration: Float, elapsed: Float)
+  | Delay(duration: Float)
-record Sequence(steps: Slice[Action])
+  | Sequence(steps: Slice[Action])
-record Parallel(steps: Slice[Action])
+  | Parallel(steps: Slice[Action])
-# `template` is the pristine action restarted each lap, `current` the lap in progress.
-record Forever(template: Action, current: Action)
+  | Forever(template: Action)
-enum Action = MoveBy | RotateBy | Delay | Sequence | Parallel | Forever
 # How much of a timed action one step covers. A zero-length action finishes at
 # once and applies all of itself (no 0/0).
@@ -39,40 +37,41 @@ struct Step(pose: Pose, spare: Float, done: Bool)
 primitive Actions =
   fun moveBy(dx: Float, dy: Float, secs: Float) -> Action =
-    MoveBy(dx: dx, dy: dy, duration: secs, elapsed: 0.0)
+    Action(elapsed: 0.0, current: null, kind: MoveBy(dx: dx, dy: dy, duration: secs))
   fun rotateBy(radians: Float, secs: Float) -> Action =
-    RotateBy(radians: radians, duration: secs, elapsed: 0.0)
+    Action(elapsed: 0.0, current: null, kind: RotateBy(radians: radians, duration: secs))
   fun delay(secs: Float) -> Action =
-    Delay(duration: secs, elapsed: 0.0)
+    Action(elapsed: 0.0, current: null, kind: Delay(duration: secs))
   fun sequence(steps: Slice[Action]) -> Action =
-    Sequence(steps: steps)
+    Action(elapsed: 0.0, current: null, kind: Sequence(steps: steps))
   fun parallel(steps: Slice[Action]) -> Action =
-    Parallel(steps: steps)
+    Action(elapsed: 0.0, current: null, kind: Parallel(steps: steps))
   fun forever(a: Action) -> Action =
-    Forever(template: Actions.fresh(a), current: a)
+    Action(elapsed: 0.0, current: a, kind: Forever(template: Actions.fresh(a)))
   # An unstarted copy of `a` (elapsed 0, all steps present).
   fun fresh(a: Action) -> Action =
-    match a
+    match a.kind
-      MoveBy => MoveBy(dx: a.dx, dy: a.dy, duration: a.duration, elapsed: 0.0)
+      MoveBy(dx, dy, duration) => Actions.moveBy(dx, dy, duration)
-      RotateBy => RotateBy(radians: a.radians, duration: a.duration, elapsed: 0.0)
+      RotateBy(radians, duration) => Actions.rotateBy(radians, duration)
-      Delay => Delay(duration: a.duration, elapsed: 0.0)
+      Delay(duration) => Actions.delay(duration)
-      Sequence =>
+      Sequence(steps) =>
         out := Slice[Action]()
-        for i := range a.steps.length()
+        for i := range steps.length()
-          out.push(Actions.fresh(a.steps.at(i)))
+          out.push(Actions.fresh(steps.at(i)))
-        Sequence(steps: out)
+        Actions.sequence(out)
-      Parallel =>
+      Parallel(steps) =>
         out := Slice[Action]()
-        for i := range a.steps.length()
+        for i := range steps.length()
-          out.push(Actions.fresh(a.steps.at(i)))
+          out.push(Actions.fresh(steps.at(i)))
-        Parallel(steps: out)
+        Actions.parallel(out)
+      Forever(template) =>
-      Forever => Forever(template: a.template, current: Actions.fresh(a.template))
+        Action(elapsed: 0.0, current: Actions.fresh(template), kind: Forever(template: template))
   fun tick(duration: Float, elapsed: Float, dt: Float) -> Tick =
     if duration <= 0.0
@@ -81,43 +80,50 @@ primitive Actions =
     Tick(used: used, frac: used / duration, done: elapsed + used >= duration)
   fun stepAction(p: Pose, a: Action, dt: Float) -> Step =
-    match a
+    match a.kind
-      MoveBy =>
+      MoveBy(dx, dy, duration) =>
-        k := Actions.tick(a.duration, a.elapsed, dt)
+        k := Actions.tick(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
-        q := Pose(x: p.x + a.dx * k.frac, y: p.y + a.dy * k.frac, rotation: p.rotation, scaleX: p.scaleX, scaleY: p.scaleY)
+        q := Pose(x: p.x + dx * k.frac, y: p.y + dy * k.frac, rotation: p.rotation, scaleX: p.scaleX, scaleY: p.scaleY)
         Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      RotateBy =>
+      RotateBy(radians, duration) =>
-        k := Actions.tick(a.duration, a.elapsed, dt)
+        k := Actions.tick(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
-        q := Pose(x: p.x, y: p.y, rotation: p.rotation + a.radians * k.frac, scaleX: p.scaleX, scaleY: p.scaleY)
+        q := Pose(x: p.x, y: p.y, rotation: p.rotation + radians * k.frac, scaleX: p.scaleX, scaleY: p.scaleY)
         Step(pose: q, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      Delay =>
+      Delay(duration) =>
-        k := Actions.tick(a.duration, a.elapsed, dt)
+        k := Actions.tick(duration, a.elapsed, dt)
         a.elapsed = a.elapsed + k.used
         Step(pose: p, spare: if k.done then dt - k.used else 0.0, done: k.done)
-      Sequence =>
+      Sequence(steps) =>
-        if a.steps.length() == 0
+        if steps.length() == 0
           return Step(pose: p, spare: dt, done: true)
-        s := Actions.stepAction(p, a.steps.at(0), dt)
+        s := Actions.stepAction(p, steps.at(0), dt)
         if !s.done
           return Step(pose: s.pose, spare: 0.0, done: false)
         # The rest starts in this same frame with the time left over; the list
         # is one shorter on every call, so this terminates.
-        a.steps.removeAt(0)
+        steps.removeAt(0)
         Actions.stepAction(s.pose, a, s.spare)
-      Parallel =>
+      Parallel(steps) =>
-        Actions.stepAll(p, a.steps, dt)
+        Actions.stepAll(p, steps, dt)
-      Forever =>
+      Forever(template) =>
         # Restarts at most once per step, with the spare time, so a zero-length
         # template cannot spin forever inside one step.
+        if a.current == null
+          a.current = Actions.fresh(template)
+        lap := template
+        if c := a.current
+          lap = c
-        s := Actions.stepAction(p, a.current, dt)
+        s := Actions.stepAction(p, lap, dt)
         if !s.done
           return Step(pose: s.pose, spare: 0.0, done: false)
-        a.current = Actions.fresh(a.template)
+        next := Actions.fresh(template)
-        r := Actions.stepAction(s.pose, a.current, s.spare)
+        r := Actions.stepAction(s.pose, next, s.spare)
         if r.done
-          a.current = Actions.fresh(a.template)
+          a.current = Actions.fresh(template)
+        else
+          a.current = next
         Step(pose: r.pose, spare: 0.0, done: false)
   # Steps every action side by side in place and drops the finished ones by
@@ -146,13 +152,13 @@ fun actNear(a: Float, b: Float) -> Bool =
   {a - b}.abs() < 0.000001
 fun actSeqLen(a: Action) -> Int =
-  match a
+  match a.kind
-    Sequence => a.steps.length()
+    Sequence(steps) => steps.length()
     _ => 0 - 1
 fun actElapsed(a: Action) -> Float =
-  match a
+  match a.kind
-    MoveBy => a.elapsed
+    MoveBy(_, _, _) => a.elapsed
     _ => 0.0 - 1.0
 fun actPose0() -> Pose =

plum-std/game/PureScene.plum CHANGED Viewed

@@ -10,11 +10,12 @@ import std/game/Affine
 import std/game/Game
 import std/game/Actions
-# A pure scene graph: actors are own values. `Actor` is an own trait that own
+# A pure scene graph: a node is an own record (`Node`) holding a `Transform` and
-# records embed (`Group`, `Sprite`, `Label`, `Button` here). `onPointer` and
+# an `enum Kind`. Group, Sprite, Label and Button are built in; games add their
+# own behaviour with `Custom(actor: Actor)`, a behaviour-only trait their records
+# embed (like Rust's `Box<dyn Actor>`). `onPointer` takes the node, changes it in
-# `act` take the actor, change it in place and hand it back; readers borrow.
+# place and hands it back; readers borrow. Only `drawTree` talks to the host,
-# Only `drawTree` talks to the host, through `std/game/Game`.
-# `act`, the actions in `actions` and tree-wide updates live in std/game/SceneTree.
+# through `std/game/Game`. Actions and tree-wide updates live in std/game/SceneTree.
 enum Touchable =
   | Enabled
@@ -38,104 +39,55 @@ enum UiKind =
 record UiEvent(id: Int, kind: UiKind)
-# The actor after handling an event, and the events it raised.
+# The node's position, size, origin, scale and rotation.
-own record Handled(actor: Actor, events: Slice[UiEvent]) =
+record Transform(x: Float, y: Float, width: Float, height: Float, originX: Float, originY: Float, scaleX: Float, scaleY: Float, rotation: Float) =
-  # The actor, moved out; read `events` first, they stay behind.
+  # The transform into the parent's coordinates: translate to the position,
+  # rotate and scale about the origin.
-  fun intoActor(own self) -> Actor =
+  fun localMatrix(self) -> Affine =
+    cs := Math.cos(self.rotation)
+    sn := Math.sin(self.rotation)
-    match self
+    ma := cs * self.scaleX
-      Handled(a, _) => a
+    mb := sn * self.scaleX
+    mc := 0.0 - sn * self.scaleY
-own trait Actor(
+    md := cs * self.scaleY
-  id: Int,
+    Affine(
-  x: Float, y: Float, width: Float, height: Float,
-  originX: Float, originY: Float,
-  scaleX: Float, scaleY: Float,
+      a: ma, b: mb, c: mc, d: md,
-  rotation: Float,
-  color: Color,
-  visible: Bool,
-  touchable: Touchable,
-  actions: Slice[Action]) =
-  # This actor after `dt` seconds of its own behaviour; the default is itself.
-  fun act(own self, dt: Float) -> Actor = self
-  # The children of a group; null for a leaf.
-  fun kids(self) -> Slice[Actor]? = null
-  # Paints this actor only, at its stage transform `m` with the combined `tint`.
-  fun draw(self, m: Affine, tint: Color) =
-    return
-  # Whether `p`, in this actor's own coordinates, is on it.
-  fun hit(self, p: Vec2) -> Bool =
-    self.touchable == Enabled && p.x >= 0.0 && p.x <= self.width && p.y >= 0.0 && p.y <= self.height
-  # Handles a pointer event and returns the new actor with the events it raised.
-  fun onPointer(own self, e: Pointer) -> Handled =
-    Handled(actor: self, events: Slice[UiEvent]())
-own record Group(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  children: Slice[Actor]) =
-  override fun kids(self) -> Slice[Actor]? = self.children
+      e: self.x + self.originX - {ma * self.originX + mc * self.originY},
-own record Sprite(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
-  tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
+      f: self.y + self.originY - {mb * self.originX + md * self.originY})
+  # Whether `p`, in the node's own coordinates, is inside its box.
-  override fun draw(self, m: Affine, tint: Color) =
+  fun contains(self, p: Vec2) -> Bool =
-    pureDrawSprite(m, tint, self.width, self.height, self.tex, self.srcX, self.srcY, self.srcW, self.srcH)
+    p.x >= 0.0 && p.x <= self.width && p.y >= 0.0 && p.y <= self.height
-own record Label(
+own record Node(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
+  Transform(x, y, width, height, originX, originY, scaleX, scaleY, rotation),
-  text: Str, size: Float) =
+  id: Int, color: Color, visible: Bool, touchable: Touchable, actions: Slice[Action], kind: Kind)
+enum Kind =
+  | Group(children: Slice[Node])
+  | Sprite(tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float)
+  | Label(text: Str, size: Float)
+  | Button(text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool)
+  | Custom(actor: Actor)
-  override fun draw(self, m: Affine, tint: Color) =
+# Game behaviour for a `Custom` node. The defaults do nothing.
-    pureDrawText(m, tint, self.text, self.size)
+trait Actor =
-own record Button(
-  Actor(id, x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, touchable, actions),
+  # The node after `dt` seconds of this actor's behaviour; the default is itself.
-  text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool) =
+  fun act(self, own n: Node, dt: Float) -> Node = n
+  # Paints the node at its stage transform `m` with the combined `tint`.
+  fun draw(self, n: Node, m: Affine, tint: Color) =
+    return
+# The node after handling an event, and the events it raised.
-  override fun draw(self, m: Affine, tint: Color) =
+own record Handled(node: Node, events: Slice[UiEvent]) =
-    t := self.upTex
-    if self.pressed && self.over
-      t = self.downTex
-    pureDrawSprite(m, tint, self.width, self.height, t, 0.0, 0.0, 0.0, 0.0)
-    size := self.height * 0.5
-    ox := {self.width - size * 0.6 * Float(self.text.length())} / 2.0
-    oy := {self.height - size} / 2.0
-    pureDrawText(m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, self.text, size)
+  # The node, moved out; read `events` first, they stay behind.
-  override fun onPointer(own self, e: Pointer) -> Handled =
+  fun intoNode(own self) -> Node =
-    ev := Slice[UiEvent]()
-    id := self.id
+    match self
-    wasOver := self.over
-    wasPressed := self.pressed
-    if e.kind == Down
-      self.pressed = true
-      self.over = e.over
-      ev.push(UiEvent(id: id, kind: Press))
-    else if e.kind == Move
-      self.over = e.over
-      if e.over && !wasOver
-        ev.push(UiEvent(id: id, kind: Enter))
-      if !e.over && wasOver
-        ev.push(UiEvent(id: id, kind: Exit))
-    else
-      self.over = e.over
-      if wasPressed
-        self.pressed = false
-        ev.push(UiEvent(id: id, kind: Release))
-        if e.over
-          ev.push(UiEvent(id: id, kind: Click))
-    Handled(actor: self, events: ev)
+      Handled(n, _) => n
 fun pureDrawSprite(m: Affine, tint: Color, w: Float, h: Float, tex: Int, srcX: Float, srcY: Float, srcW: Float, srcH: Float) =
   sx := w * m.scaleX()
@@ -150,64 +102,101 @@ fun pureDrawText(m: Affine, tint: Color, s: Str, size: Float) =
 fun pureMulColor(a: Color, b: Color) -> Color =
   Color(r: a.r * b.r, g: a.g * b.g, b: a.b * b.b, a: a.a * b.a)
+fun pureDrawButton(n: Node, m: Affine, tint: Color, text: Str, upTex: Int, downTex: Int, pressed: Bool, over: Bool) =
+  t := upTex
+  if pressed && over
+    t = downTex
+  pureDrawSprite(m, tint, n.width, n.height, t, 0.0, 0.0, 0.0, 0.0)
+  size := n.height * 0.5
+  ox := {n.width - size * 0.6 * Float(text.length())} / 2.0
+  oy := {n.height - size} / 2.0
+  pureDrawText(m.mul(Affine(a: 1.0, b: 0.0, c: 0.0, d: 1.0, e: ox, f: oy)), tint, text, size)
+fun pureNode(id: Int, x: Float, y: Float, w: Float, h: Float, touchable: Touchable, kind: Kind) -> Node =
+  Node(
+    x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
+    scaleX: 1.0, scaleY: 1.0, rotation: 0.0,
+    id: id, color: Color.White, visible: true, touchable: touchable,
+    actions: Slice[Action](), kind: kind)
 primitive PureScene =
-  # The actor's transform into its parent's coordinates: translate to the
+  # The node's transform into its parent's coordinates.
-  # position, rotate and scale about the origin.
-  fun localMatrix(a: Actor) -> Affine =
+  fun localMatrix(n: Node) -> Affine =
-    cs := Math.cos(a.rotation)
+    n.localMatrix()
-    sn := Math.sin(a.rotation)
-    ma := cs * a.scaleX
-    mb := sn * a.scaleX
-    mc := 0.0 - sn * a.scaleY
-    md := cs * a.scaleY
-    Affine(
-      a: ma, b: mb, c: mc, d: md,
-      e: a.x + a.originX - {ma * a.originX + mc * a.originY},
-      f: a.y + a.originY - {mb * a.originX + md * a.originY})
-  # Draws the actor and its children given the parent's matrix and tint.
+  # Draws the node and its children given the parent's matrix and tint.
-  fun drawTree(a: Actor, parent: Affine, tint: Color) =
+  fun drawTree(n: Node, parent: Affine, tint: Color) =
-    if !a.visible
+    if !n.visible
       return
-    m := parent * PureScene.localMatrix(a)
+    m := parent * n.localMatrix()
-    t := pureMulColor(tint, a.color)
+    t := pureMulColor(tint, n.color)
-    a.draw(m, t)
-    match a
+    match n.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, g) =>
+      Group(children) =>
-        for i := range g.length()
+        for i := range children.length()
-          PureScene.drawTree(g.at(i), m, t)
+          PureScene.drawTree(children.at(i), m, t)
+      Sprite(tex, srcX, srcY, srcW, srcH) =>
+        pureDrawSprite(m, t, n.width, n.height, tex, srcX, srcY, srcW, srcH)
+      Label(text, size) =>
+        pureDrawText(m, t, text, size)
+      Button(text, upTex, downTex, pressed, over) =>
+        pureDrawButton(n, m, t, text, upTex, downTex, pressed, over)
+      Custom(actor) =>
+        actor.draw(n, m, t)
+  # The children of a group, or null for anything else.
+  fun childrenOf(n: Node) -> Slice[Node]? =
+    match n.kind
+      Group(children) => children
+      _ => null
+  # Whether `p`, in the node's own coordinates, is on it.
+  fun hit(n: Node, p: Vec2) -> Bool =
+    n.touchable == Enabled && n.contains(p)
+  # Handles a pointer event and returns the new node with the events it raised.
+  # Only a Button reacts.
+  fun onPointer(own n: Node, e: Pointer) -> Handled =
+    ev := Slice[UiEvent]()
+    match n.kind
+      Button(text, upTex, downTex, wasPressed, wasOver) =>
+        pressed := wasPressed
+        over := wasOver
+        if e.kind == Down
+          pressed = true
+          over = e.over
+          ev.push(UiEvent(id: n.id, kind: Press))
+        else if e.kind == Move
+          over = e.over
+          if e.over && !wasOver
+            ev.push(UiEvent(id: n.id, kind: Enter))
+          if !e.over && wasOver
+            ev.push(UiEvent(id: n.id, kind: Exit))
+        else
+          over = e.over
+          if wasPressed
+            pressed = false
+            ev.push(UiEvent(id: n.id, kind: Release))
+            if e.over
+              ev.push(UiEvent(id: n.id, kind: Click))
+        n.kind = Button(text: text, upTex: upTex, downTex: downTex, pressed: pressed, over: over)
       _ => 0
+    Handled(node: n, events: ev)
+  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Node]) -> Node =
+    pureNode(id, x, y, w, h, Enabled, Group(children: children))
+  fun sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
+    pureNode(id, x, y, w, h, Enabled, Sprite(tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0))
-  # The children of a group, or null for a leaf.
-  fun childrenOf(a: Actor) -> Slice[Actor]? =
-    a.kids()
-  fun group(id: Int, x: Float, y: Float, w: Float, h: Float, children: Slice[Actor]) -> Group =
-    Group(
-      id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: Slice[Action](), children: children)
-  fun sprite(id: Int, tex: Int, x: Float, y: Float, w: Float, h: Float) -> Sprite =
-    Sprite(
-      id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: Slice[Action](),
-      tex: tex, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0)
-  fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Label =
+  fun label(id: Int, text: Str, x: Float, y: Float, size: Float) -> Node =
-    Label(
-      id: id, x: x, y: y, width: size * 0.6 * Float(text.length()), height: size, originX: 0.0, originY: 0.0,
+    pureNode(id, x, y, size * 0.6 * Float(text.length()), size, Disabled, Label(text: text, size: size))
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Disabled, actions: Slice[Action](), text: text, size: size)
-  fun button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Button =
+  fun button(id: Int, text: Str, upTex: Int, downTex: Int, x: Float, y: Float, w: Float, h: Float) -> Node =
-    Button(
-      id: id, x: x, y: y, width: w, height: h, originX: 0.0, originY: 0.0,
-      scaleX: 1.0, scaleY: 1.0, rotation: 0.0, color: Color.White, visible: true,
-      touchable: Enabled, actions: Slice[Action](),
-      text: text, upTex: upTex, downTex: downTex, pressed: false, over: false)
+    pureNode(id, x, y, w, h, Enabled, Button(text: text, upTex: upTex, downTex: downTex, pressed: false, over: false))
+  fun custom(id: Int, x: Float, y: Float, w: Float, h: Float, actor: Actor) -> Node =
+    pureNode(id, x, y, w, h, Disabled, Custom(actor: actor))
 fun psKinds(h: Handled) -> Slice[UiKind] =
   out := Slice[UiKind]()
@@ -215,9 +204,9 @@ fun psKinds(h: Handled) -> Slice[UiKind] =
     out.push(h.events.at(i).kind)
   out
-fun psIsPressed(a: Actor) -> Bool =
+fun psIsPressed(n: Node) -> Bool =
-  match a
+  match n.kind
-    Button(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, pressed, _) => pressed
+    Button(_, _, _, pressed, _) => pressed
     _ => false
 fun psClicks(h: Handled) -> Int =
@@ -230,6 +219,23 @@ fun psClicks(h: Handled) -> Int =
 fun psOverPtr(kind: PointerKind, over: Bool) -> Pointer =
   Pointer(kind: kind, x: 1.0, y: 1.0, over: over)
+# A game actor: counts its draws and moves its node right by 1 on each act.
+record Beacon(Actor, draws: Int) =
+  override fun act(self, own n: Node, dt: Float) -> Node =
+    n.x = n.x + 1.0
+    n
+  override fun draw(self, n: Node, m: Affine, tint: Color) =
+    self.draws = self.draws + 1
+fun psActorOf(n: Node) -> Actor? = match n.kind
+  Custom(a) => a
+  _ => null
+fun psActed(own n: Node, dt: Float) -> Node =
+  if a := psActorOf(n)
+    return a.act(n, dt)
+  n
 test "local_matrix_translates"
   s := PureScene.sprite(1, 0, 10.0, 0.0, 2.0, 2.0)
   p := PureScene.localMatrix(s).apply(Vec2(x: 0.0, y: 0.0))
@@ -238,11 +244,11 @@ test "local_matrix_translates"
 test "button_click_needs_press_and_over"
   b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h1 := b.onPointer(psOverPtr(Down, true))
+  h1 := PureScene.onPointer(b, psOverPtr(Down, true))
   ks := psKinds(h1)
   n1 := h1.events.length()
   id1 := h1.events.at(0).id
-  h2 := h1.intoActor().onPointer(psOverPtr(Up, true))
+  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Up, true))
   ks.push(h2.events.at(0).kind)
   ks.push(h2.events.at(1).kind)
   assert n1 == 1
@@ -255,23 +261,68 @@ test "button_click_needs_press_and_over"
 test "button_release_elsewhere_no_click"
   b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h1 := b.onPointer(psOverPtr(Down, true))
+  h1 := PureScene.onPointer(b, psOverPtr(Down, true))
-  h2 := h1.intoActor().onPointer(psOverPtr(Up, false))
+  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Up, false))
   assert h2.events.length() == 1
   assert h2.events.at(0).kind == Release
-  assert !psIsPressed(h2.intoActor())
+  assert !psIsPressed(h2.intoNode())
 test "button_drag_off_and_back_one_click"
   b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  a1 := b.onPointer(psOverPtr(Down, true)).intoActor()
+  a1 := PureScene.onPointer(b, psOverPtr(Down, true)).intoNode()
-  h2 := a1.onPointer(psOverPtr(Move, false))
+  h2 := PureScene.onPointer(a1, psOverPtr(Move, false))
   c2 := psClicks(h2)
-  h3 := h2.intoActor().onPointer(psOverPtr(Move, true))
+  h3 := PureScene.onPointer(h2.intoNode(), psOverPtr(Move, true))
   c3 := psClicks(h3)
-  h4 := h3.intoActor().onPointer(psOverPtr(Up, true))
+  h4 := PureScene.onPointer(h3.intoNode(), psOverPtr(Up, true))
   assert c2 + c3 + psClicks(h4) == 1
 test "on_pointer_hands_back_changed_actor"
   b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
-  h := b.onPointer(psOverPtr(Down, true))
+  h := PureScene.onPointer(b, psOverPtr(Down, true))
-  assert psIsPressed(h.intoActor())
+  assert psIsPressed(h.intoNode())
+test "custom_actor_act_and_draw_dispatch"
+  beacon := Beacon(draws: 0)
+  n := PureScene.custom(7, 2.0, 0.0, 8.0, 8.0, beacon)
+  PureScene.drawTree(n, Affine.Identity, Color.White)
+  assert beacon.draws == 1
+  moved := psActed(n, 0.016)
+  assert moved.x == 3.0
+test "draw_tree_nested_groups_reaches_custom"
+  beacon := Beacon(draws: 0)
+  inner := PureScene.group(2, 0.0, 0.0, 10.0, 10.0, Slice(PureScene.custom(3, 1.0, 1.0, 4.0, 4.0, beacon)))
+  root := PureScene.group(1, 0.0, 0.0, 10.0, 10.0, Slice(inner))
+  PureScene.drawTree(root, Affine.Identity, Color.White)
+  assert beacon.draws == 1
+test "hit_box_and_children_of"
+  s := PureScene.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
+  assert PureScene.hit(s, Vec2(x: 5.0, y: 5.0))
+  assert !PureScene.hit(s, Vec2(x: 11.0, y: 5.0))
+  assert PureScene.childrenOf(s) == null
+  assert PureScene.childrenOf(PureScene.group(2, 0.0, 0.0, 1.0, 1.0, Slice(s))) != null
+test "button_move_raises_enter_then_exit"
+  b := PureScene.button(7, "go", 1, 2, 0.0, 0.0, 10.0, 10.0)
+  h1 := PureScene.onPointer(b, psOverPtr(Move, true))
+  assert h1.events.length() == 1
+  assert h1.events.at(0).kind == Enter
+  h2 := PureScene.onPointer(h1.intoNode(), psOverPtr(Move, false))
+  assert h2.events.length() == 1
+  assert h2.events.at(0).kind == Exit
+  assert !psIsPressed(h2.intoNode())
+test "on_pointer_non_button_raises_nothing"
+  s := PureScene.sprite(1, 0, 0.0, 0.0, 10.0, 10.0)
+  h := PureScene.onPointer(s, psOverPtr(Down, true))
+  assert h.events.length() == 0
+  assert h.intoNode().id == 1
+test "draw_tree_skips_invisible_custom"
+  beacon := Beacon(draws: 0)
+  n := PureScene.custom(7, 0.0, 0.0, 8.0, 8.0, beacon)
+  n.visible = false
+  PureScene.drawTree(n, Affine.Identity, Color.White)
+  assert beacon.draws == 0

plum-std/game/SceneInput.plum CHANGED Viewed

@@ -35,7 +35,7 @@ own record StageHandled(stage: Stage, events: Slice[UiEvent]) =
     match self
       StageHandled(s, _) => s
-own record Stage(root: Actor, camera: Affine, captured: Capture?) =
+own record Stage(root: Node, camera: Affine, captured: Capture?) =
   # Handles one input: routes it, returns the new stage and the events raised.
   fun input(own self, e: Input) -> StageHandled =
@@ -105,7 +105,7 @@ fun inputIsPrefix(a: Slice[Int], b: Slice[Int]) -> Bool =
   true
 primitive SceneInput =
-  fun stage(own root: Actor) -> Stage =
+  fun stage(own root: Node) -> Stage =
     Stage(root: root, camera: Affine.Identity, captured: null)
   # This frame's pointer inputs from the host mouse: a press, a release, or a
@@ -122,26 +122,25 @@ primitive SceneInput =
       out.push(Input(kind: PointerMove, x: m.x, y: m.y))
     out
-fun inBtnTree() -> Actor =
+fun inBtnTree() -> Node =
-  b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
-  kids := Slice[Actor]()
+  kids := Slice(b)
-  kids.push(b)
-  g: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  g: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
   g
 fun inBtnPressed(s: Stage) -> Bool =
-  if k := s.root.kids()
+  if k := PureScene.childrenOf(s.root)
     return psIsPressed(k.at(0))
   false
 fun inBtnOver(s: Stage) -> Bool =
-  if k := s.root.kids()
+  if k := PureScene.childrenOf(s.root)
     return inOverOf(k.at(0))
   false
-fun inOverOf(a: Actor) -> Bool =
+fun inOverOf(a: Node) -> Bool =
-  match a
+  match a.kind
-    Button(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, over) => over
+    Button(_, _, _, _, over) => over
     _ => false
 fun inDown(x: Float, y: Float) -> Input =
@@ -160,15 +159,14 @@ fun inClicks(events: Slice[UiEvent]) -> Int =
       n = n + 1
   n
-fun inXformTree() -> Actor =
+fun inXformTree() -> Node =
-  b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
-  kids := Slice[Actor]()
+  kids := Slice(b)
-  kids.push(b)
   g := PureScene.group(1, 100.0, 0.0, 800.0, 600.0, kids)
   g.rotation = 1.5707963267948966
   g.scaleX = 2.0
   g.scaleY = 2.0
-  me: Actor := g
+  me: Node := g
   me
 test "press_sets_capture"
@@ -202,7 +200,7 @@ test "drag_off_and_back_one_click"
 test "stale_capture_dropped"
   h1 := SceneInput.stage(inBtnTree()).input(inDown(20.0, 20.0))
-  empty: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Actor]())
+  empty: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, Slice[Node]())
   swapped := Stage(root: empty, camera: h1.stage.camera, captured: h1.stage.captured)
   h2 := swapped.input(inUp(20.0, 20.0))
   assert h2.events.length() == 0
@@ -223,24 +221,19 @@ test "camera_maps_screen_to_world"
 test "frame_handles_inputs_then_updates"
   spr := PureScene.sprite(6, 0, 300.0, 300.0, 10.0, 10.0)
-  acts := Slice[Action]()
-  acts.push(Actions.moveBy(10.0, 0.0, 1.0))
+  acts := Slice(Actions.moveBy(10.0, 0.0, 1.0))
   spr.actions = acts
-  b: Actor := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
+  b: Node := PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0)
-  sp: Actor := spr
+  sp: Node := spr
-  kids := Slice[Actor]()
+  kids := Slice(b, sp)
-  kids.push(b)
-  kids.push(sp)
-  root: Actor := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
+  root: Node := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  ins := Slice[Input]()
-  ins.push(inDown(20.0, 20.0))
+  ins := Slice(inDown(20.0, 20.0), inUp(20.0, 20.0))
-  ins.push(inUp(20.0, 20.0))
   h := SceneInput.stage(root).frame(0.5, ins)
   assert h.events.length() == 3
   assert h.events.at(0).kind == Press
   assert h.events.at(1).kind == Release
   assert h.events.at(2).kind == Click
-  if k := h.stage.root.kids()
+  if k := PureScene.childrenOf(h.stage.root)
     assert {k.at(1).x - 305.0}.abs() < 0.000001
   else
     assert false

plum-std/game/SceneTree.plum CHANGED Viewed

@@ -8,34 +8,44 @@ import std/game/Affine
 import std/game/Actions
 import std/game/PureScene
+fun treeActorOf(n: Node) -> Actor? =
+  match n.kind
+    Custom(actor) => actor
+    _ => null
 fun treePrepend(i: Int, rest: Slice[Int]) -> Slice[Int] =
-  out := Slice[Int]()
+  out := Slice(i)
-  out.push(i)
   for j := range rest.length()
     out.push(rest.at(j))
   out
 primitive SceneTree =
+  # A Custom node's actor acts on it; every other node is itself.
+  fun act(own n: Node, dt: Float) -> Node =
+    if actor := treeActorOf(n)
+      return actor.act(n, dt)
+    n
-  # The actor after `dt` seconds: its own `act`, then its actions on its pose,
+  # The node after `dt` seconds: a Custom actor's own `act`, then its actions on its pose,
   # then every child. The tree is changed in place and handed back.
-  fun update(own a: Actor, dt: Float) -> Actor =
+  fun update(own a: Node, dt: Float) -> Node =
-    b := a.act(dt)
+    b := SceneTree.act(a, dt)
     r := Actions.stepAll(Pose(x: b.x, y: b.y, rotation: b.rotation, scaleX: b.scaleX, scaleY: b.scaleY), b.actions, dt)
     b.x = r.pose.x
     b.y = r.pose.y
     b.rotation = r.pose.rotation
     b.scaleX = r.pose.scaleX
     b.scaleY = r.pose.scaleY
-    match b
+    match b.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+      Group(ks) =>
         _ := ks.mapInPlace(|k| SceneTree.update(k, dt))
       _ => 0
     b
   # The path (child indexes from `a`) to the topmost actor under `p`, which is
   # in the coordinates of `a`'s parent; `parent` is that parent's stage matrix.
-  fun findHit(a: Actor, parent: Affine, p: Vec2) -> Slice[Int]? =
+  fun findHit(a: Node, parent: Affine, p: Vec2) -> Slice[Int]? =
     if !a.visible || a.touchable == Disabled
       return null
     m := parent * PureScene.localMatrix(a)
@@ -45,8 +55,8 @@ primitive SceneTree =
     lp := Vec2(x: 0.0, y: 0.0)
     if q := inv
       lp = q.apply(p)
-    match a
+    match a.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+      Group(ks) =>
         i := ks.length() - 1
         while i >= 0
           sub := SceneTree.findHit(ks.at(i), m, p)
@@ -54,16 +64,16 @@ primitive SceneTree =
             return treePrepend(i, s)
           i = i - 1
       _ => 0
-    if a.hit(lp)
+    if PureScene.hit(a, lp)
       return Slice[Int]()
     null
   # The id of the actor at `path` below `a`, or -1 if the path leads nowhere.
-  fun idAt(a: Actor, path: Slice[Int], depth: Int) -> Int =
+  fun idAt(a: Node, path: Slice[Int], depth: Int) -> Int =
     if depth >= path.length()
       return a.id
-    match a
+    match a.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+      Group(ks) =>
         i := path.at(depth)
         if i >= 0 && i < ks.length()
           return SceneTree.idAt(ks.at(i), path, depth + 1)
@@ -71,11 +81,11 @@ primitive SceneTree =
     -1
   # The path to the first actor with `id`, depth first; null if none.
-  fun findPath(a: Actor, id: Int) -> Slice[Int]? =
+  fun findPath(a: Node, id: Int) -> Slice[Int]? =
     if a.id == id
       return Slice[Int]()
-    match a
+    match a.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+      Group(ks) =>
         for i := range ks.length()
           sub := SceneTree.findPath(ks.at(i), id)
           if s := sub
@@ -84,17 +94,17 @@ primitive SceneTree =
     null
   # The tree where the first actor with `id` is replaced by `f` of it.
-  fun modify(own a: Actor, id: Int, f: fn(Actor) -> Actor) -> Actor =
+  fun modify(own a: Node, id: Int, f: fn(Node) -> Node) -> Node =
     path := SceneTree.findPath(a, id)
     if p := path
       return SceneTree.modifyAt(a, p, 0, f)
     a
-  fun modifyAt(own a: Actor, path: Slice[Int], depth: Int, f: fn(Actor) -> Actor) -> Actor =
+  fun modifyAt(own a: Node, path: Slice[Int], depth: Int, f: fn(Node) -> Node) -> Node =
     if depth >= path.length()
       return f(a)
-    match a
+    match a.kind
-      Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+      Group(ks) =>
         i := path.at(depth)
         if i >= 0 && i < ks.length()
           c := ks.takeAt(i)
@@ -105,39 +115,36 @@ primitive SceneTree =
   # Delivers `e` (in the coordinates of `a`'s parent) along `path`: the child on
   # the path first, then `a` itself. A path that runs out reaches the deepest
   # actor it can.
-  fun route(own a: Actor, path: Slice[Int], depth: Int, e: Pointer) -> Handled =
+  fun route(own a: Node, path: Slice[Int], depth: Int, e: Pointer) -> Handled =
     events := Slice[UiEvent]()
     r := SceneTree.routeInto(a, path, depth, e, events)
-    Handled(actor: r, events: events)
+    Handled(node: r, events: events)
   # `route`, appending the raised events to `events` and returning the actor.
-  fun routeInto(own a: Actor, path: Slice[Int], depth: Int, e: Pointer, events: Slice[UiEvent]) -> Actor =
+  fun routeInto(own a: Node, path: Slice[Int], depth: Int, e: Pointer, events: Slice[UiEvent]) -> Node =
     lp := Vec2(x: e.x, y: e.y)
     inv := PureScene.localMatrix(a).invert()
     if q := inv
       lp = q.apply(lp)
     local := Pointer(kind: e.kind, x: lp.x, y: lp.y, over: e.over)
     if depth < path.length()
-      match a
+      match a.kind
-        Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, ks) =>
+        Group(ks) =>
           i := path.at(depth)
           if i >= 0 && i < ks.length()
             c := ks.takeAt(i)
             ks.putAt(i, SceneTree.routeInto(c, path, depth + 1, local, events))
         _ => 0
-    h := a.onPointer(local)
+    h := PureScene.onPointer(a, local)
     for j := range h.events.length()
       events.push(h.events.at(j))
-    h.intoActor()
+    h.intoNode()
-fun ttFixture() -> Actor =
+fun ttFixture() -> Node =
-  inner := Slice[Actor]()
-  inner.push(PureScene.sprite(4, 0, 0.0, 0.0, 5.0, 5.0))
+  inner := Slice(PureScene.sprite(4, 0, 0.0, 0.0, 5.0, 5.0))
-  kids := Slice[Actor]()
-  kids.push(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0))
-  kids.push(PureScene.group(3, 20.0, 0.0, 10.0, 10.0, inner))
+  kids := Slice(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), PureScene.group(3, 20.0, 0.0, 10.0, 10.0, inner))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Actor := root
+  me: Node := root
   me
 fun ttNoPath(r: Slice[Int]?) -> Bool =
@@ -154,98 +161,98 @@ fun ttPathEq(r: Slice[Int]?, want: Slice[Int]) -> Bool =
   false
 fun ttInts(a: Int, b: Int) -> Slice[Int] =
-  out := Slice[Int]()
+  out := Slice(a, b)
-  out.push(a)
-  out.push(b)
   out
 fun ttAt(x: Float, y: Float) -> Vec2 =
   Vec2(x: x, y: y)
-fun ttMovingTree() -> Actor =
+fun ttMovingTree() -> Node =
   s := PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
   s.actions = Slice(Actions.moveBy(10.0, 0.0, 1.0))
-  kids := Slice[Actor]()
+  kids := Slice(s)
-  kids.push(s)
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Actor := root
+  me: Node := root
   me
-fun ttFirstKidX(a: Actor) -> Float =
+fun ttFirstKidX(a: Node) -> Float =
-  match a
+  match a.kind
-    Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, k) =>
+    Group(k) =>
       return k.at(0).x
     _ => 0
   0.0 - 1.0
-fun ttFirstKidActions(a: Actor) -> Int =
+fun ttFirstKidActions(a: Node) -> Int =
-  match a
+  match a.kind
-    Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, k) =>
+    Group(k) =>
       return k.at(0).actions.length()
     _ => 0
   0 - 1
-fun ttSetTouch(own t: Actor, id: Int, tc: Touchable) -> Actor =
+fun ttSetTouch(own t: Node, id: Int, tc: Touchable) -> Node =
   SceneTree.modify(t, id, |a| ttSetTouchOf(a, tc))
-fun ttSetTouchOf(own a: Actor, tc: Touchable) -> Actor =
+fun ttSetTouchOf(own a: Node, tc: Touchable) -> Node =
   a.touchable = tc
   a
-fun ttSetScaleX(own a: Actor) -> Actor =
+fun ttSetScaleX(own a: Node) -> Node =
   a.scaleX = 0.0
   a
-fun ttSetX9(own a: Actor) -> Actor =
+fun ttSetX9(own a: Node) -> Node =
   a.x = 9.0
   a
-fun ttKidX(a: Actor, i: Int) -> Float =
+fun ttKidX(a: Node, i: Int) -> Float =
-  match a
+  match a.kind
-    Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, k) =>
+    Group(k) =>
       return k.at(i).x
     _ => 0
   0.0 - 1.0
-fun ttButtonRoot() -> Actor =
+fun ttButtonRoot() -> Node =
-  kids := Slice[Actor]()
-  kids.push(PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0))
+  kids := Slice(PureScene.button(5, "Go", 0, 1, 10.0, 10.0, 100.0, 40.0))
   root := PureScene.group(1, 0.0, 0.0, 800.0, 600.0, kids)
-  me: Actor := root
+  me: Node := root
   me
 fun ttZero() -> Slice[Int] =
-  out := Slice[Int]()
+  out := Slice(0)
-  out.push(0)
   out
 # Five actions on one sprite: the 1st, 3rd and 5th finish in the first 0.1s step,
 # the 2nd (MoveBy) and 4th (RotateBy) keep running.
-fun ttCompactTree() -> Actor =
+fun ttCompactTree() -> Node =
   s := PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0)
   s.actions = Slice(Actions.moveBy(1.0, 0.0, 0.1), Actions.moveBy(0.0, 10.0, 10.0), Actions.rotateBy(1.0, 0.1), Actions.rotateBy(2.0, 10.0), Actions.delay(0.1))
-  kids := Slice[Actor]()
+  kids := Slice(s)
-  kids.push(s)
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Actor := root
+  me: Node := root
   me
-fun ttKid(a: Actor) -> Actor =
+fun ttKid(a: Node) -> Node =
-  match a
+  match a.kind
-    Group(_, _, _, _, _, _, _, _, _, _, _, _, _, _, k) =>
+    Group(k) =>
       return k.at(0)
     _ => 0
-  none: Actor := PureScene.sprite(0, 0, 0.0, 0.0, 0.0, 0.0)
+  none: Node := PureScene.sprite(0, 0, 0.0, 0.0, 0.0, 0.0)
   none
 # 1 MoveBy, 2 RotateBy, 3 Delay, 0 anything else.
 fun ttActKind(a: Action) -> Int =
-  match a
+  match a.kind
-    MoveBy => 1
+    MoveBy(_, _, _) => 1
-    RotateBy => 2
+    RotateBy(_, _) => 2
-    Delay => 3
+    Delay(_) => 3
     _ => 0
+# Adds 1.0 to its node's x on every act.
+record TtStepper(Actor, ticks: Int) =
+  override fun act(self, own n: Node, dt: Float) -> Node =
+    n.x = n.x + 1.0
+    n
 test "find_hit_nested"
   r := SceneTree.findHit(ttFixture(), Affine.Identity, ttAt(21.0, 1.0))
   assert ttPathEq(r, ttInts(1, 0))
@@ -256,8 +263,7 @@ test "find_hit_miss"
 test "id_at_paths"
   t := ttFixture()
   assert SceneTree.idAt(t, ttInts(1, 0), 0) == 4
-  five := Slice[Int]()
+  five := Slice(5)
-  five.push(5)
   assert SceneTree.idAt(t, five, 0) == -1
   assert SceneTree.idAt(t, Slice[Int](), 0) == 1
@@ -293,22 +299,17 @@ test "scale_zero_not_hit"
   assert ttPathEq(r, Slice[Int]())
 test "topmost_child_wins"
-  kids := Slice[Actor]()
-  kids.push(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0))
-  kids.push(PureScene.sprite(3, 0, 0.0, 0.0, 10.0, 10.0))
+  kids := Slice(PureScene.sprite(2, 0, 0.0, 0.0, 10.0, 10.0), PureScene.sprite(3, 0, 0.0, 0.0, 10.0, 10.0))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Actor := root
+  me: Node := root
   r := SceneTree.findHit(me, Affine.Identity, ttAt(1.0, 1.0))
-  want := Slice[Int]()
+  want := Slice(1)
-  want.push(1)
   assert ttPathEq(r, want)
 test "modify_changes_first_match_only"
-  kids := Slice[Actor]()
-  kids.push(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
+  kids := Slice(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0), PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
-  kids.push(PureScene.sprite(7, 0, 0.0, 0.0, 10.0, 10.0))
   root := PureScene.group(1, 0.0, 0.0, 100.0, 100.0, kids)
-  me: Actor := root
+  me: Node := root
   n := SceneTree.modify(me, 7, |a| ttSetX9(a))
   assert ttKidX(n, 0) == 9.0
   assert ttKidX(n, 1) == 0.0
@@ -318,7 +319,7 @@ test "route_child_first_then_group"
   h1 := SceneTree.route(g, ttZero(), 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
   n1 := h1.events.length()
   k1 := h1.events.at(0).kind
-  h2 := SceneTree.route(h1.intoActor(), ttZero(), 0, Pointer(kind: Up, x: 20.0, y: 20.0, over: true))
+  h2 := SceneTree.route(h1.intoNode(), ttZero(), 0, Pointer(kind: Up, x: 20.0, y: 20.0, over: true))
   assert n1 == 1
   assert k1 == Press
   assert h2.events.length() == 2
@@ -327,8 +328,7 @@ test "route_child_first_then_group"
   assert h2.events.at(1).id == 5
 test "stale_path_reaches_group_only"
-  nine := Slice[Int]()
+  nine := Slice(9)
-  nine.push(9)
   h := SceneTree.route(ttButtonRoot(), nine, 0, Pointer(kind: Down, x: 20.0, y: 20.0, over: true))
   assert h.events.length() == 0
@@ -351,3 +351,8 @@ test "compaction_keeps_order"
   assert {ttKid(m).y - 0.6}.abs() < 1e-6
   assert {ttKid(m).rotation - 1.12}.abs() < 1e-6
   assert {ttKid(m).x - 1.0}.abs() < 1e-6
+test "update_runs_custom_actor_act"
+  c := PureScene.custom(9, 1.0, 0.0, 4.0, 4.0, TtStepper(ticks: 0))
+  n := SceneTree.update(PureScene.group(1, 0.0, 0.0, 10.0, 10.0, Slice(c)), 0.016)
+  assert ttFirstKidX(n) == 2.0

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -7798,6 +7798,18 @@ fn compileExprCore(
                 state,
             )?;
         }
+        // A field-less variant or record built with call syntax (`Panel()`, e.g. a record
+        // that only embeds a field-less trait): same value as the bare name.
+        ast::Expr::ClassCall(call)
+            if call.fields.is_empty()
+                && call.spread.is_none()
+                && ctx
+                    .enum_variants
+                    .get(&call.type_name)
+                    .is_some_and(|info| info.field_types.is_empty() && info.values.is_empty()) =>
+        {
+            compileExpr(&ast::Expr::TypeName(call.type_name.clone()), body, ctx, state)?;
+        }
         // A NAMED-payload enum variant construction (`Circle(radius: 5)`, as
         // opposed to the positional/generic-payload form `Next(T)` — constructed
         // via `Expr::FnCall` instead, elsewhere) — mirrors `plum-checker`'s own

plum-wasm-codegen/tests/empty_record_embed_e2e_test.rs ADDED Viewed

@@ -0,0 +1,76 @@
+#![allow(non_snake_case)]
+use plum_wasm_codegen::compileSource;
+fn gcEngine() -> wasmtime::Engine {
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    wasmtime::Engine::new(&config).expect("engine with GC config should construct")
+}
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn load(name: &str, src: &str) -> Result<plum_core::ast::Source, String> {
+    let dir = std::env::temp_dir().join(format!("plum_empty_record_embed_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    r.map_err(|e| format!("{e}"))
+}
+/// Compiles `src` through the real pipeline and runs its `main() -> Int`.
+fn runInt(name: &str, src: &str) -> i64 {
+    let source = load(name, src).expect("load");
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/Slice\n\n";
+fn prog(body: &str) -> String {
+    format!("{PRE}{body}")
+}
+#[test]
+fn field_less_record_embedding_field_less_trait_dispatches_in_a_slice() {
+    let src = prog("\
+trait Actor =
+  fun act(self, n: Int) -> Int = n
+  fun draw(self) -> Int = 1
+record Panel(Actor) =
+  override fun draw(self) -> Int = 10
+record Ship(Actor, speed: Int) =
+  override fun act(self, n: Int) -> Int = n + self.speed
+  override fun draw(self) -> Int = 100
+fun main() -> Int =
+  xs: Slice[Actor] := Slice[Actor]()
+  xs.push(Panel())
+  xs.push(Ship(speed: 5))
+  total := 0
+  for i := range 2
+    total = total + xs[i].draw() + xs[i].act(1000)
+  total
+");
+    // Panel: draw 10 + act 1000; Ship: draw 100 + act 1005.
+    assert_eq!(runInt("slice", &src), 2115);
+}