incanto 0.72.0 → 0.73.0

package/skills/incanto-scene-json-authoring.md

@@ -103,7 +103,11 @@ Rules the engine enforces with **hard errors** (it never warns silently):
    On export, default-equal values are omitted automatically.
 3. Prop keys and value kinds are validated against the type's schema:
    unknown key → `UNKNOWN_PROP` (message lists valid keys); wrong JSON kind
-   (e.g. string where the default is boolean) → `PROP_TYPE_MISMATCH`.
+   (e.g. string where the default is boolean) → `PROP_TYPE_MISMATCH`. A prop
+   whose default is `null` means AUTO — the engine decides — and validates the
+   other kinds it declares (`drape`/`collide`/`islandEdge`/`Chase.ground` take
+   a boolean, `snapToGround` a boolean or a lift in metres, `reflectivity` a
+   number); the editor offers the boolean ones as auto / on / off.
    A few props accept TWO kinds — `Flowers3D.density` takes a preset name or
    plants per m², `Water3D.underwater` takes `true`/`false` or a settings
    object — and `incanto-node-reference.md` names both in its Kind column
@@ -425,8 +429,10 @@ const resolveScene = (path: string) => (path === 'crate.scene.json' ? crateJson
 await runScript(sceneJson, { durationMs: 4000, resolveScene, steps: [...] });
 ```
 
-`examples/tiles-2d` is the worked example: two crates that ARE
-`crate.scene.json`, one of them adding a rope child of its own.
+`examples/tiles-2d` is the worked example in 2D: two crates that ARE
+`crate.scene.json`, one of them adding a rope child of its own. `examples/tps-3d`
+is the 3D one: the arena's cover blocks and pillars are `cover.scene.json` and
+`pillar.scene.json`, placed with a `position` override each.
 
 ## Error codes you will see (all hard failures at load)
 

package/skills/incanto-verifying-your-game.md

@@ -41,6 +41,10 @@ $ bunx incanto verify                       # finds your scene AND your behaviou
 passes what was measured — plays, draws not measured.
 next: nothing here is broken — a win that takes skill or a sequence is out of reach of random play. Judge it with a scripted run: `bun run verify`
 ```
+`--runs N` gives the `plays` rung more seeds (default 8). Eight see a one-in-eight event
+64% of the time; `bun run sweep` asks the six shipped starters for sixteen, and a starter that
+falls out of the world once in twelve runs is how the arena in tps-3d got its `Respawn`.
+
 
 ### `agrees` — do two clients hold the same values?
 
@@ -72,7 +76,10 @@ encodes so you do not have to remember them:
   warned about is printed under it with a `!` — `loads` runs `incanto-check`,
   and the ladder used to read only whether it passed and drop the warnings, so a
   scene the check describes as "It will render black" came back as
-  `✓ loads — the scene is legal and its assets resolve`;
+  `✓ loads — the scene is legal and its assets resolve` (LOCAL art is looked for on
+  disk; REMOTE urls are asked with a HEAD request — a 404 drops the claim to
+  `the scene is legal`, and a host that cannot be reached is a `note:`, never a
+  failure);
 - an **unmeasured** rung (`?`) is not a failure. "No dev server" means the
   question was never asked; treating that as a broken game sends you editing a
   scene that is fine;
@@ -218,7 +225,7 @@ const result = await runScript(sceneJson, {
   durationMs: 3000,
   seed: 42,                            // same seed → identical run
   steps: [
-    { atMs: 0,    vector: ['move', 1, 0] },          // hold right
+    { atMs: 0,    vector: ['move', 1, 0] },          // hold right (y is DOWN: forward is [0, -1])
     { atMs: 1000, press: 'jump' },
     { atMs: 1100, release: 'jump' },
     { atMs: 1500, label: 'jump apex reached',
@@ -252,6 +259,16 @@ captures; `result.logs` holds everything behaviors logged via `this.log`.
 Steps that never execute (atMs beyond the run) are reported as failures —
 an assert cannot "pass" by not running.
 
+**A game that has ended does not advance.** `GameFlow` stops the clock
+(`timeScale 0`) on a win or a loss, and a pause does the same; after that every
+`ctx.engine.step()` is a no-op and every value you read is the last one before
+it stopped. A harness that lost its player three times inside one `do:` then
+measured `0.00` for everything after it. The report now names each `do:`/`assert:`
+step that ran with the clock stopped (`! at 4000ms [measure apex]: the clock
+was stopped …`, also `result.stalled`) — read that line before reading the
+zeros. Measure before the game ends, or `restartScene` / read `Flow.state` in
+the step.
+
 Note: `validateScene`/`runScript` register node types and your `behaviors`
 into the process-global registries (hot-replacing same names). In a test
 suite, isolate with `clearRegistry()`/`clearBehaviors()` between files if

package/templates-app/beacon-isle-3d/PROJECT/Status.md

@@ -36,3 +36,11 @@
 
 - Boss attack telegraphs (charge-up glow, ground slam particles).
 - A hurt/attack clip for shades once one lands in the catalog.
+
+## This round's surfaces, on the island (2026-09-04)
+
+`Pad` (StaticBody3D, `restitution 1`, `snapToGround: 0.1`) with a dead `Ball` dropped on it,
+and `Walker` (CharacterBody3D + `Chase` on a child, `slopeLimitDeg 50`, `stepHeight 0.5`) on
+the west slope, `loseRange 25` so it never joins the quest. `verify.ts` measures the rebound
+(2.4 m of 3), the chase up the slope (8.5 m of 10, +1.75 m) and that the walker stays on the
+terrain (0.97 m over `heightAt`).

package/templates-app/beacon-isle-3d/PROJECT/Structure.md

@@ -22,3 +22,6 @@ verify.ts                audit + quest E2E + hunt + death/respawn + replay
   keeps lit wards; `IsleDirector.onReady` re-applies their glow.
 - The whole Terrain subtree is static EXCEPT Sea and Clouds (auditScene
   catches the freeze-the-water mistake if you regress this).
+
+- `Pad`, `Ball`, `Walker` — the harness's fixtures for a trampoline and a ground chaser on the
+  heightfield.

package/templates-app/beacon-isle-3d/package.json

@@ -14,7 +14,7 @@
     "@dimforge/rapier2d-compat": "0.19.3",
     "@dimforge/rapier3d-compat": "0.19.3",
     "@pixiv/three-vrm": "^3.5.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.73.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/beacon-isle-3d/src/game.scene.json

@@ -2759,6 +2759,142 @@
           }
         ],
         "uid": "n_0q1r3a6rijr3hc1w"
+      },
+      {
+        "name": "Pad",
+        "type": "StaticBody3D",
+        "uid": "n_uae445vafun14t1w",
+        "props": {
+          "position": [2, 0, 66],
+          "snapToGround": 0.1,
+          "collider": { "shape": "box", "size": [2, 0.2, 2] },
+          "restitution": 1
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "MeshInstance3D",
+            "uid": "n_r5z35fqhlhntir5y",
+            "props": {
+              "mesh": "box",
+              "size": [2, 0.2, 2],
+              "castShadow": true,
+              "material": { "color": "#3b82f6", "roughness": 0.7 }
+            }
+          }
+        ]
+      },
+      {
+        "name": "Ball",
+        "type": "RigidBody3D",
+        "uid": "n_rbwioxy4v827q3a4",
+        "props": { "position": [2, 60, 66], "collider": { "shape": "sphere", "radius": 0.3 } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "MeshInstance3D",
+            "uid": "n_hy0cclrpbgge9wiy",
+            "props": {
+              "mesh": "sphere",
+              "size": [0.3, 0.3, 0.3],
+              "castShadow": true,
+              "material": { "color": "#f4f1de" }
+            }
+          }
+        ]
+      },
+      {
+        "name": "Walker",
+        "type": "CharacterBody3D",
+        "uid": "n_mjjx1odvbl668a8p",
+        "props": {
+          "position": [-92, 0, -64],
+          "snapToGround": 0.95,
+          "slopeLimitDeg": 50,
+          "stepHeight": 0.5,
+          "collider": { "shape": "capsule", "radius": 0.4, "height": 1.1 }
+        },
+        "children": [
+          {
+            "name": "AI",
+            "type": "Node3D",
+            "uid": "n_73h5b3fzsep3ksnf",
+            "script": {
+              "name": "Chase",
+              "props": {
+                "target": "/root/Player",
+                "speed": 2.4,
+                "stopRange": 1.5,
+                "loseRange": 25,
+                "moveParent": true
+              }
+            }
+          },
+          {
+            "name": "Skin",
+            "type": "MeshInstance3D",
+            "uid": "n_lt6ypdouri4cicwd",
+            "props": {
+              "mesh": "capsule",
+              "size": [0.4, 1.1, 0.4],
+              "castShadow": true,
+              "material": { "color": "#6b4d8a", "roughness": 0.7 }
+            }
+          }
+        ]
+      },
+      {
+        "name": "Buoy",
+        "type": "RigidBody3D",
+        "uid": "n_y0kpfi62yas7ai09",
+        "props": {
+          "position": [-150, 9.6, 0],
+          "snapToGround": false,
+          "mass": 20,
+          "collider": { "shape": "box", "size": [1, 1, 1] }
+        },
+        "script": {
+          "name": "Buoyancy",
+          "props": { "water": "/root/Terrain/Sea", "samples": 1, "drag": 0.1, "drift": 0 }
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "MeshInstance3D",
+            "uid": "n_tz2qooe24d5evtq2",
+            "props": {
+              "mesh": "box",
+              "size": [1, 1, 1],
+              "castShadow": true,
+              "material": { "color": "#f59e0b", "roughness": 0.6 }
+            }
+          }
+        ]
+      },
+      {
+        "name": "Crate",
+        "type": "RigidBody3D",
+        "uid": "n_x0on4nkgt4l83sic",
+        "props": {
+          "position": [-150, 9.6, 8],
+          "snapToGround": false,
+          "mass": 20,
+          "collider": { "shape": "box", "size": [1, 1, 1] }
+        },
+        "script": { "name": "Buoyancy", "props": { "drift": 0 } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "MeshInstance3D",
+            "uid": "n_u0ckada9zfkpv9zz",
+            "props": {
+              "mesh": "box",
+              "size": [1, 1, 1],
+              "castShadow": true,
+              "material": { "color": "#8b5a2b", "roughness": 0.8 }
+            }
+          }
+        ]
       }
     ],
     "uid": "n_nxftk1ep8wbi1bn9"

