incanto 0.72.0 → 0.74.0

package/skills/incanto-physics-and-input.md

@@ -35,6 +35,10 @@ independent; enable the one matching your scene.
 `{"shape":"heightfield"}` (STATIC-only; reads the grid from a `Terrain3D` child — see the
 incanto-environment skill).
 Malformed colliders are hard `BAD_FORMAT` errors at enable time.
+The collider FOLLOWS the terrain: reshape the `Terrain3D` at runtime — `maxHeight`,
+`seed`, `roughness`, a channel a `River3D` cuts — and the heightfield is rebuilt on the
+next physics step, so the ground is walked on where it is drawn (the editor's collider
+outline moves with it for the same reason).
 
 **`{"shape":"auto"}` is the one to reach for on props.** It shapes the collider like the
 `MeshInstance3D` the body CARRIES — box→cuboid, sphere→ball, cylinder/capsule→their own
@@ -49,6 +53,10 @@ the corners. Give the body its mesh as a CHILD and let the shape follow:
   "children": [ { "name": "Deck", "type": "MeshInstance3D",
     "props": { "mesh": "box", "size": [14, 0.22, 2.2] } } ] }
 ```
+It FOLLOWS the mesh, too: resize it, turn the box into a sphere, or move it inside the
+body at runtime and the collider is rebuilt on the next physics step — the same rule the
+heightfield keeps with its terrain. A body that takes its shape from another node moves
+with that node, not only with its own `collider` prop.
 
 The child's OWN `position`, `rotation` and `scale` are part of the shape: raise the plank on
 the child instead of the body and the collider goes up with it; scale the crate 4× and it is
@@ -77,19 +85,48 @@ The body simply does not exist until the model has downloaded — nothing is inv
 meantime — and it appears the step the asset lands. A body is ONE shape, so `auto` fits one
 mesh or one model and warns when the body carries more.
 
-- **`StaticBody2D/3D`** — immovable (ground, walls). Props: `collider`.
+- **`StaticBody2D/3D`** — immovable (ground, walls). Props: `collider`, and the SURFACE it
+  is: `friction 0.5` (0 = ice, 1+ = glue) and `restitution 0` (1 = trampoline; above 1
+  is allowed and is a catapult). Two things a pad under the PLAYER taught: the controller's
+  falls run at `fallGravity` (2.5×) and its rises at 1×, so a `restitution 1` pad injects
+  energy on every bounce of a character that falls onto it (measured: 6.9 m, then 11.6 m) —
+  use ~0.8 for a pad players land on again and again; and `friction 0` is not ice for a
+  CharacterController3D, because the controller brakes itself (its own damping, not the
+  floor's friction, stops it) — an ice patch slows a crate, not the character. A static
+  body's authored value WINS the pair — restitution above 0 combines by Max, friction below
+  the default by Min and above it by Max — so a trampoline launches a dead ball and an ice
+  patch slides a grippy crate. The same on a `RigidBody`: its own `friction`/`restitution`
+  win the pair too; when both sides speak, Rapier's order (Max > Multiply > Min > Average)
+  decides. Left at the defaults it pairs by average, as it always did.
+  On a `Terrain3D`, `snapToGround: <lift>` on the body sits the pad on the island at load
+  (beacon-isle's trampoline: `snapToGround: 0.1` for a 0.2 m slab).
 - **`RigidBody2D/3D`** — simulated. Props: `collider`, `mass 1`, `gravityScale 1`,
   `fixedRotation false`, `friction 0.5`, `restitution 0`, `linearVelocity` (write to launch,
   read back every step; `velocity` is an alias for it). 3D also has
-  `angularVelocity`. Every one of them is LIVE — write it mid-run and the solver
-  picks it up on the next step.
+  `angularVelocity` (RADIANS per second about each world axis — the one place the
+  engine is not in degrees). Every one of them is LIVE — write it mid-run and the solver
+  picks it up on the next step. Three things a first composition of these measured:
+  an authored `restitution` or `friction` WINS the pair whichever side wrote it — a `0.75`
+  ball on a plain floor keeps 75% of its speed (it used to average with the floor's 0 and
+  keep 37%), a `friction: 0` body slides on a plain floor as if the floor were ice (the
+  character skill's recipe, honoured at last: walk 4.0, not 3.7);
+  `gravityScale: 0` with an `angularVelocity` and a `linearVelocity` is a floating,
+  spinning, drifting prop and a NEGATIVE `gravityScale` rises; and the body's
+  `rotation` is written back as Euler XYZ, which reports a yaw past 90° as
+  `[180, 180 − yaw, 180]` — recover a heading from all three, never from `rotation[1]`.
 - **`Area2D/3D`** — sensor. Emits `triggerEnter(other)` / `triggerExit(other)`. Never blocks
   movement. Solid bodies emit the same signals on real contact (one mental model).
   Areas overlapping OTHER Areas fire too (e.g. a weapon-hitbox Area over an
   enemy-hitbox Area) — neither side needs to be a Body.
 - **`CharacterBody2D/3D`** — kinematic character (Rapier KCC). Props: `collider`
   (capsule recommended), `velocity`, `stickToGround true`, `slopeLimitDeg 45`,
-  `stepHeight` (3D `0.35` m / 2D `35` px — see below).
+  `stepHeight` (3D `0.35` m / 2D `35` px — see below), and
+  **`collideWithCharacters true`** — whether OTHER characters are obstacles to
+  this one. Leave it on for a few enemies; turn it OFF for a horde: eighty
+  chasers around a player cost 64–286 ms a STEP with it on (each slide
+  shape-casts against every neighbour — O(n²) in the crowd, and 93% of the
+  profile was Rapier) and 1.6 ms off. The horde overlaps itself and nobody
+  minds; it still collides with the floor and the walls.
   API: `moveAndSlide()` (call from `fixedUpdate`), `isOnFloor()`,
   **`isOnWall()`** and **`isOnCeiling()`**. Which wall is answered in the shape
   each dimension has: 2D's `wallSide()` is `-1` left / `+1` right, 3D's
@@ -336,7 +373,8 @@ per frame from `update(dt)` scaled by `dt`. In 2D the impulse is in px·kg/s,
 y-down, exactly like `linearVelocity`.
 
 Readable/writable body state, in BOTH adapters: `velocity` (= `linearVelocity`),
-`angularVelocity`, `mass`, `gravityScale`, `friction`, `restitution`. Read the
+`angularVelocity`, `mass`, `gravityScale`, `friction`, `restitution`,
+`linearDamping`, `angularDamping`. Read the
 spin to see how fast a lever is swinging; write it to launch a spinning body.
 3D's is a 3-vector about the world axes, 2D's is the scalar rad/s about z with
 the same sign as `rotation` (clockwise, because 2D is y-down). There is no
@@ -352,6 +390,30 @@ body is CREATED. Changing it mid-run does nothing, and a locked body's
 > in both, `mass`/`friction`/`restitution` were read once at creation in both,
 > and `gravityScale` was live in 3D and dead in 2D.
 
+### A ball that never stops (`angularDamping`, `linearDamping`)
+
+A sphere on a flat floor, one impulse: 4.27 m/s at one second and 4.27 at
+eight. Rapier has no rolling resistance — friction only converts slip into
+spin, and a rolling ball is a wheel — so a golf ball, a bowling ball, a marble
+and a kicked can all rolled to the edge of the world. Two props, per second,
+`0` by default (nothing you built changes):
+
+| prop | what it damps | reach for it when |
+|---|---|---|
+| `angularDamping` | the SPIN, so a rolling body coasts to a stop | anything that rolls: `2` stops a golf ball from 4 m/s in about four seconds, `0.5` is a long coast |
+| `linearDamping` | the VELOCITY itself, `e^(-k·t)` | drag through air or water: a parachute, a puck on felt, a body that must not fly forever |
+
+```json
+{ "name": "Ball", "type": "RigidBody3D",
+  "props": { "friction": 0.6, "restitution": 0.3, "angularDamping": 2,
+             "collider": { "shape": "sphere", "radius": 0.2 } } }
+```
+
+Both are live — a green that slows the ball, a pond that drags it — and both
+exist on `RigidBody2D` in the same terms. "At rest" is yours to decide: read
+`physics.velocityOf(ball)` and call it stopped under ~0.05 for a few frames.
+`examples/minigolf-3d` is the composition.
+
 ## What is inside this Area right now?
 
 `triggerEnter(other)` / `triggerExit(other)` tell you about CROSSINGS. A pressure

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.74.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.74.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.74.0",
     "three": "^0.184.0"
   },
   "devDependencies": {