package/templates-app/beacon-isle-3d/verify.ts

@@ -285,3 +285,147 @@ const ok = (label: string, cond: boolean): void => {
 }
 
 console.log(process.exitCode ? '\nVERIFY FAILED' : '\nVERIFY OK');
+
+// ---- HEIGHTFIELD: this round's surfaces, on terrain instead of a flat arena -----
+// A trampoline pad snapped to the island (`snapToGround: 0.1` on a StaticBody3D
+// with `restitution 1`), a dead ball dropped on it, and a `CharacterBody3D`
+// walker chasing the player up the island's slope (`Chase.ground` auto: the
+// KCC's slopeLimitDeg and stepHeight decide, gravity keeps it on the ground).
+{
+  type Vec = { position: number[] };
+  type Terrain = { heightAt(x: number, z: number): number };
+  const ballY: number[] = [];
+  let walkerFrom: number[] = [];
+  let walkerTo: number[] = [];
+  let groundUnderWalker = 0;
+  let targetY = 0;
+  let closed = 0;
+  const result = await runScript(gameJson, {
+    behaviors: BEHAVIORS,
+    durationMs: 8000,
+    steps: [
+      {
+        atMs: 100,
+        do: (ctx) => {
+          const pad = ctx.getNode('/root/Pad') as unknown as Vec;
+          const ball = ctx.getNode('/root/Ball') as unknown as Vec;
+          ball.position = [pad.position[0] ?? 0, (pad.position[1] ?? 0) + 3, pad.position[2] ?? 0];
+        },
+      },
+      ...Array.from({ length: 30 }, (_, i) => ({
+        atMs: 200 + i * 100,
+        do: (ctx: { getNode(p: string): unknown }) => {
+          ballY.push((ctx.getNode('/root/Ball') as Vec).position[1] ?? 0);
+        },
+      })),
+      {
+        atMs: 3300,
+        do: (ctx) => {
+          const terrain = ctx.getNode('/root/Terrain/Ground/Surface') as unknown as Terrain;
+          const walker = ctx.getNode('/root/Walker') as unknown as Vec;
+          const player = ctx.getNode('/root/Player') as unknown as Vec;
+          const [wx = 0, , wz = 0] = walker.position;
+          // the steepest way UP from the walker, 10 m out: that is where the player goes
+          let best = { x: wx + 10, z: wz, h: -Infinity };
+          for (let a = 0; a < 16; a++) {
+            const x = wx + 10 * Math.cos((a / 16) * Math.PI * 2);
+            const z = wz + 10 * Math.sin((a / 16) * Math.PI * 2);
+            const h = terrain.heightAt(x, z);
+            if (h > best.h) best = { x, z, h };
+          }
+          player.position = [best.x, best.h + 1.4, best.z];
+          targetY = best.h;
+          walkerFrom = [...walker.position];
+          const d0 = Math.hypot(best.x - wx, best.z - wz);
+          for (let i = 0; i < 240; i++) ctx.engine.step();
+          walkerTo = [...walker.position];
+          const [tx = 0, , tz = 0] = walkerTo;
+          groundUnderWalker = terrain.heightAt(tx, tz);
+          closed = d0 - Math.hypot(best.x - tx, best.z - tz);
+          player.position = [-4.5, 18.73, 70.5]; // and back to the spawn for the quest
+        },
+      },
+    ],
+  });
+  ok('runScript reported no failures (HEIGHTFIELD path)', result.ok);
+  let touch = ballY.findIndex((y, i) => i > 0 && y > (ballY[i - 1] ?? 0));
+  if (touch < 1) touch = 1;
+  const low = ballY[touch - 1] ?? 0;
+  const rebound = Math.max(...ballY.slice(touch)) - low;
+  ok(
+    `a pad snapped to the island with restitution 1 launches a dead ball back up ${rebound.toFixed(2)} m of its 3 m drop`,
+    rebound > 1.8,
+  );
+  const rose = (walkerTo[1] ?? 0) - (walkerFrom[1] ?? 0);
+  const gap = targetY - (walkerFrom[1] ?? 0);
+  ok(
+    `the walker chased the player UP the slope: closed ${closed.toFixed(1)} m of 10, rose ${rose.toFixed(2)} m of a ${gap.toFixed(2)} m climb`,
+    closed > 5 && rose > gap * 0.5,
+  );
+  const hover = (walkerTo[1] ?? 0) - groundUnderWalker;
+  ok(
+    `…and stayed on the ground while doing it (capsule centre ${hover.toFixed(2)} m over the terrain, 0.95 expected)`,
+    hover > 0.5 && hover < 1.6,
+  );
+}
+
+// ---- FLOATS: what `Buoyancy.water`, `samples` and `drag` do on the open sea --------
+// Set by no example: every raft in the repo took the first Water3D, four samples
+// and the default drag. Two crates float west of the island (the heightfield
+// ends at x −120): the Buoy names its water, samples once and says `drag: 0.1`;
+// the Crate keeps the defaults. Both `drift: 0`, so a 3 m/s shove is the only
+// thing moving them and drag is the only thing that differs. Asserted by how
+// far each travels in 2 s — e^{-drag·t} says 5.4 m against 2.8 m — and by both
+// still sitting at the waterline afterwards.
+{
+  type Vec = { position: number[] };
+  type Body = { mass: number; applyImpulse(i: [number, number, number]): void };
+  type Water = { heightAt(x: number, z: number): number };
+  let buoyRest = 0;
+  let crateRest = 0;
+  let buoyRun = 0;
+  let crateRun = 0;
+  let buoyOver = 99;
+  let crateOver = 99;
+  const result = await runScript(gameJson, {
+    behaviors: BEHAVIORS,
+    durationMs: 8000,
+    steps: [
+      {
+        atMs: 100,
+        do: (ctx) => {
+          const sea = ctx.getNode('/root/Terrain/Sea') as unknown as Water;
+          const buoy = ctx.getNode('/root/Buoy') as unknown as Vec & Body;
+          const crate = ctx.getNode('/root/Crate') as unknown as Vec & Body;
+          for (let i = 0; i < 240; i++) ctx.engine.step(); // 4 s to settle on the waterline
+          buoyRest = buoy.position[1] ?? 0;
+          crateRest = crate.position[1] ?? 0;
+          const bx = buoy.position[0] ?? 0;
+          const cx = crate.position[0] ?? 0;
+          buoy.applyImpulse([3 * buoy.mass, 0, 0]);
+          crate.applyImpulse([3 * crate.mass, 0, 0]);
+          for (let i = 0; i < 120; i++) ctx.engine.step();
+          buoyRun = (buoy.position[0] ?? 0) - bx;
+          crateRun = (crate.position[0] ?? 0) - cx;
+          buoyOver =
+            (buoy.position[1] ?? 0) - sea.heightAt(buoy.position[0] ?? 0, buoy.position[2] ?? 0);
+          crateOver =
+            (crate.position[1] ?? 0) - sea.heightAt(crate.position[0] ?? 0, crate.position[2] ?? 0);
+        },
+      },
+    ],
+  });
+  ok('runScript reported no failures (FLOATS path)', result.ok);
+  ok(
+    `water "/root/Terrain/Sea", samples 1: the Buoy settles at y ${buoyRest.toFixed(2)} (sea 9.19 + draft 0.35 ≈ 9.54), the Crate at ${crateRest.toFixed(2)}`,
+    Math.abs(buoyRest - 9.54) < 0.5 && Math.abs(crateRest - 9.54) < 0.5,
+  );
+  ok(
+    `drag 0.1 vs 0.9: the same 3 m/s shove carries the Buoy ${buoyRun.toFixed(2)} m and the Crate ${crateRun.toFixed(2)} m in 2 s (5.4 vs 2.8 expected)`,
+    buoyRun > crateRun * 1.5 && buoyRun > 4 && crateRun > 1.5 && crateRun < 3.5,
+  );
+  ok(
+    `…and both still ride the waterline (${buoyOver.toFixed(2)} m and ${crateOver.toFixed(2)} m over the sea)`,
+    Math.abs(buoyOver - 0.35) < 0.5 && Math.abs(crateOver - 0.35) < 0.5,
+  );
+}

package/templates-app/molehill-2d/package.json

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@dimforge/rapier2d-compat": "0.19.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.73.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/platformer-2d/PROJECT/Status.md

@@ -58,3 +58,10 @@
 - One hand-authored level — extend by copying nodes into the right GROUP
   (`enemy`/`hazard`/`pit`/`checkpoint`/`platform`); `PlayerController` picks them
   up with no extra wiring.
+
+## The round's surfaces, in 2D (2026-09-04)
+
+A course past GroundD (x 3000+): `Trampoline` (`restitution 1`) with a dead `Bouncer`, `Ice`
+(`friction 0`) with a `Sled` at 260 px/s, and a `Hound` (`CharacterBody2D` + `Chase`
+`ground: true`) under a `Perch`. `verify.ts` measures the rebound (287 of 300 px), the slide
+(400 px of ice) and that the hound stays on the floor under a perched player.

package/templates-app/platformer-2d/PROJECT/Structure.md

@@ -75,3 +75,6 @@ The vibe-coding rules: read the skills, JSON structure, built-ins first, omit
 uids, declared assets, y-down space, collider props, GROUP-DRIVEN centralised
 damage (§8), deferred engine access (§11), debug draw, delta discipline, verify
 like a user.
+
+- `CourseFloor`, `Trampoline`, `Bouncer`, `Ice`, `Sled`, `Hound`, `Perch` — the harness's course for
+  the 2D surfaces and the ground chaser.

package/templates-app/platformer-2d/package.json

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@dimforge/rapier2d-compat": "0.19.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.73.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/platformer-2d/src/game.scene.json

@@ -1350,6 +1350,132 @@
           }
         ],
         "uid": "n_i3xs3gnb3cyrar1u"
+      },
+      {
+        "name": "CourseFloor",
+        "type": "StaticBody2D",
+        "uid": "n_9p55c0wu33vbe194",
+        "props": { "position": [3300, 520], "collider": { "shape": "rect", "size": [900, 120] } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_56chxbokw5okl2ar",
+            "props": { "size": [900, 120], "color": "#6b5638", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Trampoline",
+        "type": "StaticBody2D",
+        "uid": "n_vqjbknb54e0zq787",
+        "props": {
+          "position": [3000, 455],
+          "collider": { "shape": "rect", "size": [120, 10] },
+          "restitution": 1
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_bed7i5blyg8p63ij",
+            "props": { "size": [120, 10], "color": "#3b82f6", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Bouncer",
+        "type": "RigidBody2D",
+        "uid": "n_8vd73zp82idtm5gx",
+        "props": { "position": [3000, 150], "collider": { "shape": "circle", "radius": 14 } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_n18pdy731ltnmb3l",
+            "props": { "size": [28, 28], "color": "#f4f1de", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Ice",
+        "type": "StaticBody2D",
+        "uid": "n_zlp89ikkls0xkbwn",
+        "props": {
+          "position": [3400, 455],
+          "collider": { "shape": "rect", "size": [400, 10] },
+          "friction": 0
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_opic7894wramqynx",
+            "props": { "size": [400, 10], "color": "#bfe9ff", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Sled",
+        "type": "RigidBody2D",
+        "uid": "n_nhcrprd8no2pzb9i",
+        "props": {
+          "position": [3215, 435],
+          "collider": { "shape": "circle", "radius": 14 },
+          "linearVelocity": [260, 0]
+        },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_y2owjzo7khqchken",
+            "props": { "size": [28, 28], "color": "#8c6a3f", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Hound",
+        "type": "CharacterBody2D",
+        "uid": "n_kmnt12lx070t311c",
+        "props": { "position": [3650, 440], "collider": { "shape": "rect", "size": [30, 40] } },
+        "children": [
+          {
+            "name": "AI",
+            "type": "Node2D",
+            "uid": "n_juz8aw6j311cstbs",
+            "script": {
+              "name": "Chase",
+              "props": {
+                "target": "/root/Player",
+                "speed": 160,
+                "stopRange": 24,
+                "loseRange": 500,
+                "moveParent": true,
+                "ground": true
+              }
+            }
+          },
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_k5h72ttrivo8vy0m",
+            "props": { "size": [30, 40], "color": "#6b4d8a", "anchor": [0.5, 0.5] }
+          }
+        ]
+      },
+      {
+        "name": "Perch",
+        "type": "StaticBody2D",
+        "uid": "n_t6vi97e88isgglef",
+        "props": { "position": [3650, 300], "collider": { "shape": "rect", "size": [160, 20] } },
+        "children": [
+          {
+            "name": "Skin",
+            "type": "ColorRect2D",
+            "uid": "n_m7qcxz6z1sc6rfbv",
+            "props": { "size": [160, 20], "color": "#9aa3bd", "anchor": [0.5, 0.5] }
+          }
+        ]
       }
     ],
     "uid": "n_d9t51gs0vhpnp2jj"

package/templates-app/platformer-2d/verify.ts

@@ -273,3 +273,57 @@ interface Player {
 }
 
 console.log(process.exitCode ? '\nVERIFY FAILED' : '\nVERIFY OK — Castle Run plays end to end');
+
+// ---- TWIN: this round's 3D surfaces, in two dimensions ----------------------------
+// StaticBody2D.restitution/friction (#1295) and Chase.ground (#1297) were built
+// with the 3D case in hand and 2D tests beside it; a course past the last
+// ground slab composes them in the 2D flagship and measures each. y is DOWN.
+{
+  type Body = { position: number[] };
+  const bouncerY: number[] = [];
+  let sledX = 0;
+  let houndY = 0;
+  let houndX = 0;
+  const result = await runScript(sceneJson, {
+    behaviors,
+    durationMs: 4200,
+    steps: [
+      ...Array.from({ length: 30 }, (_, i) => ({
+        atMs: 100 + i * 100,
+        do: (ctx: { getNode(p: string): unknown }) => {
+          bouncerY.push((ctx.getNode('Bouncer') as Body).position[1] ?? 0);
+        },
+      })),
+      {
+        atMs: 3100,
+        do: (ctx) => {
+          sledX = (ctx.getNode('Sled') as unknown as Body).position[0] ?? 0;
+          // the player on the perch above the hound: a ground chaser closes in below, never up
+          const player = ctx.getNode('Player') as unknown as Body;
+          player.position = [3650, 260];
+          for (let i = 0; i < 120; i++) ctx.engine.step();
+          const hound = ctx.getNode('Hound') as unknown as Body;
+          houndX = hound.position[0] ?? 0;
+          houndY = hound.position[1] ?? 0;
+        },
+      },
+    ],
+  });
+  ok('runScript reported no failures (TWIN path)', result.ok);
+  let touch = bouncerY.findIndex((y, i) => i > 0 && y < (bouncerY[i - 1] ?? 0));
+  if (touch < 1) touch = 1;
+  const low = bouncerY[touch - 1] ?? 0;
+  const rebound = low - Math.min(...bouncerY.slice(touch));
+  ok(
+    `StaticBody2D restitution 1: a dead ball climbs back ${rebound.toFixed(0)} px of its 300 px drop`,
+    rebound > 180,
+  );
+  ok(
+    `StaticBody2D friction 0: the sled slides to x ${sledX.toFixed(0)} across the ice (from 3215)`,
+    sledX > 3450,
+  );
+  ok(
+    `Chase.ground: the hound stays on the floor (y ${houndY.toFixed(0)}, floor 440) under a player on the perch, ${Math.abs(houndX - 3650).toFixed(0)} px off its x`,
+    houndY > 400 && Math.abs(houndX - 3650) < 60,
+  );
+}

package/templates-app/star-survivor/package.json

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@dimforge/rapier2d-compat": "0.19.3",
-    "incanto": "^0.72.0",
+    "incanto": "^0.73.0",
     "three": "^0.184.0"
   },
   "devDependencies": {

package/templates-app/tps-3d/PROJECT/Context.md

@@ -5,7 +5,7 @@
 "Vanguard" — a 3D THIRD-PERSON shooter. The camera rides over your soldier's
 shoulder (you SEE your character); the crosshair is where the hitscan rifle
 fires. Move with WASD, look with the mouse (click locks the pointer), Shift to
-sprint, Space to jump, click / F to fire, R to reload, Enter to restart. Survive and clear three
+sprint, Space to jump (tap for a short hop, hold for the full jump, press again in the air for a second), click / F to fire, R to reload, Enter to restart. Survive and clear three
 escalating waves of chasing enemies to **SECURE THE AREA**; let them drain your
 HP to 0 and the **MISSION FAILS**.