Add vertical gusts, freeze debris.pieces, fix fog restore

SPRINT2 decisions 3 and 5, plus Lane A's fog nit.

Decision 3 — gusts now descend. Cloth pressure goes with dot(wind, normal); a
flat panel's normal points at the sky, so in a perfectly horizontal wind the
dot is ~0 and "lie it flat and ignore the storm" was the cheapest winning rig.
A gust front is descending air, not just faster air. Per-gust downdraft
fraction in storm JSON (storm_02 0.3, storm_01 0.18, default 0.25, validated
0..1), each gust varying 0.6-1.4x. Peak downdraft in storm_02 is 4.4 m/s, 17%
of the horizontal. Lane B: the cloth-side assert is yours.

The vertical draws from its OWN rng stream, and there's an assert pinning
that: pulling it from the main stream would shift every subsequent (t0, pow)
and silently re-time storms Lane A has already hand-verified. Their carabiner
still blows at t=45.4 and cascades at t=56.

speedAt() stays horizontal — an anemometer doesn't read falling air, and a
wind meter that spikes because a gust is descending reads as a bug.

Decision 5 — debris.pieces frozen and documented in contracts.js as the seam
Lane B reads in sail.step(), with the sphere/SI/mutated-in-place semantics
spelled out and an assert tying the live shape to the contract table.

Fog: dispose() captured scene.fog by reference and step() mutates that object
in place, so restoring it restored nothing (Lane A caught it). Now captured by
value, and fog we created ourselves is removed rather than left behind.

Selftest 130/0/0 (was 121); Lane C 28 asserts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.claude/launch.json

@@ -4,14 +4,8 @@
     {
       "name": "shades3d",
       "runtimeExecutable": "python3",
-      "runtimeArgs": ["server.py"],
-      "port": 8801
-    },
-    {
-      "name": "shades-proto",
-      "runtimeExecutable": "python3",
-      "runtimeArgs": ["-m", "http.server", "8642", "--directory", "prototype"],
-      "port": 8642
+      "runtimeArgs": ["server.py", "--port", "8811"],
+      "port": 8811
     }
   ]
 }

.gitignore

@@ -6,6 +6,11 @@
 *.obj
 *.mtl
 
+# Lane E: per-asset verification renders — regenerable, and 3 MB of churn.
+# The tiled tools/blender/contact_sheet.png IS committed; it's the acceptance
+# evidence for §5-E, and it renders deterministically so it never churns.
+tools/blender/thumbs/
+
 # macOS / python noise
 .DS_Store
 __pycache__/

LANE_PROMPTS.md

@@ -77,3 +77,84 @@ Lane A starts first; B/C/D/E can start immediately after in parallel
 > models/debris/. Verify every export by rendering a contact sheet against the
 > 1.7 m ref capsule (the 3D=models/_thumbnails pattern). Commit script AND
 > GLBs. Log in THREADS.md.
+
+---
+---
+
+# SPRINT 2 prompts (assembly — fire A/B/C/E together, D at gate 1)
+
+Same rules: own clone (`~/Documents/shades-lane<X>` on m3ultra), branch `lane/<x>`,
+rebase onto latest main FIRST (it moved: all lanes merged + importmap + path
+fixes + M3 clip pack). Read THREADS.md from the [I] integrator entries down,
+then SPRINT2.md in full — the six decisions at the top are final, stop
+re-deciding them.
+
+## Lane A — Sprint 2
+
+> You are Lane A on SHADES 3D, Sprint 2. Rebase onto main, read THREADS.md's
+> [I] entries and SPRINT2.md §Lane A. Your sprint IS the assembly: in main.js
+> swap stub wind → createWind (storm_01 calm phases, storm_02 for the storm),
+> placeholder → await createPlayer (importmap already landed), add the sail
+> view + rig step, skyfx + debris + unlockAudio, dress the yard with Lane E's
+> GLBs (house per decision 6 — read fascia_anchor_* from the GLB), rework
+> anchors per decision 2 (posts in, p3 added, tree branch_anchor_* live, with
+> the new quad-area assert), then HUD (loads in kN) and the four-phase machine.
+> Post "gate 1" in THREADS.md the moment weather+player+sail are live in the
+> yard so Lane D starts. Small commits, selftest green after each, you remain
+> merge shepherd per PLAN3D §6.
+
+## Lane B — Sprint 2
+
+> You are Lane B on SHADES 3D, Sprint 2. Rebase onto main, read THREADS.md [I]
+> entries and SPRINT2.md §Lane B + decisions 3/4/5. Land in this order: (1) the
+> decision-4 API — repair(i), trim(i,delta), cornerPos(i) — matching Lane D's
+> existing call sites in interact.js, with contract entries + asserts; (2)
+> decision 5 — consume debris.pieces in sail.step() with a momentum assert;
+> (3) the coverageOver ray-origin fix (heightAt, not y=0); (4) the prep-phase
+> picking adapter over RiggingSession once Lane A's anchor markers exist —
+> coordinate in THREADS; (5) the joint tuning session with Lane C against real
+> m/s storms, then re-run the §7 gate against REAL wind and log the constants;
+> (6) after C lands vertical gusts, the decision-3 assert (flat-horizontal no
+> longer dominant).
+
+## Lane C — Sprint 2
+
+> You are Lane C on SHADES 3D, Sprint 2. Rebase onto main, read THREADS.md [I]
+> entries and SPRINT2.md §Lane C + decision 3. Land: (1) vertical gust
+> component in storm JSON (downdraft fraction, ~0.25 default, validator +
+> asserts) — this closes the flat-horizontal loophole with Lane B; (2) freeze
+> and document the debris.pieces shape in contracts.js for B's integrator;
+> (3) rain-vs-sail occlusion so the garden visibly stays dry under cloth
+> (cheap — coordinate the API with B, don't ray-test every drop); (4) the
+> joint storm-tuning session with B (your THREADS ask — if storm_02 can't
+> break a carabiner rig, raise the curve, it's a data edit); (5) verify skyfx
+> light restoration inside the real main.js phase transitions once Lane A
+> wires it.
+
+## Lane D — Sprint 2 (start at gate 1)
+
+> You are Lane D on SHADES 3D, Sprint 2. Rebase onto main FIRST — the M3 clip
+> pack landed: player_anims.glb now carries 17 clips (ClimbLadder, Crank, Dig,
+> PickUp, Carry/CarryTurn/CarryIdle, StandUp, TakeCover, StumbleBack,
+> PlantSeeds beside your original six; names logged in THREADS). Also note the
+> integrator fixed /world/ → ./ relative paths in player.js and dev_player.html.
+> Wait for Lane A's "gate 1" THREADS entry, then: (1) verify controls + camera
+> feel in the real yard (slopes, world.solids collision), tune speeds to yard
+> scale, gust shove + knockdown from real wind and real debris hits; (2) wire
+> the full spare loop — shed_table pickup_anchor → Carry/CarryIdle while
+> carrying → repair(i) consumes the spare (B is landing repair/trim/cornerPos
+> to your call sites, decision 4); (3) prompts track cornerPos(i) live; (4)
+> wire Crank to trim(i), TakeCover as the storm shelter verb, StumbleBack for
+> gust knockback — your state machine, your call on transitions. The §7
+> one-mid-storm-repair scenario must be playable by hand before you're done.
+
+## Lane E — Sprint 2 (small)
+
+> You are Lane E on SHADES 3D, Sprint 2. Rebase onto main, read SPRINT2.md
+> §Lane E. Small sprint: (1) canopy sway handles — verify your canopy_* nodes
+> sway cleanly when Lane A drives them, add sway_hint props if per-tree tuning
+> is needed; (2) a 512² sail cloth weave atlas + tear decal strip so the
+> membrane reads as fabric; (3) storm dressing set: wheelie bin (mass_hint),
+> washing line, garden gnome — same one-script determinism + contact-sheet
+> acceptance; (4) when Lane A's yard is dressed, render a contact sheet of the
+> assembled yard from the game camera for DESIGN.md.

SPRINT2.md

@@ -0,0 +1,132 @@
+# SPRINT 2 — ASSEMBLY (instructions for Opus 4.8 lanes)
+
+*Sprint 1 verdict: every module is built and proven in isolation — 121/121
+selftest asserts green on merged main — but the game is not assembled. main.js
+still drives the M0 placeholder capsule and stub wind. Sprint 2 is one thing:
+**wire the proven modules into one playable storm.** Read THREADS.md from your
+last entry down before starting; the integrator [I] entry lists what changed
+under you.*
+
+## Decisions (made — stop waiting on them)
+
+1. **Lanes run on m3ultra.** Lane D's recommendation is adopted: the M1 Ultra
+   (`johnking@100.91.239.7`) is an asset-build box you SSH to; GLBs get committed;
+   the game never needs it at runtime. PLAN3D §0 is amended by this line.
+2. **Sail-area problem (B's 70–192 m² finding): fix the yard, not the physics.**
+   Lane A: move p1/p2 in to roughly (−4.5, 5.5) and (4.0, 6.0), add a third post
+   p3 near (0, 7), and register the trees' `branch_anchor_*` empties (E shipped
+   them with `rating_hint`) as anchors. Target: at least three pickable quads in
+   the 18–45 m² range that can shade the garden bed, verified by a new a.test
+   assert that enumerates quad areas. The huge quads stay possible — the load
+   bars teaching "you cannot span the whole yard" is design working as intended.
+3. **Flat-horizontal loophole: Lane C closes it with vertical gust structure.**
+   Real gusts aren't horizontal; add a per-gust vertical component (downdraft
+   fraction in storm JSON, default ~0.25 of gust power, validated) so a
+   horizontal plate carries real load. Lane B adds the assert: over 8 directions
+   in storm_02 wind, flat-horizontal peak load ≥ 60% of flat-pitched peak (i.e.
+   no longer a free lunch). Ponding stays out of scope (M4 water spike).
+4. **repair/trim seam: Lane B conforms to Lane D's call sites** (D landed first,
+   duck-typed): add `repair(i)` (→ repairCorner with the spare's hw),
+   `trim(i, delta)` (→ trimCorner) and `cornerPos(i) -> Vector3` (live world
+   position, fresh vector) to the rig object. Contract entries + b.test asserts.
+5. **debris↔sail seam: option (b)** — Lane B reads `debris.pieces`
+   ({x,y,z,vx,vy,vz,r,mass}) inside `sail.step()` and applies impulses; momentum
+   bookkeeping stays in the one integrator. Lane C freezes the `pieces` shape.
+6. **House GLB: no re-cut.** Lane A reads `fascia_anchor_*` positions out of
+   `house_yardside_v1.glb` at load and places anchors there (data wins over the
+   yard constants). E's 2.80 m fascia replaces the 2.6 m graybox number.
+
+## Lane A — assemble the game (this is the sprint)
+
+main.js boot(), in order; keep each step behind a small commit:
+1. Stub wind → `createWind(storm)` — `storm_01_gentle` for prep/forecast calm,
+   `storm_02_wildnight` when the storm phase starts. Call
+   `wind.setSheltersFromTrees(...)` after the yard builds, per C's ask.
+2. Placeholder → `await createPlayer(scene, world, cameraRig, {wind, interact})`
+   (async boot; D says same first three args). Delete the placeholder factory.
+3. Sail: `const view = await createSailView(rig); scene.add(view); view.update()`
+   per frame after `rig.step(dt, wind, t)`. B's THREADS entry has the exact shape.
+4. `createSkyFx({scene, camera, wind, sun, hemi})` + `unlockAudio()` on first
+   input; `createDebris({heightAt: world.heightAt, onHitPlayer: player.knockdown})`,
+   `debris.setModels()` from `models/debris/` (glob the dir).
+5. Yard dressing: swap graybox house → `house_yardside_v1.glb` (decision 6),
+   shed + shed_table (D's spare pickup), sail posts as `sail_post_v1.glb` rotated
+   about `rake_pivot`, fence set, grass billboards off `textures/grass_atlas.png`.
+6. Anchor rework per decision 2.
+7. HUD: loads in **kN** (B's units note), per-corner bars vs rating, wind meter +
+   gust telegraph banner, garden % (wire `rig.coverageOver(world.gardenBed)` →
+   HP → E's `plants_full/tattered/dead` visibility swap), phase banner, forecast
+   card (storm JSON summary: peak wind, change time), aftermath screen (garden %,
+   corners lost, budget delta).
+8. Phase machine: forecast (show card, Enter) → prep (rigging UI live, budget
+   $80, optional timer OFF this sprint) → storm (90 s, storm_02) → aftermath.
+Acceptance: `python3 server.py` → rig a sail with the mouse, press Enter, watch
+storm_02 try to kill it, repair a corner mid-storm, see the aftermath screen.
+60 fps during the storm on this box. Selftest stays green after every merge.
+
+## Lane B — sail in the world
+
+1. Decision 4 API (repair/trim/cornerPos) + asserts.
+2. Decision 5: consume `debris.pieces` in step(); assert momentum is conserved
+   within tolerance on a crate-through-sail scenario.
+3. Prep-phase picking adapter: RiggingSession → clicks. Raycast against Lane A's
+   anchor markers (A exposes `world.anchorMarkers` if you need meshes — agree in
+   THREADS), corner cycling + tension dial + spare purchase, HUD summary line
+   from `summary()`. This unblocks A step 8.
+4. Joint tuning session with C (their THREADS ask): retune cloth ρ against real
+   m/s storms; then re-run the §7 gate against REAL wind (current assert used the
+   stub) — flat cheap rig cascades in storm_02, twisted mixed rig + one repair
+   survives. Log tuned constants in THREADS.
+5. Small fix: `coverageOver()` rays start at `heightAt(x,z)`, not y=0 (your nit).
+6. Decision 3 assert (flat-horizontal no longer dominant) once C lands vertical gusts.
+
+## Lane C — weather in the game
+
+1. Decision 3: vertical gust component in storm JSON + validator + asserts.
+2. Decision 5: freeze and document `debris.pieces` shape in contracts.js.
+3. Rain must react to the sail: cheap occlusion — sample `rig.coverageOver` cells
+   or raycast a handful of drops so the garden visibly stays dry under cloth.
+   (Coordinate the API with B; don't ray-test every drop.)
+4. Storm tuning session with B (see B-4).
+5. skyfx: verify light restoration on `dispose()` inside the real main.js scene —
+   A will call you if teardown flickers phase transitions.
+6. Consider retiring weather_demo.html once main.js hosts the storm — your call,
+   it stops earning its place when the game IS the bench.
+
+## Lane D — player in the storm
+
+1. After A's step 2 swap: verify controls + camera feel in the real yard (slopes,
+   fence collision against `world.solids`), tune walk/run speeds against yard
+   scale, make gust shove + knockdown fire from real wind and real debris hits.
+2. Wire the spare pickup loop end-to-end: shed_table `pickup_anchor` → carrying →
+   `repair(i)` consumes it (B's decision-4 API). The §7 "one mid-storm repair"
+   scenario must be playable by hand.
+3. Interaction prompts follow `cornerPos(i)` live (flogging corner = moving prompt).
+4. Kill dev_player.html only when the main game covers everything it proves.
+
+## Lane E — polish targets (small sprint)
+
+1. Wind-reactive foliage handles: verify canopy nodes sway cleanly when A drives
+   them; add `sway_hint` custom props if A needs per-tree tuning.
+2. Sail cloth texture (512² weave/UV-stripe atlas) so the membrane reads as
+   fabric, + a simple tear decal strip for M3.
+3. Storm dressing set: wheelie bin (debris, `mass_hint`), washing line, garden
+   gnome (collateral scoring bait). One script run, same acceptance as before.
+4. Contact-sheet the assembled yard from A's camera for DESIGN.md.
+
+## Order & gates
+
+```
+gate 1: A steps 1-4 land  → the yard has weather, a person and a live sail
+gate 2: B-3 picking + A-8 → the loop is playable start to finish
+gate 3: B/C tuning + D-2  → §7 scenario passes BY HAND and in selftest
+```
+Definition of done = gate 3 + THREADS updated + selftest green + a 90 s
+storm_02 run captured (screenshots or video) for the log.
+
+## For John (human-only items)
+
+- Mixamo login on the M1 for D's M3 wishlist (`tools/character/mixamo_wishlist.txt`
+  — Climbing Ladder, Turning Key, Digging). Not blocking this sprint.
+- Two dev servers float around: another session holds :8801; this repo's
+  launch.json now uses :8809. Kill either freely; `server.py --port N` works.

THREADS.md

@@ -81,6 +81,92 @@ Format: `[lane letter] YYYY-MM-DD — note`
     `~/Documents/shades-laneD/` and work there** — B, C and E already have their own. PLAN3D §0 says to
     do this; it's the one house rule that has to hold or the whole lane model stops working.
 
+[D] 2026-07-16 — Worktree collision: mine, sorry — acknowledged and fixed. I was launched in the shared
+    `~/Documents/shades/` and branched there, which is what moved HEAD under Lane A. Now on my own
+    worktree at `~/Documents/shades-laneD/` (branch `lane/d`); shared checkout handed back clean on
+    `main` at 8d76340, nothing of A's touched. My asset commit 027fb99 had already been swept into main
+    ahead of M0 — leaving it, it's what player.js loads.
+
+[D] 2026-07-16 — 🔑 **ANSWERS A's OPEN QUESTION + the §2 asset gap — the libraries are REAL, on the OTHER
+    box.** Lane A is right that `3D=models/`, `character_kit/`, `mixamo-fetch/` and `FBX/` do not exist on
+    `m3ultra`. They exist on the **M1 Ultra**, which is up and reachable over SSH right now
+    (`ssh johnking@100.91.239.7`, hostname `ultra.local`, no password needed). Verified there:
+      · `~/Documents/FBX/` — Running.fbx, Falling.fbx, Crouch To Stand.fbx, Reaction.fbx, Death.fbx…
+      · `~/Documents/3D=models/animations/` — 32 clips incl. Happy Idle.fbx, Walk.fbx, Start Walking.fbx
+      · `~/Documents/character_kit/` (rigged/, scripts/merge_anims.py), `~/Documents/mixamo-fetch/`,
+        `~/Documents/3D-STORE/` (Lane E: `clean_glbs/` + `build_booth_room_v23.py` are there too, in
+        addition to the `Destroyulater/3D-STORE/` copy A found here), and Blender 5.0.1.
+    **So §2's inventory isn't wrong, it's just written from the M1 — and §0 meant it: "all asset paths
+    below are local there".** This does NOT mean lanes should move. The copies rule already resolves it:
+    build the asset ON the M1, commit the GLB, and the game never needs that box again. That's what I did
+    — `player_anims.glb` was built there and is committed; `python3 server.py` on m3ultra needs nothing
+    remote. **Recommendation: lanes stay on m3ultra; the M1 is an asset-build box you SSH to.** Lane E,
+    that's your unblock too if you want Poly Haven/reference work — Blender is over there.
+
+[D] 2026-07-16 — ⚠️ **BLOCKS THE PLAYER SWAP — Lane A, one line in index.html.** Every vendored addon
+    imports from the **bare specifier `'three'`** (`vendor/addons/**/*.js` all end `} from 'three';`).
+    index.html has no importmap, so the moment it imports player.js it dies with "Failed to resolve
+    module specifier 'three'". Nothing hit this before because main/world/camera.js import
+    `../vendor/three.module.js` directly and use no addons — I'm the first lane to need one, and it isn't
+    optional: SkeletonUtils + GLTFLoader are what the DEVMANUAL rig rules mandate. Fix is the 90sDJsim
+    line, in `<head>` before the module script:
+      `<script type="importmap">{ "imports": { "three": "/world/vendor/three.module.js",
+        "three/addons/": "/world/vendor/addons/" } }</script>`
+    (selftest.html does NOT need it — d.test.js only imports the zero-dep sim, which is why it's green.)
+    **Lane E: this will land on you too** the moment you load a GLB. Alternative if you'd rather not add
+    a map: rewrite the 12 addon files' `from 'three'` → a relative path — but that forks the vendor drop
+    from upstream, so I'd take the importmap.
+
+[D] 2026-07-16 — **PLAYER LANDED** on `lane/d`, rebased on M0, ready for the boot() swap.
+    `player.sim.js` (deterministic core, zero imports) · `player.js` (rig/view + `createPlayer`) ·
+    `interact.js` (hold-E + `wireYardActions`) · `js/tests/d.test.js` · `dev_player.html` (my mock
+    harness — Lane A owns the real shell; I never touched main.js/index.html/selftest.html).
+    Selftest: **38 pass / 3 skip**, 20 of them Lane D. Verified in a real scene, not just asserts:
+    head bone **1.715 m** at fig scale 0.983, all 6 clips bound, walk/run at the tuned speeds, knockdown
+    lies the body down and drops the carried spare, get-up returns upright, hold-E radial fires once.
+    `checkContract('player', createPlayer(...))` → **CONFORMS**, and it clamps to `world.heightAt()`.
+    **Lane A: swap `createPlaceholderPlayer(scene, world, cameraRig)` → `await createPlayer(scene, world,
+    cameraRig, {wind, interact})` — same first three args, deliberately — add the importmap above, and
+    delete the placeholder.** It's async (two GLB fetches), so boot() must await it.
+
+[D] 2026-07-16 — ❗ **CONTRACT NEEDS FROM LANE B — not urgent, but §5-D.4 can't finish without them.**
+    PLAN3D §4's `sailRig` exposes corners/attach/step/coverageOver/events but nothing to ACT on a corner,
+    and repairs are Lane D's whole job. `interact.js:wireYardActions` already calls these, duck-typed, so
+    they no-op harmlessly until you land them — nothing breaks meanwhile:
+      · `sailRig.repair(i)` — re-rig corner i (I gate it on the player carrying a spare, 2.5 s hold, and
+        I consume the spare). Needed for the M2 "one mid-storm repair must be survivable" line in §7.
+      · `sailRig.trim(i, delta)` — per-corner turnbuckle, ±tension at ONE corner (1.2 s hold). This is
+        §5-D.4's "new vs prototype, makes corners individual".
+      · `corner.pos` (or `sailRig.cornerPos(i)`) → world Vector3 — I need somewhere to put the prompt.
+        Live-read each frame, so a flogging corner's prompt tracks it.
+    Shout if the shapes fight your sim and I'll adapt — you own sail.js, I'll move.
+
+[D] 2026-07-16 — 📌 **PLAN3D §5-D.1 is not buildable as written — the peds cannot go through Blender.**
+    §5-D.1 says merge clips onto a ped via the character_kit pipeline. That pipeline cannot accept a ped:
+    the ped GLBs encode metre scale as a **node scale of 0.01 on `mixamorig*:Hips`** with every child bone
+    in centimetres (Spine T=+10.05, LeftLeg T=+42.8). Blender bones have no rest scale, so the glTF
+    importer silently drops that 0.01 — straight after import the rig already reads Hips at 0.99 (metres)
+    while HeadTop_End reads 76.88 (centimetres) and LeftToe_End sits **96 m under the floor**. Exploded
+    before a single clip is merged. (It's also why `dancer.glb` is 30x small — its base, Hum_M_1.fbx, is
+    an FBX with no such trick, head bone 0.0563 m. And `merge_anims.py`'s own comment warns about exactly
+    this class of bug from the other end.) **What I did instead:** ship the ped byte-identical and carry
+    the clips beside it in an anim-only GLB (`player_anims.glb`, 677 kB, no mesh) — which is precisely the
+    shape 90sDJsim already ships as `peds/idle.glb` + `peds/walk.glb`, so it's the house pattern, not a
+    workaround. Retarget is at load: canonicalise the bone namespace, keep rotation tracks only.
+    Rebuild: `tools/character/build_player_anims.py` (header has the full why + the ssh one-liner).
+    Two gotchas worth knowing if you touch rigs:
+      · three.js **GLTFLoader strips `:` from node names** (reserved in property paths), so at runtime the
+        bones are `mixamorigHips`, never `mixamorig:Hips`. `_canon` still works — both sides sanitise
+        identically, which is *why* a mixamorig4 clip binds to a mixamorig12 ped.
+      · Blender 5.0 **removed `Action.fcurves`** (slotted actions — they're under
+        `layers[].strips[].channelbags[]`), so `character_kit/scripts/merge_anims.py` no longer runs there
+        as written. My script handles both layouts.
+
+[D] 2026-07-16 — M3 clips are **queued, not fetched**: `tools/character/mixamo_wishlist.txt` (Climbing
+    Ladder, Turning Key, Digging + repair/storm extras). `mixamo-fetch` needs a **manual Google login in a
+    real browser** — its README is explicit that Claude never sees the password — so this one wants John,
+    not a lane. Everything M0–M2 needs is already on disk and in `player_anims.glb`.
+
 [A] 2026-07-16 — ❓ **OPEN QUESTION, needs a human.** PLAN3D §0 says lanes run on "the M1 Ultra
     (`johnking@100.91.239.7`, Tailscale)", but this box is `m3ultra` and already has
     `~/Documents/shades-laneB/` and `shades-laneE/` checked out — so lanes are in fact running here, and
@@ -88,6 +174,172 @@ Format: `[lane letter] YYYY-MM-DD — note`
     other machine, this isn't a path fix, it's a decision about where lanes run. Flagging rather than
     guessing.
 
+[B] 2026-07-16 — **sail.js + rigging.js landed on `lane/b`, rebased on M0.** `checkContract('sailRig')`
+    conforms; `js/tests/b.test.js` runs 28 asserts green. 3D verlet cloth, N=10, structural/shear/bend,
+    5 iterations at a fixed 1/60 substep, wind per FACE. `step(dt, wind, t)` takes ragged frame dt and
+    does its own fixed-dt substepping — asserted that a 4-24 ms ragged loop converges on the fixed-dt
+    trace, so what selftest proves actually applies to the running game.
+
+[B] 2026-07-16 — **⚠️ UNITS CHANGED — Lane A (HUD) read this one.** `corner.load` and `hw.rating` are in
+    NEWTONS now, not the prototype's arbitrary scale. I retuned `HARDWARE` in contracts.js to real WLLs
+    (carabiner 1200 N, shackle 3200 N, rated 6500 N) under the standing note in that file that Lane B
+    owns these numbers — costs and tier shape untouched, and $80 still buys rated hardware on at most 2
+    of 4 corners (asserted). **HUD: show `load/1000` as kN.** A 5×5 m sail pulls ~1-4 kN per corner in a
+    34 m/s storm, which is exactly why real shade sails use 3 kN+ shackles. That's DESIGN.md's Kerbal
+    trick working — the number on the meter is one you could take to a hardware shop.
+
+[B] 2026-07-16 — thanks for the `sway(t)` clarification, it caught a real bug: I had it as an offset and
+    was adding it to `pos`, which would have flung every tree-anchored corner to double its coordinates.
+    Also consuming `world.sunDir` and `world.gardenBed` as specified (centre+size rect; a hit along
+    sunDir means shaded). One nit: `coverageOver()` starts its rays at y=0 rather than `heightAt(x,z)`.
+    On ±0.3 m terrain under a 3 m sail that's ~0.2 m of shadow error — not worth a contract change now,
+    flagging so it isn't a surprise later.
+
+[B] 2026-07-16 — **⚠️ FINDING FOR LANE A — the yard's anchors imply enormous sails.** Every 4-anchor quad
+    a player can pick from the 7 fixed anchors, by area: h1,h2,t1,p1 = 70 m² · h2,h3,t2,p2 = 71 m² ·
+    t1,t2,p1,p2 = 111 m² · h1,h3,t1,t2 = 133 m² · h2,t1,p1,p2 = 143 m² · h1,h3,p1,p2 = **192 m²**.
+    Real domestic shade sails are 20-50 m², and DESIGN.md itself pictures "a 30 m² kite". Wind load
+    scales with area, so at 192 m² nothing affordable on an $80 budget survives a real storm. The sim is
+    saying "you cannot span the whole yard", which is correct physics and arguably correct design — but
+    it means the natural, obvious pick (house corners out to both posts) is an instant loss. Options in
+    my order of preference: (1) more anchors, closer together, so a sensible 25-40 m² quad exists at all,
+    (2) posts moved in, (3) accept it and let the prep-phase load bars teach it. Not my call — flagging
+    with numbers rather than guessing. Nothing blocks on it; M1 is playable either way.
+
+[B] 2026-07-16 — **❓ OPEN — the flat-horizontal loophole. Needs Lane C, or the water spike.** DESIGN.md's
+    core tension is "big, flat, low = great shade, death in a storm". My sim disagrees, and it is right
+    to. Peak corner load over 8 wind directions, same footprint: flat *pitched* 3.06 kN, hypar 1.86 kN,
+    flat *horizontal* **1.14 kN** — the lowest of all three. A horizontal plate in horizontal wind
+    genuinely has almost no drag. What kills real flat sails is ponding (water weight), flutter and
+    leeward suction, none of which are in scope for me: ponding is DESIGN.md's second prototype spike,
+    and proper separated-flow aero is not happening in a hand-rolled cloth sim. So a player who plants
+    four posts at equal height currently gets the *safest* possible rig, which is the exact inverse of
+    the design's intent. Not fixable inside sail.js. Lane C: a vertical gust component would load a
+    horizontal sail and would partly close this.
+
+[B] 2026-07-16 — **the thesis assert is scored on WORST CASE over 8 wind directions, not per-direction.**
+    PLAN3D §5-B says "twisted peak < flat peak, same storm". Per-direction is a false assert and I won't
+    ship it: from the one angle where a flat sail sits edge-on it genuinely beats the hypar, and forcing
+    that green would mean tuning the sim into a lie. Worst-case is also the honest game question, since
+    Lane C's storms veer and the player never gets to pick the wind. Result: flat worst 3.06 kN (from S)
+    vs hypar worst 1.86 kN (from N) — the hypar sheds 39% off its worst moment. Thesis holds.
+
+[B] 2026-07-16 — two notes for whoever next reads sail.js, because both look "simplifiable" and aren't.
+    (1) Corner load is read from each constraint's **XPBD Lagrange multiplier** (|λ|/dt²), NOT from
+    `FABRIC_K × leftover stretch`. After a fixed 5 iterations the leftover stretch is *solver error*, not
+    fabric strain, so the obvious reading measures the solver — it came out ~50× hot, 60 kN peaks on a
+    5×5 sail. The `statics` assert is what keeps this honest: corner reactions must sum to the real
+    aerodynamic + weight force on the fabric (Newton's third law). It balances to 8.3%. If someone
+    "simplifies" the load reading, that assert is what goes red. (2) The **tension dial was remapped**
+    off the prototype's `rest = rest/tension`, which asks for 29% pre-strain at dial 1.4 and put 68 kN on
+    a corner before any wind blew. It is now a real pre-strain (0.10/dial → 4% at 1.4).
+
+[B] 2026-07-16 — **BUG worth knowing about, fixed:** a corner that blew was marked `broken` but never got
+    its mass back, so it stayed pinned — a "blown" corner sat welded in mid-air and the sail quietly went
+    dead instead of flogging. PLAN3D §5-B wants flogging emergent from the freed node, and it is now. The
+    cascade test missed it entirely because it forced the break by hand and called `_repin()` itself; the
+    replacement drives a real overload failure and asserts the corner tears free of its anchor and keeps
+    moving. Lesson for other lanes: a test that sets up state by hand can pass over a dead code path.
+
+[B] 2026-07-16 — **Lane D — your API is ready.** `sailRig.repairCorner(i, hw)` re-pins a blown corner
+    (your 2.5 s hold-E; returns false if it isn't broken). `sailRig.trimCorner(i, ±delta)` is the
+    per-corner turnbuckle (your 1.2 s hold; clamps 0.85-1.15, scales rest lengths near that corner only).
+    Both emit on `sailRig.events`. Spare count lives on `RiggingSession.spares` — gate `canUse()` on it
+    and decrement on use.
+
+[B] 2026-07-16 — **Lane A — wiring the rendered sail.** `const view = await createSailView(rig);
+    scene.add(view);` then `view.update()` each frame after `rig.step()`. Returns a THREE.Group,
+    double-sided, `castShadow` on — the shadow IS the product. three is imported lazily inside it so the
+    sim core stays headless-runnable. Verified headless (100 verts / 162 tris, normals recomputed, verts
+    track the sim) but **not yet eyeballed in a browser** — it wants a look once it's in main.js. The
+    prep-phase picking UI is NOT landed: it needs your camera and anchor markers to raycast against. All
+    the rules behind it are done and tested in `RiggingSession` (rigging.js), so it's a thin
+    click-to-session adapter once M0's camera is available to me.
+
+[B] 2026-07-16 — selftest convention, slightly off your stub and I think worth keeping: my asserts live
+    next to the code in `js/sail.selftest.js` and `js/rigging.selftest.js` as exported `[name, fn]`
+    arrays, and `js/tests/b.test.js` is a 3-line adapter that feeds them to your Suite. The reason is
+    that those modules ALSO run under plain `node web/world/js/sail.selftest.js` — no browser, no server,
+    ~7 s — which is how the cloth got proven before M0 existed. Same array both ways, so the two
+    harnesses cannot drift. `contracts.js` importing three is no obstacle to that: node imports
+    `three.module.js` fine.
+[E] 2026-07-16 — ✅ **A's §2 correction independently confirmed** — I hit the same wall from the asset side
+    before M0 landed: `3D-STORE` is at `~/Documents/Destroyulater/3D-STORE/`, and `character_kit` / `FBX` /
+    `3D=models` / `mixamo-fetch` exist nowhere on this box. My inputs were relocated, not missing, so §5-E
+    is unblocked and done — Lane D's §5-D genuinely isn't. Two lanes hitting this independently is probably
+    the answer to A's open question.
+
+[E] 2026-07-16 — **§5-E LANDED: 16 GLBs + grass atlas, all from one script.**
+    `blender -b -P tools/blender/build_yard_assets.py` (flags: `--only <name>` / `--no-verify` /
+    `--no-debris`). Proven rather than asserted: 17/17 outputs are byte-identical across two runs; every
+    GLB is re-imported from disk and checked for dims-in-range, tri budget and node-name survival;
+    `contact_sheet.png` renders each beside the 1.7 m ref capsule. Heaviest is garden_bed at 2,580 tris —
+    everything far under the 15 k budget. Machine-readable manifest: `tools/blender/asset_report.json`.
+
+[E] 2026-07-16 — **NODE CONTRACTS — the names your code queries.** Every empty survives the export;
+    verified in three.js, not just Blender.
+      · trees: `trunk` (trunk+branches, rigid) + `canopy_01..03` as SEPARATE nodes — Lane A, sway the
+        canopies only. `branch_anchor_01..03` empties carry `anchor_type="tree"` + `rating_hint` (thicker
+        limb = higher) for `world.anchors`.
+      · `house_yardside`: `fascia_anchor_01..03` carry `rating_hint=0.35` + `collateral="gutter"`, and the
+        `gutter` node carries `collateral_of="fascia"` — DESIGN.md's "the fascia board is a lie" wired as
+        data, so ripping it takes the gutter with it. Facade only, 9.20 × 1.05 × 2.90 m, no interior.
+      · `sail_post`: exported VERTICAL, `rake_pivot` at the footing, `top_anchor` at the head. Rake is a
+        player decision (DESIGN.md: rake away from the load), so it's a runtime rotation, never baked.
+        **Lane A — this is exactly your 8° rake:** rotate about `rake_pivot` and the footing stays put.
+      · hardware: `shackle`/`carabiner`/`turnbuckle` each keep their failure part as its own node — `pin`
+        (unscrews then shears), `gate` (flutters open), `body` (thread strips) — with `failure_mode`
+        stamped as a custom prop, so a break anim moves just that piece.
+      · `shed_table` → `pickup_anchor` · `ladder_01` → `ladder_base`/`ladder_top` · `gate` → `hinge_axis`.
+
+[E] 2026-07-16 — `garden_bed` ships all 3 damage states in ONE glb as sibling nodes `plants_full` /
+    `plants_tattered` / `plants_dead` (full visible, rest `hide_render`). Lane A: toggle `.visible`, don't
+    reload — instant swap, no pop-in. Tuft positions are identical across states, so the bed wilts instead
+    of rearranging itself.
+
+[E] 2026-07-16 — debris in `web/world/models/debris/`, copied verbatim (§0 copies rule) and scale-checked:
+    BlueCrate_v2 0.36×0.36×0.29 · BlackTub_v2 + WhiteTub_v2 0.36×0.54×0.20 · WoodenBin_v2 0.35×0.36×0.31 m
+    — all plausible real-world sizes. Plus `tramp_01_v1.glb` (2.96×2.96×0.78, `mass_hint` 45), because every
+    Australian storm produces exactly one airborne trampoline. **Lane C: glob the dir, don't hardcode
+    names** — §0's `*_v1.glb` rule beats §5-E's "tramp_01.glb" spelling. Grass is a texture, not geometry
+    (§5-E item 9): `models/textures/grass_atlas.png`, 512², 2×2 tufts, alpha — instance billboards off it.
+
+[E] 2026-07-16 — ⚠️ **LANE A + LANE C, BOUNDING BOXES.** `THREE.Box3.setFromObject(obj)` expands each mesh's
+    LOCAL box by the world matrix, so a node carrying a rotation reports an inflated box — and that box is
+    what three frustum-culls against. Blender's `obj.bound_box` has the identical trap; it cost me an hour
+    chasing phantom failures. Fixed at source: `join_group()` now bakes rotation into the vertices so every
+    local box is axis-aligned and tight. Before the fix, three reported `tramp_01` as 3.29 × 1.27 m against
+    a true 2.96 × 0.78. Default `Box3` is safe on these assets now — but if you ever measure geometry
+    yourself, measure VERTICES, not `bound_box` corners.
+
+[E] 2026-07-16 — filled in `js/tests/e.test.js` (thanks for the pre-created stub — that was a good call)
+    and landed `tools/assetcheck/` as a standalone version. Loads every GLB through the vendored
+    GLTFLoader and asserts Y-up, scale sanity and node survival. It exists because the Blender round-trip
+    **cannot** catch an axis bug: it exports Z-up→Y-up and imports Y-up→Z-up, so a broken `export_yup`
+    flips back and passes green. Only a native glTF reader can prove it. Green: 16/16, with
+    `branch_anchor_01` at (-0.96, 3.64, -1.46) — height correctly on +Y.
+
+[E] 2026-07-16 — ⚠️ **LANE A — three lines needed in selftest.html + index.html. Blocks Lane D too.**
+    No page in the repo has an `<script type="importmap">`, and M0 didn't need one: it imports three by
+    relative path (`../vendor/three.module.js`). But EVERY three.js addon imports the **bare specifier
+    `three`**, so the first lane to touch `GLTFLoader` or `SkeletonUtils` gets
+    `Failed to resolve module specifier "three"`. That's me now — and it's **Lane D the moment they load
+    `player_01.glb`**, which is the whole of §5-D. The fix, in `<head>`:
+        <script type="importmap">
+        { "imports": { "three": "./vendor/three.module.js",
+          "three/addons/": "./vendor/addons/" } }
+        </script>
+    I did **not** edit your file (§6 says post the need instead, and you'd asked for selftest.html to stay
+    out of the merge path). `e.test.js` imports GLTFLoader dynamically and `skip`s with that message, so
+    your gate stays green rather than going red over a harness gap — and the suite lights up on its own
+    the moment the importmap lands, no edit from me. Verified behind a temporary local probe first:
+    **36/36 pass** (16 GLBs × scale + node survival, plus anchor world-position and the 3 damage states).
+    Until then the same asserts run in `tools/assetcheck/`, which carries its own importmap.
+
+[E] 2026-07-16 — ❓ open q for Lane A: your yard puts house fascia anchors at y=2.6, but `house_yardside`'s
+    fascia sits at 2.80 (2.90 m ridge), and the facade is 9.20 m against a 30 m north edge. Want me to
+    re-cut it to your numbers, or will you read `fascia_anchor_*` off the GLB when you swap the graybox?
+    Either way it's one constant for me — the script regenerates everything.
 [C] 2026-07-16 — ⚠️ **THE WORKTREE COLLISION WAS ME, NOT LANE D — please don't redirect D on my
     account.** Before I'd realised Lane A was live in the shared checkout, I ran `git checkout -b lane/c`
     inside `~/Documents/shades/`, and a few minutes later `git checkout main` + `git branch -D lane/c` to
@@ -179,3 +431,77 @@ Format: `[lane letter] YYYY-MM-DD — note`
         `(cos d, sin d)` and contracts puts north at -Z, so a southerly needs `sin(d) < 0`. Worth a second
         look at anything that reasons about wind direction.
     All three were caught by an assert or the bench rather than by reading, which is the argument for both.
+
+[I] 2026-07-16 — **INTEGRATION PASS (main).** All four lane branches merged to main (b → e → c → d;
+    THREADS conflicts resolved keep-both). Added the importmap D+E asked for to index.html AND
+    selftest.html (relative form: `./vendor/…` — D's `/world/…` spelling 404s on the repo-root server).
+    Same absolute-path bug fixed in dev_player.html and player.js GLB URLs (`/world/models/…` →
+    `./models/…`) — the ped never loaded under `server.py`; it does now, verified in dev_player.html.
+    Selftest on merged main: **121 pass / 0 skip / 0 fail** (E's suite lit up as promised).
+    launch.json now runs `--port 8809` (8801 was held by another session). Next work: SPRINT2.md.
+
+[I] 2026-07-16 — **M3 CLIP PACK LANDED — the mixamo wishlist is fetched and baked.** John supplied a
+    logged-in Mixamo session; 11 clips downloaded Without Skin @30fps (subs where Mixamo has no such
+    clip: Turning Key→Pulling Lever, Standing Up Ready→Standing Up, Covering Head→Taking Cover; bonus
+    find: Dig And Plant Seeds. Hammering/Sweeping/Bracing don't exist — skipped). FBXs now canonical in
+    the M1's ~/Documents/FBX/; CLIPS extended in build_player_anims.py (names: ClimbLadder, Crank, Dig,
+    PickUp, Carry, CarryTurn, CarryIdle, StandUp, TakeCover, StumbleBack, PlantSeeds); rebuilt on the M1
+    (Blender 5.0.1, 17 NLA tracks, 2.3 MB) and committed. Verified: GLTFLoader reads all 17 clips with
+    contract names; selftest still 121/0/0. Lane D: your M3 verbs are on disk — wire when ready.
+
+[A] 2026-07-16 — 🚩 **GATE 1 — the yard is live. LANE D: START.** SPRINT2 §Lane A steps 1–4 are on main.
+    The placeholder capsule and stub wind are gone. `python3 server.py` → real weather, your ped walking
+    in it, a rendered sail overhead with its shadow on the garden bed, rain, debris, storm audio.
+    Selftest **121/0/0** after the assembly — nobody's suite moved. 0.63 ms/frame in mid-storm_02
+    (0.17 sim + 0.45 render) against a 16.67 ms budget, 120 k tris / 74 draw calls, so there is a LOT of
+    headroom to spend. Note my clone runs `--port 8811` (8801 and 8809 are held by other sessions).
+
+[A] 2026-07-16 — **It works. storm_02, hand-driven end to end, default rig (rated/shackle/shackle/carabiner
+    on h1/h3/p2/p1):** the carabiner blows at **t=45.4 s**, then p2's shackle cascades at **t=56 s — one
+    second after the southerly change at 55**. That is Lane C's design landing exactly as they described
+    it: the corners that were slack all storm are the loaded ones after the change. Coverage over the bed
+    is **1.0 with the rig intact and 0.0 once two corners are gone** — the whole game in one number.
+    Peak corner load 5427 N; cloth never went non-finite. Nothing here is asserted-only; I drove it.
+
+[A] 2026-07-16 — ❗ **LANE B — two things about wiring your sail, one is a real trap.**
+      · `createSailView(rig)` reads `rig.pos`/`rig.tris`, which don't exist until `attach()` allocates
+        them in `_build()`. Build the view before rigging and it throws on an undefined array — cost me
+        my first boot. Not asking you to change it; just documenting the order.
+      · **Call `SHADES.rigSail(anchorIds, hwChoices, tension)`, NOT `rig.attach()` directly**, from your
+        picking adapter. `attach()` replaces the corners array and can change the grid, so the view must
+        be rebuilt and interact re-wired (its targets close over corner objects, and stale closures point
+        at corners the sim no longer steps). `rigSail()` does attach + view rebuild + re-wire behind one
+        door, and it's `async`. Ids are stable so re-wiring replaces rather than stacking duplicates.
+      · Your view is now **eyeballed in a browser**, as you asked: it bellies, catches light, and its
+        shadow lands on the bed. Screenshot going in DESIGN.md with the assembled-yard sheet.
+      · FYI the default rig I boot with is the prototype's AUTO loadout and spans most of the yard — it's
+        your 70–192 m² finding, visible from orbit. Decision 2 (my step 6) shrinks it; not a cloth fault.
+
+[A] 2026-07-16 — ❗ **LANE D — `knockdown(t, dirX, dirZ)` takes the sim clock first, not the impact.**
+    Lane C's `onHitPlayer(piece, impact)` hands you an impact magnitude, and the obvious wiring —
+    `knockdown(impact)` — jams ~40 into the state machine's start time and you never get up. I wired it
+    `knockdown(windT, piece.vx, piece.vz)`, so you also fall the way the crate was travelling. Flagging
+    in case anything else calls it. Also: `player.pos` is a plain `{x,y,z}`, not a `Vector3` — contracts.js
+    says Vector3. Everything only reads `.x/.y/.z` so it duck-types fine everywhere (camera, wind, HUD)
+    and I'm NOT asking you to change it; I'll relax the contract's wording instead. Your ped, all six
+    clips, walk/run and the yard clamp are confirmed working in the real yard.
+
+[A] 2026-07-16 — ✅ **LANE C — your §Lane C.5 ask, answered with evidence: `dispose()` restores the lights
+    exactly.** Tested inside the real main.js scene, not a bench. After a 40 s storm_02 dragged sun to
+    1.067 and hemi to 1.132, a bare `sky.dispose()` with no rebuild put them back at **exactly 2.0 and
+    1.8**. I also ran three full forecast→storm→forecast cycles to see if anything compounds: sun settles
+    at 1.939 → 1.941 → 1.951, i.e. converging on storm_01's calm-day target, not decaying. No leak, no
+    flicker. Two notes: (1) I **rebuild** skyfx on every phase change rather than re-pointing it, because
+    it reads `wind.def.sky` at construction and storm_01/storm_02 have different darkness — dispose() is
+    therefore on your hot path, and it holds up. (2) `dispose()` restores sun/hemi but leaves `scene.fog`
+    where the storm left it; invisible in practice because the next skyfx immediately re-drives fog, and
+    it only bites if something disposes without replacing. Your call whether that's worth a line.
+    Wind shelters are wired (`setSheltersFromTrees` on both storms — shelters describe trees, which don't
+    stop existing when the weather turns), `unlockAudio()` fires on first pointer/key, debris bounces off
+    `world.heightAt`, and all four of Lane E's crate/tub GLBs load into `setModels`.
+
+[A] 2026-07-16 — 🔧 `SHADES.step(dt)` and `SHADES.render()` are exposed on the debug api. rAF is throttled
+    to a standstill in a hidden/background tab, so they are the only honest way to fast-forward or capture
+    a storm from a headless browser — which is what this sprint's "90 s storm_02 run captured" acceptance
+    needs. Same code path the rAF loop uses; no test-only branch that can drift. Everything I reported
+    above was measured through them.

tools/assetcheck/README.md

@@ -0,0 +1,50 @@
+# assets_in_three.html — verify the GLBs in the real consumer
+
+`build_yard_assets.py` already re-imports every GLB into Blender and asserts
+dims, tri budget, and node names. That is necessary but **structurally cannot
+catch an axis error**: Blender exports Z-up→Y-up and imports Y-up→Z-up, so a
+broken `export_yup` flips back on the way in and round-trips green. Only
+something that reads glTF natively can prove the file is right.
+
+This page is that check. It loads each GLB with three.js r175's `GLTFLoader` and
+asserts:
+
+- **Y-up**: a Blender asset measuring `(dx, dy, dz)` must arrive as `(dx, dz, dy)`.
+- **node survival**: `branch_anchor_*`, `fascia_anchor_*`, `plants_*` etc. still
+  exist after the export — glTF has no "empty", anchors arrive as bare
+  `Object3D`, and exporters have been known to prune childless nodes.
+- **anchors are usable**: `branch_anchor_01` resolves to a sane world position
+  with height on +Y.
+
+Expectations are read from `tools/blender/asset_report.json`, so this stays in
+sync with the factory automatically.
+
+## Why it uses the default (non-precise) Box3
+
+`THREE.Box3.setFromObject(obj)` expands each mesh's **local** bounding box by the
+world matrix, so a node carrying a rotation reports an inflated box. That is the
+same trap Blender's `obj.bound_box` sets, and it is what three uses for frustum
+culling. `join_group()` therefore bakes rotation into the vertices so the local
+box is axis-aligned and tight. Passing `precise: true` here would hide exactly
+the regression this page exists to catch — so don't.
+
+Before that fix, three reported `tramp_01` as 3.29 × 1.27 m against a true
+2.96 × 0.78 m.
+
+## Running it
+
+Needs three.js on `/world/vendor/` and the models on `/models/`. Once Lane A's
+`server.py` lands, serve `web/` and this can move next to `selftest.html`
+(Lane A: happy to fold it in — see THREADS).
+
+Until then, the standalone recipe:
+
+```sh
+D=$(mktemp -d) && mkdir -p "$D/world"
+ln -s ~/Documents/90sDJsim/web/world/vendor        "$D/world/vendor"
+ln -s "$PWD/web/world/models"                      "$D/models"
+ln -s "$PWD/tools/blender/asset_report.json"       "$D/asset_report.json"
+cp tools/assetcheck/assets_in_three.html           "$D/index.html"
+python3 -m http.server 8805 --directory "$D"
+# open http://127.0.0.1:8805 — look for "SUMMARY: ALL PASS IN THREE.JS"
+```

tools/assetcheck/assets_in_three.html

@@ -0,0 +1,82 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Lane E — GLB check in the real consumer (three.js r175)</title>
+<style>
+  body { background:#14161a; color:#dfe3e8; font:13px/1.5 ui-monospace,Menlo,monospace; padding:16px; }
+  .pass { color:#7fd67f; } .fail { color:#ff6b6b; } h1 { font-size:15px; color:#9fb4c7; }
+</style>
+<h1>GLB verification — loaded by three.js GLTFLoader, not Blender</h1>
+<pre id="out">loading…</pre>
+
+<script type="importmap">
+{ "imports": { "three": "/world/vendor/three.module.js",
+  "three/addons/": "/world/vendor/addons/" } }
+</script>
+<script type="module">
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+
+const out = document.getElementById('out');
+const log = [];
+const say = (s, cls) => {
+  log.push(s);
+  out.innerHTML += `<span class="${cls || ''}">${s}</span>\n`;
+  console.log(s);
+};
+
+const report = await (await fetch('/asset_report.json')).json();
+const loader = new GLTFLoader();
+let fails = 0;
+
+say(`three.js r${THREE.REVISION}  |  ${report.assets.length} assets\n`);
+
+for (const a of report.assets) {
+  let gltf = null;
+  for (const dir of ['/models/', '/models/debris/']) {
+    try { gltf = await loader.loadAsync(`${dir}${a.name}_v1.glb`); break; } catch (e) {}
+  }
+  if (!gltf) { say(`[FAIL] ${a.name.padEnd(16)} could not load`, 'fail'); fails++; continue; }
+
+  const size = new THREE.Vector3();
+  new THREE.Box3().setFromObject(gltf.scene).getSize(size);
+
+  // The whole point of this page. Blender is Z-up, glTF is Y-up, so a Blender
+  // asset measuring (dx, dy, dz) MUST arrive here as (dx, dz, dy). A Blender
+  // re-import can never catch a broken export_yup — it just flips it back.
+  const [bx, by, bz] = a.dims;
+  const exp = [bx, bz, by];
+  const got = [size.x, size.y, size.z];
+  const axisOk = got.every((v, i) => Math.abs(v - exp[i]) < 0.02);
+
+  const names = [];
+  gltf.scene.traverse(o => names.push(o.name));
+  const missing = a.nodes.filter(n => !names.includes(n));
+
+  const ok = axisOk && missing.length === 0;
+  if (!ok) fails++;
+  say(`[${ok ? 'PASS' : 'FAIL'}] ${a.name.padEnd(16)} ` +
+      `${got.map(v => v.toFixed(2)).join(' x ')} m (Y-up)`, ok ? 'pass' : 'fail');
+  if (!axisOk) say(`        axis/scale: expected ${exp.map(v => v.toFixed(2)).join(' x ')}`, 'fail');
+  if (missing.length) say(`        nodes lost in three.js: ${missing.join(', ')}`, 'fail');
+}
+
+// Empties are the risky part: glTF has no "empty", they arrive as bare Object3D
+// nodes, and exporters have been known to prune childless ones. Anchors ARE the
+// contract, so prove one survives with a usable world position.
+const t = await loader.loadAsync('/models/tree_gum_01_v1.glb');
+const anchor = t.scene.getObjectByName('branch_anchor_01');
+if (anchor) {
+  t.scene.updateWorldMatrix(true, true);
+  const p = new THREE.Vector3().setFromMatrixPosition(anchor.matrixWorld);
+  const upright = p.y > 1.0 && p.y < 6.0;
+  if (!upright) fails++;
+  say(`\n[${upright ? 'PASS' : 'FAIL'}] branch_anchor_01 world pos ` +
+      `(${p.x.toFixed(2)}, ${p.y.toFixed(2)}, ${p.z.toFixed(2)}) — ` +
+      `${upright ? 'height is on +Y, anchors are usable' : 'height is NOT on +Y!'}`,
+      upright ? 'pass' : 'fail');
+} else { fails++; say('\n[FAIL] branch_anchor_01 missing entirely', 'fail'); }
+
+say(`\nSUMMARY: ${fails === 0 ? 'ALL PASS IN THREE.JS' : fails + ' FAILURES'}`,
+    fails === 0 ? 'pass' : 'fail');
+window.__done = true; window.__fails = fails;
+</script>

tools/blender/asset_report.json

@@ -0,0 +1,328 @@
+{
+  "blender": "5.1.2",
+  "assets": [
+    {
+      "name": "ref_capsule",
+      "dims": [
+        0.4,
+        0.4,
+        1.7
+      ],
+      "tris": 220,
+      "nodes": [
+        "head_height",
+        "ref_capsule",
+        "ref_capsule_mesh"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "tree_gum_01",
+      "dims": [
+        4.5522,
+        4.956,
+        7.9702
+      ],
+      "tris": 396,
+      "nodes": [
+        "branch_anchor_01",
+        "branch_anchor_02",
+        "branch_anchor_03",
+        "canopy_01",
+        "canopy_02",
+        "canopy_03",
+        "tree_gum_01",
+        "trunk"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "tree_gum_02",
+      "dims": [
+        3.8871,
+        2.7787,
+        5.4972
+      ],
+      "tris": 288,
+      "nodes": [
+        "branch_anchor_01",
+        "branch_anchor_02",
+        "canopy_01",
+        "canopy_02",
+        "tree_gum_02",
+        "trunk"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "fence_post",
+      "dims": [
+        0.13,
+        0.13,
+        2.03
+      ],
+      "tris": 24,
+      "nodes": [
+        "fence_post",
+        "post"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "fence_panel",
+      "dims": [
+        2.4,
+        0.054,
+        1.8194
+      ],
+      "tris": 324,
+      "nodes": [
+        "fence_panel",
+        "palings",
+        "rails"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "gate",
+      "dims": [
+        1.045,
+        0.0615,
+        1.75
+      ],
+      "tris": 220,
+      "nodes": [
+        "gate",
+        "gate_frame",
+        "gate_palings",
+        "hinge_axis",
+        "hinges"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "house_yardside",
+      "dims": [
+        9.2,
+        1.0547,
+        2.9
+      ],
+      "tris": 200,
+      "nodes": [
+        "door",
+        "fascia",
+        "fascia_anchor_01",
+        "fascia_anchor_02",
+        "fascia_anchor_03",
+        "gutter",
+        "house_yardside",
+        "roof",
+        "wall",
+        "window"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "shed_01",
+      "dims": [
+        2.58,
+        1.9708,
+        2.2224
+      ],
+      "tris": 96,
+      "nodes": [
+        "door_anchor",
+        "doors",
+        "roof",
+        "shed_01",
+        "shell"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "shed_table",
+      "dims": [
+        1.6,
+        0.6,
+        0.9
+      ],
+      "tris": 72,
+      "nodes": [
+        "pickup_anchor",
+        "shed_table",
+        "table_frame",
+        "table_top"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "garden_bed",
+      "dims": [
+        3.0,
+        1.2,
+        0.8609
+      ],
+      "tris": 2580,
+      "nodes": [
+        "bed",
+        "garden_bed",
+        "plants_dead",
+        "plants_full",
+        "plants_tattered",
+        "soil"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "sail_post",
+      "dims": [
+        0.507,
+        0.52,
+        4.0327
+      ],
+      "tris": 528,
+      "nodes": [
+        "footing",
+        "pad_eye",
+        "post",
+        "rake_pivot",
+        "sail_post",
+        "top_anchor"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "ladder_01",
+      "dims": [
+        0.455,
+        0.075,
+        3.0
+      ],
+      "tris": 276,
+      "nodes": [
+        "ladder",
+        "ladder_01",
+        "ladder_base",
+        "ladder_top"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "shackle",
+      "dims": [
+        0.0569,
+        0.019,
+        0.0744
+      ],
+      "tris": 560,
+      "nodes": [
+        "bow",
+        "pin",
+        "shackle"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "carabiner",
+      "dims": [
+        0.049,
+        0.009,
+        0.1027
+      ],
+      "tris": 476,
+      "nodes": [
+        "body",
+        "carabiner",
+        "gate"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "turnbuckle",
+      "dims": [
+        0.0292,
+        0.0341,
+        0.1955
+      ],
+      "tris": 728,
+      "nodes": [
+        "body",
+        "eye_a",
+        "eye_b",
+        "turnbuckle"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
+    {
+      "name": "tramp_01",
+      "dims": [
+        2.9555,
+        2.9555,
+        0.78
+      ],
+      "tris": 976,
+      "nodes": [
+        "legs",
+        "mat",
+        "pad",
+        "rim",
+        "tramp_01"
+      ],
+      "status": "PASS",
+      "problems": []
+    }
+  ],
+  "debris": [
+    {
+      "file": "BlueCrate_v2.glb",
+      "dims": [
+        0.36,
+        0.36,
+        0.29
+      ],
+      "sane": true
+    },
+    {
+      "file": "BlackTub_v2.glb",
+      "dims": [
+        0.36,
+        0.54,
+        0.2
+      ],
+      "sane": true
+    },
+    {
+      "file": "WhiteTub_v2.glb",
+      "dims": [
+        0.36,
+        0.54,
+        0.2
+      ],
+      "sane": true
+    },
+    {
+      "file": "WoodenBin_v2.glb",
+      "dims": [
+        0.35,
+        0.36,
+        0.31
+      ],
+      "sane": true
+    }
+  ]
+}

tools/character/build_player_anims.py

@@ -46,6 +46,21 @@ CLIPS = [
     ("Falling",       f"{FBX}/Falling.fbx"),      # limb flail; player.js pitches the root itself
     ("CrouchToStand", f"{FBX}/Crouch To Stand.fbx"),
     ("Reaction",      f"{FBX}/Reaction.fbx"),     # stagger on a debris glance
+    # --- M3 verbs, fetched from Mixamo 2026-07-16 (see tools/character/mixamo_wishlist.txt).
+    # Substitutions where Mixamo has no such clip: Turning Key → Pulling Lever,
+    # Standing Up Ready → Standing Up, Covering Head → Taking Cover.
+    # Hammering / Sweeping Floor / Bracing don't exist on Mixamo — skipped.
+    ("ClimbLadder",   f"{FBX}/Climbing Ladder.fbx"),
+    ("Crank",         f"{FBX}/Pulling Lever.fbx"),      # turnbuckle work
+    ("Dig",           f"{FBX}/Digging.fbx"),
+    ("PickUp",        f"{FBX}/Picking Up Object.fbx"),
+    ("Carry",         f"{FBX}/Carrying.fbx"),
+    ("CarryTurn",     f"{FBX}/Carrying Turn.fbx"),
+    ("CarryIdle",     f"{FBX}/Box Idle.fbx"),
+    ("StandUp",       f"{FBX}/Standing Up.fbx"),
+    ("TakeCover",     f"{FBX}/Taking Cover.fbx"),       # hail/debris shelter
+    ("StumbleBack",   f"{FBX}/Stumble Backwards.fbx"),
+    ("PlantSeeds",    f"{FBX}/Dig And Plant Seeds.fbx"),# garden repair verb
 ]
 
 PREFIX_RE = re.compile(r"mixamorig\d*:")

tools/character/mixamo_wishlist.txt

@@ -0,0 +1,43 @@
+# SHADES animation wishlist — Mixamo search terms, one per line.  (Lane D, for M3)
+#
+# Same pipeline as 90sDJsim's dj_wishlist.txt and the op-shop clerk's wishlist.txt:
+#   cd ~/Documents/mixamo-fetch
+#   node fetch.cjs login                  # a real browser opens; John logs in by hand, once
+#   cp <this file> ./shades_wishlist.txt
+#   node fetch.cjs anims                  # loops the wishlist, downloads each "Without Skin"
+# then add the new FBX to CLIPS in tools/character/build_player_anims.py and rebuild the pack.
+#
+# NOTE: fetch.cjs needs a MANUAL Google login in a real browser window (its README is explicit that
+# Claude never sees the password), so this list is queued for John to run — not something a lane
+# fetches on its own. Everything M0-M2 needs is already on disk and already in player_anims.glb:
+# Idle / Walk / Run / Falling / CrouchToStand / Reaction.
+#
+# '#' and blank lines ignored. Names are fuzzy search terms (top hit wins); a miss is skipped.
+# In-place clips only — the game translates the player itself, and player.js keeps rotation tracks
+# only, so anything with big root travel is wasted.
+
+## --- M3: the repair verbs (PLAN3D §5-D.1) ---
+Climbing Ladder
+Turning Key
+Digging
+
+## --- M3: worth having while the browser is open (DESIGN.md "limited hands" toolset) ---
+Hammering
+Sweeping Floor
+Picking Up Object
+Carrying Box
+Standing Up Ready
+
+## --- storm reactions (better than reusing Reaction for everything) ---
+Covering Head
+Bracing
+Stumble Backwards
+
+## --- FETCH LOG 2026-07-16 (fetched via browser session on m3ultra, John's Mixamo login) ---
+# Landed in ~/Documents/FBX/ on the M1 and baked into player_anims.glb (17 clips total):
+#   Climbing Ladder ✓ · Pulling Lever ✓ (sub for Turning Key — no such clip on Mixamo)
+#   Digging ✓ · Dig And Plant Seeds ✓ (bonus, garden verb) · Picking Up Object ✓
+#   Carrying ✓ + Carrying Turn ✓ + Box Idle ✓ (the Carrying Box family)
+#   Standing Up ✓ (sub for Standing Up Ready) · Taking Cover ✓ (sub for Covering Head)
+#   Stumble Backwards ✓
+# Genuinely absent from Mixamo, skipped: Hammering · Sweeping Floor · Bracing

web/world/data/storms/storm_01_gentle.json

@@ -13,7 +13,8 @@
     "maxGap": 14,
     "powBase": 2,
     "powRand": 3,
-    "powRamp": 2
+    "powRamp": 2,
+    "downdraft": 0.18
   },
 
   "dirCurve": [[0, 0.9], [45, 1.0], [90, 1.15]],

web/world/data/storms/storm_02_wildnight.json

@@ -11,13 +11,16 @@
 
   "baseCurve": [[0, 7.0], [15, 11.0], [40, 17.0], [60, 20.0], [78, 19.0], [90, 16.0]],
 
+  "_gusts_comment": "downdraft = fraction of gust power that blows DOWN, per gust (each gust varies 0.6-1.4x this). A gust front is descending air, not just faster air; without it a flat horizontal sail sheds everything and ignoring the storm is the winning move. 0.3 here because a wild night should punish a flat rig hard.",
+
   "gusts": {
     "firstAt": 3,
     "minGap": 5.5,
     "maxGap": 11,
     "powBase": 3,
     "powRand": 5,
-    "powRamp": 7
+    "powRamp": 7,
+    "downdraft": 0.3
   },
 
   "dirCurve": [[0, 0.85], [50, 0.95], [55, 0.6], [59, -1.25], [70, -1.45], [90, -1.35]],

web/world/dev_player.html

@@ -0,0 +1,203 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>SHADES — Lane D player harness</title>
+<style>
+  html, body { margin: 0; height: 100%; background: #6f7f8c; overflow: hidden; font: 12px/1.5 ui-monospace, Menlo, monospace; }
+  canvas { display: block; }
+  #hud { position: fixed; top: 8px; left: 8px; color: #fff; text-shadow: 0 1px 2px #000; white-space: pre; pointer-events: none; }
+  #panel { position: fixed; top: 8px; right: 8px; color: #fff; text-shadow: 0 1px 2px #000; text-align: right; }
+  #panel button { font: inherit; margin: 1px; }
+  #panel input { vertical-align: middle; }
+  #prompt { position: fixed; left: 50%; bottom: 64px; transform: translateX(-50%); color: #fff;
+            text-shadow: 0 1px 3px #000; font-size: 15px; text-align: center; pointer-events: none; }
+  #bar { width: 160px; height: 5px; background: #0006; margin: 5px auto 0; border-radius: 3px; overflow: hidden; }
+  #fill { height: 100%; width: 0; background: #ffd54a; }
+</style>
+<!--
+  REQUIRED, don't delete: every vendored addon (GLTFLoader, SkeletonUtils, …) imports from the bare
+  specifier 'three', so any page that pulls in player.js needs this map. index.html has no importmap
+  yet because nothing there uses an addon — flagged for Lane A in THREADS.md, since the placeholder
+  swap will need it too.
+-->
+<script type="importmap">
+{ "imports": { "three": "./vendor/three.module.js", "three/addons/": "./vendor/addons/" } }
+</script>
+</head>
+<body>
+<canvas id="c"></canvas>
+<div id="hud"></div>
+<div id="panel">
+  wind <input id="wind" type="range" min="0" max="40" step="0.5" value="4"> <span id="wv">4</span> m/s<br>
+  dir <input id="dir" type="range" min="0" max="6.28" step="0.01" value="0"><br>
+  <button id="gust">gust (+18, 1.6s)</button>
+  <button id="knock">knockdown</button>
+  <button id="stag">stagger</button>
+</div>
+<div id="prompt"></div>
+
+<!--
+  Lane D dev harness. NOT the game — Lane A owns index.html, world.js, camera.js, hud.js.
+  Everything here that isn't player.js / interact.js is a throwaway mock standing in until M0 lands:
+  the ground, the wind, the camera and the prompt UI. PLAN3D §0 says lanes develop against contracts
+  + mocks until Lane A's skeleton merges; this is that mock.
+-->
+<script type="module">
+import * as THREE from 'three';
+import { loadPlayer, KeyboardInput, STATES } from './js/player.js';
+import { Interact, wireYardActions } from './js/interact.js';
+
+const renderer = new THREE.WebGLRenderer({ canvas: document.getElementById('c'), antialias: true });
+renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+renderer.shadowMap.enabled = true;
+renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+
+const scene = new THREE.Scene();
+scene.background = new THREE.Color(0x8fa6b6);
+scene.fog = new THREE.Fog(0x8fa6b6, 30, 90);
+
+const cam = new THREE.PerspectiveCamera(55, 1, 0.1, 300);
+const resize = () => {
+  renderer.setSize(innerWidth, innerHeight);
+  cam.aspect = innerWidth / innerHeight; cam.updateProjectionMatrix();
+};
+addEventListener('resize', resize); resize();
+
+const sun = new THREE.DirectionalLight(0xfff3e0, 2.4);
+sun.position.set(-8, 14, 6); sun.castShadow = true;
+sun.shadow.mapSize.set(2048, 2048);
+Object.assign(sun.shadow.camera, { left: -18, right: 18, top: 18, bottom: -18, near: 1, far: 50 });
+scene.add(sun, new THREE.HemisphereLight(0xbfd8e8, 0x4a5a3a, 1.1));
+
+// --- mock yard: 30x20 m, flat. Lane A's world.js replaces this (and gives real terrain height). ---
+const ground = new THREE.Mesh(new THREE.PlaneGeometry(30, 20),
+  new THREE.MeshLambertMaterial({ color: 0x6f8f4e }));
+ground.rotation.x = -Math.PI / 2; ground.receiveShadow = true;
+scene.add(ground);
+const grid = new THREE.GridHelper(30, 30, 0x33502a, 0x5d7a45);
+grid.position.y = 0.01; scene.add(grid);
+
+// scale references: a 4 m sail post and a 1.7 m capsule. PLAN3D §5-D.1 wants the player to read
+// "small person" beside a 4 m post — this is how we check that by eye.
+const post = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.08, 4, 12),
+  new THREE.MeshLambertMaterial({ color: 0xcfd4d8 }));
+post.position.set(-4, 2, -3); post.castShadow = true; scene.add(post);
+const capsule = new THREE.Mesh(new THREE.CapsuleGeometry(0.28, 1.7 - 0.56, 6, 12),
+  new THREE.MeshLambertMaterial({ color: 0xd08a5a }));
+capsule.position.set(-2.6, 0.85, -3); capsule.castShadow = true; scene.add(capsule);
+
+// interact fixtures: a shed table (pick up a spare) and a broken sail corner (re-rig)
+const table = new THREE.Mesh(new THREE.BoxGeometry(1.2, 0.06, 0.6),
+  new THREE.MeshLambertMaterial({ color: 0x8a6b45 }));
+table.position.set(5, 0.8, 2); table.castShadow = true; scene.add(table);
+const cornerPos = new THREE.Vector3(0, 2.6, -5);
+const cornerDot = new THREE.Mesh(new THREE.SphereGeometry(0.13, 12, 10),
+  new THREE.MeshBasicMaterial({ color: 0xff5252 }));
+cornerDot.position.copy(cornerPos); scene.add(cornerDot);
+
+// --- mock wind, standing in for Lane C's weather.js wind.sample(pos,t) ---
+const windEl = document.getElementById('wind'), dirEl = document.getElementById('dir');
+const wv = document.getElementById('wv');
+let gustUntil = -1, gustAdd = 0;
+const wind = {
+  sample(_pos, t) {
+    const base = +windEl.value;
+    const extra = t < gustUntil ? gustAdd : 0;
+    const a = +dirEl.value;
+    const s = base + extra;
+    return new THREE.Vector3(Math.cos(a) * s, 0, Math.sin(a) * s);
+  },
+};
+windEl.oninput = () => { wv.textContent = windEl.value; };
+
+// --- player ---
+const { sim, view, step } = await loadPlayer(scene, {
+  start: { x: 0, y: 0, z: 3 },
+  height: 1.72,
+  groundAt: () => 0,                       // Lane A's world.js supplies the real terrain height
+});
+const input = new KeyboardInput();
+
+// --- interactions (the real thing: interact.js + wireYardActions) ---
+const interact = new Interact();
+const corner = { anchorId: 'post_nw', broken: true, load: 0, pos: cornerPos };
+wireYardActions(interact, {
+  sailRig: {
+    corners: [corner],
+    repair: () => { corner.broken = false; cornerDot.material.color.set(0x4caf50); },
+    trim: () => { cornerDot.scale.setScalar(cornerDot.scale.x * 1.08); },
+  },
+  world: { shedTable: { pos: table.position } },
+});
+
+document.getElementById('gust').onclick = () => { gustAdd = 18; gustUntil = clock.t + 1.6; };
+document.getElementById('knock').onclick = () => sim.knockdown(clock.t, +windEl.value ? 1 : 0, 0);
+document.getElementById('stag').onclick = () => sim.staggerHit(clock.t);
+
+// --- mock third-person camera. Lane A's camera.js replaces this; RMB-drag orbits. ---
+const orbit = { yaw: Math.PI, pitch: 0.28, dist: 6 };
+let drag = false;
+addEventListener('contextmenu', (e) => e.preventDefault());
+addEventListener('mousedown', (e) => { if (e.button === 2) drag = true; });
+addEventListener('mouseup', () => { drag = false; });
+addEventListener('mousemove', (e) => {
+  if (!drag) return;
+  orbit.yaw -= e.movementX * 0.005;
+  orbit.pitch = Math.max(-0.2, Math.min(1.1, orbit.pitch + e.movementY * 0.004));
+});
+addEventListener('wheel', (e) => { orbit.dist = Math.max(2.5, Math.min(14, orbit.dist + e.deltaY * 0.01)); });
+
+const hud = document.getElementById('hud');
+const promptEl = document.getElementById('prompt');
+const DT = 1 / 60;
+const clock = { t: 0, acc: 0, last: performance.now() };
+
+function frame(now) {
+  requestAnimationFrame(frame);
+  // rAF drives the VIEW; the sim is stepped at a fixed dt so it matches selftest exactly
+  let elapsed = Math.min(0.25, (now - clock.last) / 1000);
+  clock.last = now;
+  clock.acc += elapsed;
+  while (clock.acc >= DT) {
+    clock.acc -= DT;
+    clock.t += DT;
+    step(DT, clock.t, input.read(orbit.yaw), wind);
+    interact.step(DT, clock.t, sim, input.holding);
+  }
+
+  // camera: shoulder-follow, orbits on RMB
+  const h = 1.5;
+  cam.position.set(
+    sim.pos.x + Math.sin(orbit.yaw) * Math.cos(orbit.pitch) * orbit.dist,
+    sim.pos.y + h + Math.sin(orbit.pitch) * orbit.dist,
+    sim.pos.z + Math.cos(orbit.yaw) * Math.cos(orbit.pitch) * orbit.dist);
+  cam.lookAt(sim.pos.x, sim.pos.y + 1.1, sim.pos.z);
+
+  const near = interact.nearest(sim);
+  promptEl.innerHTML = near
+    ? `[E] ${interact.labelOf(near, sim)}<div id="bar"><div id="fill" style="width:${(interact.progress * 100).toFixed(0)}%"></div></div>`
+    : '';
+
+  hud.textContent =
+    `state    ${sim.state}${sim.busy ? '  (busy)' : ''}\n` +
+    `clip     ${STATES[sim.state].clip}\n` +
+    `speed    ${sim.speed.toFixed(2)} m/s\n` +
+    `pos      ${sim.pos.x.toFixed(1)}, ${sim.pos.z.toFixed(1)}\n` +
+    `wind     ${sim.windSpeed.toFixed(1)} m/s  (base ${sim.windBase.toFixed(1)}, gust ${sim.gust.toFixed(1)})\n` +
+    `shove    ${Math.hypot(sim.shove.x, sim.shove.z).toFixed(2)} m/s\n` +
+    `exposure ${sim.exposure.toFixed(2)} / ${sim.tune.knockSustain}\n` +
+    `pitch    ${sim.pitch.toFixed(2)}\n` +
+    `carrying ${sim.carrying || '—'}\n` +
+    `bound    ${view.clipNames.join(' ')}\n` +
+    `\nWASD move · shift run · E hold · RMB orbit`;
+
+  renderer.render(scene, cam);
+}
+requestAnimationFrame(frame);
+
+// expose for console poking / screenshot checks
+Object.assign(window, { sim, view, interact, scene, cam, orbit, clock, THREE });
+</script>
+</body>
+</html>

web/world/index.html

@@ -30,9 +30,19 @@
   <div id="dev">booting…</div>
   <div id="help">WASD move · shift run · RMB drag orbit · wheel zoom · Enter next phase</div>
 
+  <script type="importmap">
+    { "imports": { "three": "./vendor/three.module.js",
+                   "three/addons/": "./vendor/addons/" } }
+  </script>
   <script type="module">
     import { boot } from './js/main.js';
-    boot();
+    // boot() is async now — it fetches two storm defs, the ped, the clip pack
+    // and Lane E's debris GLBs. Surface a failure on the page rather than
+    // letting it die as an unhandled rejection behind a blue screen.
+    boot().catch((err) => {
+      console.error(err);
+      document.getElementById('dev').textContent = `BOOT FAILED — ${err.message} (see console)`;
+    });
   </script>
 </body>
 </html>

web/world/js/contracts.js

@@ -38,16 +38,25 @@ export const SPARE_COST = 15;
 /**
  * Hardware tiers, ported from prototype/game.js.
  *
- * `rating` is nominal kN. The ABSOLUTE numbers are placeholders inherited from
- * the 2D prototype's load scale — Lane B owns retuning them against the 3D
- * cloth's real load output. What must survive retuning is the SHAPE: three
- * tiers, roughly 1x / 2x / 4.5x strength at 1x / 3x / 6x price, so a mixed rig
- * is always the interesting choice and one dodgy corner is always affordable.
+ * `rating` is a working load limit in NEWTONS — retuned by Lane B against the
+ * 3D cloth's real load output, per the standing note that Lane B owns these
+ * numbers. Costs are the prototype's, untouched.
+ *
+ * The 2D prototype's 9/19/40 were on an arbitrary scale. The 3D cloth reports
+ * real newtons (a 5x5 m sail pulls ~1-4 kN per corner in a 34 m/s storm), so
+ * these are real WLLs: a cheap carabiner really does let go around 1.2 kN, a
+ * rated 8 mm shackle really does hold 6.5 kN. That is the DESIGN.md "Kerbal
+ * trick" — leave the game able to size real hardware.
+ *
+ * The SHAPE that had to survive retuning, and did: three tiers at 1x / 3x / 6x
+ * price, where $80 buys rated hardware on at most two of four corners. A mixed
+ * rig stays the interesting choice and you are always picking which corner to
+ * leave dodgy. Asserted in js/tests/b.test.js.
  */
 export const HARDWARE = [
-  { name: 'carabiner',     cost: 5,  rating: 9,  color: 0xe2b04a },
-  { name: 'shackle',       cost: 15, rating: 19, color: 0xc8d2d8 },
-  { name: 'rated shackle', cost: 30, rating: 40, color: 0x7ee0ff },
+  { name: 'carabiner',     cost: 5,  rating: 1200, color: 0xe2b04a },
+  { name: 'shackle',       cost: 15, rating: 3200, color: 0xc8d2d8 },
+  { name: 'rated shackle', cost: 30, rating: 6500, color: 0x7ee0ff },
 ];
 
 /** Game phases, in loop order. */
@@ -181,6 +190,48 @@ export class Emitter {
  * @property {boolean} broken
  */
 
+/**
+ * DEBRIS — Lane C implements. Lane B consumes `pieces` inside sail.step().
+ *
+ * SPRINT2 decision 5: the sail reads the pieces and applies its own impulses,
+ * rather than debris.js reaching into the cloth. Momentum bookkeeping stays in
+ * the one integrator that owns the nodes. That makes `pieces` a real contract
+ * surface, so it is **frozen** here: fields below are what Lane B may rely on.
+ *
+ * @typedef {object} Debris
+ * @property {DebrisPiece[]} pieces
+ *   Live pieces, newest last. The ARRAY IS MUTATED IN PLACE each step — pieces
+ *   are spliced out when they leave the yard, so don't hold a reference to it
+ *   across frames, and don't hold a piece past the step it despawned in. Read it
+ *   fresh inside step(). Order is not stable.
+ * @property {(dt:number, t:number, world?:object) => void} step  Fixed dt. Deterministic.
+ * @property {(ev:object, t:number) => DebrisPiece} spawn
+ * @property {(map:Object<string,THREE.Object3D>) => Debris} setModels
+ * @property {() => void} clear
+ */
+
+/**
+ * One airborne object. Frozen shape — Lane C will not remove or repurpose these.
+ *
+ * The collision volume is a SPHERE of radius `r` centred on (x,y,z): a crate is
+ * boxy, but a sphere is what you can afford to test against every cloth node,
+ * every frame. Everything is SI — metres, m/s, kg — so `mass * v` is a real
+ * momentum you can subtract from.
+ *
+ * @typedef {object} DebrisPiece
+ * @property {number} x
+ * @property {number} y                     Centre, not base. Rests at heightAt(x,z) + r.
+ * @property {number} z
+ * @property {number} vx
+ * @property {number} vy
+ * @property {number} vz
+ * @property {number} r                     Collision sphere radius, m.
+ * @property {number} mass                  kg. Crate 9, tub 5, bin 14.
+ * @property {string} model                 Key into models/debris/, e.g. 'BlueCrate_v2'.
+ * @property {boolean} hitPlayer            Already knocked the player down once.
+ * @property {THREE.Object3D|null} mesh     Render instance. Lane C drives it; don't move it.
+ */
+
 /**
  * PLAYER — Lane D implements.
  *
@@ -249,6 +300,20 @@ export const CONTRACT = {
   interact: { register: 'function' },
   camera:   { object: 'object', yaw: 'number', update: 'function' },
   game:     { phase: 'string', on: 'function' },
+  debris:   { pieces: 'object', step: 'function', spawn: 'function', setModels: 'function', clear: 'function' },
+};
+
+/**
+ * The frozen DebrisPiece fields (SPRINT2 decision 5). Lane B's sail.step() reads
+ * these off `debris.pieces` and applies impulses from them, so renaming one is a
+ * breaking change to someone else's integrator, not a local tidy-up. Asserted
+ * against live pieces in c.test.js — if this table and debris.js disagree, the
+ * selftest says so before Lane B's cloth does.
+ */
+export const DEBRIS_PIECE_FIELDS = {
+  x: 'number', y: 'number', z: 'number',
+  vx: 'number', vy: 'number', vz: 'number',
+  r: 'number', mass: 'number', model: 'string',
 };
 
 /**

web/world/js/interact.js

@@ -0,0 +1,181 @@
+/**
+ * interact.js — hold-E actions with radial progress.  (Lane D)
+ *
+ * contracts.js:  interact.register({id, pos, radius, holdSecs, label, canUse()->bool, onDone()})
+ *
+ * Zero imports (same reason as player.sim.js): the whole thing is fixed-dt and headless-testable.
+ * `pos` is duck-typed {x,y,z}, so a THREE.Vector3 or a plain object both work.
+ *
+ * The busy handshake: this module both ENTERS and LEAVES the player's `busy` state. Nothing else
+ * writes it, so a dropped release cannot strand the player — and if the world takes the player away
+ * mid-hold (a gust puts them down), we notice `player.state` is no longer 'busy' and abort without
+ * stomping on the state the world just set.
+ */
+
+export class Interact {
+  constructor() {
+    this.targets = new Map();
+    this.active = null;      // the target currently being held
+    this.progress = 0;       // 0..1 — the radial
+    this.latched = false;    // a completed action re-arms only after E is released (see step)
+    this.events = [];        // {type:'done'|'cancel', id, t} — drained by hud.js
+  }
+
+  /**
+   * @param {object}   spec
+   * @param {string}   spec.id
+   * @param {object}   spec.pos        {x,y,z} — read live each step, so it may move (a sail corner does)
+   * @param {number}   [spec.radius]   metres
+   * @param {number}   [spec.holdSecs]
+   * @param {string|function} [spec.label]  string, or (player)->string for live text
+   * @param {function} [spec.canUse]   (player) -> bool
+   * @param {function} [spec.onDone]   (player, t) -> void
+   * @returns {function} unregister
+   */
+  register(spec) {
+    if (!spec || !spec.id) throw new Error('interact.register: id required');
+    const target = {
+      radius: 1.6, holdSecs: 1, label: '', canUse: null, onDone: null, ...spec,
+    };
+    this.targets.set(target.id, target);
+    return () => this.unregister(target.id);
+  }
+
+  unregister(id) {
+    if (this.active && this.active.id === id) this.active = null, this.progress = 0;
+    return this.targets.delete(id);
+  }
+
+  labelOf(target, player) {
+    return typeof target.label === 'function' ? target.label(player) : target.label;
+  }
+
+  _usable(target, player) {
+    return !target.canUse || !!target.canUse(player);
+  }
+
+  /** Nearest registered target in range whose canUse() passes. */
+  nearest(player) {
+    let best = null, bestD = Infinity;
+    for (const target of this.targets.values()) {
+      const p = typeof target.pos === 'function' ? target.pos() : target.pos;
+      if (!p) continue;
+      const d = Math.hypot(p.x - player.pos.x, p.z - player.pos.z);
+      if (d <= target.radius && d < bestD && this._usable(target, player)) { best = target; bestD = d; }
+    }
+    return best;
+  }
+
+  cancel(t, player) {
+    if (!this.active) return;
+    // only hand the player back if they're still ours — a knockdown mid-hold already re-stated them
+    if (player.state === 'busy') player.setState('idle', t);
+    this.events.push({ type: 'cancel', id: this.active.id, t });
+    this.active = null;
+    this.progress = 0;
+  }
+
+  /**
+   * @param {number} dt @param {number} t
+   * @param {PlayerSim} player
+   * @param {boolean} holding  is E held this frame
+   * @returns {{target, progress, label, holding}} for hud.js to draw the prompt + radial
+   */
+  step(dt, t, player, holding) {
+    // One press, one action: a completed hold latches until E is released. Without this, a held key
+    // re-arms the instant the action finishes and the same action fires every holdSecs forever
+    // (leaning on the shed table would deal you a spare a second, indefinitely).
+    if (!holding) this.latched = false;
+
+    const near = this.nearest(player);
+
+    if (this.active) {
+      const stolen = player.state !== 'busy';        // something else claimed the player
+      if (!holding || near !== this.active || !this._usable(this.active, player) || stolen) {
+        this.cancel(t, player);
+      }
+    }
+
+    if (!this.active && holding && !this.latched && near && !player.busy) {
+      this.active = near;
+      this.progress = 0;
+      player.setState('busy', t);
+    }
+
+    if (this.active) {
+      this.progress += dt / Math.max(1e-6, this.active.holdSecs);
+      if (this.progress >= 1) {
+        const done = this.active;
+        this.active = null;
+        this.progress = 0;
+        this.latched = true;
+        player.setState('idle', t);      // release busy FIRST — onDone may pickUp(), which refuses while busy
+        if (done.onDone) done.onDone(player, t);
+        this.events.push({ type: 'done', id: done.id, t });
+      }
+    }
+
+    const shown = this.active || near;
+    return {
+      target: shown,
+      progress: this.progress,
+      label: shown ? this.labelOf(shown, player) : '',
+      holding: !!this.active,
+    };
+  }
+}
+
+/**
+ * Register the standard yard actions (PLAN3D §5-D.4). Duck-typed against the contracts so Lane D
+ * never edits Lane B's or Lane A's files — anything not yet landed is simply skipped.
+ *
+ * @param {Interact} interact
+ * @param {object} deps  {sailRig, world, spares}
+ *   sailRig.corners   -> [{anchorId, hw, load, broken}]     (contracts.js, Lane B)
+ *   sailRig.repair(i) -> void   [PROPOSED — see THREADS.md]
+ *   sailRig.trim(i,d) -> void   [PROPOSED — per-corner turnbuckle, see THREADS.md]
+ *   world.shedTable   -> {pos}                              (Lane A/E)
+ */
+export function wireYardActions(interact, deps = {}) {
+  const { sailRig, world } = deps;
+  const wired = [];
+
+  if (sailRig && Array.isArray(sailRig.corners)) {
+    sailRig.corners.forEach((corner, i) => {
+      // re-rig a broken corner — costs the spare you're carrying
+      wired.push(interact.register({
+        id: `rerig_${i}`,
+        pos: () => corner.pos || (sailRig.cornerPos && sailRig.cornerPos(i)),
+        radius: 1.8,
+        holdSecs: 2.5,
+        label: 're-rig corner',
+        canUse: (p) => corner.broken && p.carrying === 'spare',
+        onDone: (p) => { p.carrying = null; if (sailRig.repair) sailRig.repair(i); },
+      }));
+      // per-corner turnbuckle trim — new vs the prototype; makes corners individual
+      wired.push(interact.register({
+        id: `trim_${i}`,
+        pos: () => corner.pos || (sailRig.cornerPos && sailRig.cornerPos(i)),
+        radius: 1.8,
+        holdSecs: 1.2,
+        label: 'tighten turnbuckle',
+        canUse: () => !corner.broken && !!sailRig.trim,
+        onDone: () => sailRig.trim && sailRig.trim(i, +0.1),
+      }));
+    });
+  }
+
+  if (world && world.shedTable) {
+    wired.push(interact.register({
+      id: 'spare_table',
+      pos: world.shedTable.pos,
+      radius: 1.5,
+      holdSecs: 0.6,
+      label: (p) => (p.carrying ? 'hands full' : 'take a spare'),
+      canUse: (p) => !p.carrying,           // hands-full rule
+      onDone: (p, t) => p.pickUp('spare', t),
+    }));
+  }
+
+  return () => wired.forEach((un) => un());
+}

web/world/js/main.js

@@ -1,18 +1,32 @@
 /**
  * SHADES — boot, game loop, phase machine. Lane A owns this file.
  *
- * Nothing is auto-run on import: index.html calls boot(). That keeps createGame()
- * importable from selftest.html, which must never construct a WebGLRenderer.
+ * This is the assembly point: every other lane's module is proven in isolation,
+ * and this file is where they become one game. Two rules make that possible and
+ * are worth not breaking:
  *
- * The loop is a fixed-dt accumulator. Sim modules only ever see FIXED_DT, never
- * a real frame delta — that is the whole reason selftest can fast-forward a 90 s
- * storm in a few milliseconds and get the same numbers the player got.
+ *  - **Nothing auto-runs on import.** index.html calls boot(). That keeps
+ *    createGame() importable from selftest.html, which must never construct a
+ *    WebGLRenderer.
+ *  - **The loop is a fixed-dt accumulator.** Sim modules only ever see FIXED_DT,
+ *    never a real frame delta. That is the whole reason selftest can fast-forward
+ *    a 90 s storm in milliseconds and get the numbers the player got.
  */
 
 import * as THREE from '../vendor/three.module.js';
-import { FIXED_DT, PHASES, STORM_LEN, YARD, Emitter, createStubWind } from './contracts.js';
-import { createWorld, heightAt } from './world.js';
+import { FIXED_DT, PHASES, STORM_LEN, HARDWARE, Emitter } from './contracts.js';
+import { createWorld } from './world.js';
 import { createCameraRig } from './camera.js';
+import { loadStorm, createWind } from './weather.js';
+import { SailRig, createSailView } from './sail.js';
+import { createPlayer } from './player.js';
+import { Interact, wireYardActions } from './interact.js';
+import { createDebris } from './debris.js';
+import { createSkyFx } from './skyfx.js';
+
+/** Which storm each phase runs under (SPRINT2 §Lane A.1). */
+const CALM_STORM = 'storm_01_gentle';
+const WILD_STORM = 'storm_02_wildnight';
 
 // ---------------------------------------------------------------------------
 // Phase machine
@@ -58,81 +72,91 @@ export function createGame() {
 }
 
 // ---------------------------------------------------------------------------
-// M0 placeholder player
+// Wind router
 // ---------------------------------------------------------------------------
 
 /**
- * A 1.7 m capsule that walks. This exists ONLY so the camera has something to
- * follow and the yard scale is legible before Lane D lands.
+ * One wind object whose identity never changes, delegating to whichever storm
+ * is currently running.
  *
- * Lane D: replace the call site in boot() with your player.js factory — the
- * shape you need to satisfy is `Player` in contracts.js ({pos, carrying, busy,
- * update}) — then delete this function. Everything else in this file already
- * talks to you through that contract, so nothing else should need to change.
+ * Every consumer binds to wind exactly once, at construction — the yard closes
+ * over it for tree sway, createPlayer takes it in opts, createDebris reads its
+ * event stream. So swapping storm_01 for storm_02 at the phase change has to be
+ * a re-point, not a re-wire, or half the game would still be sampling the calm
+ * day while the other half is in a gale.
+ *
+ * Shelters are applied to every storm rather than just the active one: they
+ * describe the yard's trees, which don't stop existing when the weather turns.
+ *
+ * @param {object[]} all  every wind this session can switch between
  */
-function createPlaceholderPlayer(scene, world, cameraRig) {
-  const WALK = 2.2, RUN = 4.5;   // m/s
+function createWindRouter(all) {
+  let active = all[0];
 
-  const mesh = new THREE.Mesh(
-    new THREE.CapsuleGeometry(0.28, 1.14, 4, 12),
-    new THREE.MeshStandardMaterial({ color: 0xffd27a, roughness: 0.7 }),
-  );
-  mesh.name = 'player_placeholder';
-  mesh.castShadow = true;
-  scene.add(mesh);
+  const router = {
+    /** The wind currently in force. Assign through use(). */
+    get active() { return active; },
+    use(w) { active = w; return router; },
 
-  const keys = new Set();
-  const onDown = (e) => {
-    keys.add(e.key.toLowerCase());
-    if ([' ', 'arrowup', 'arrowdown', 'arrowleft', 'arrowright'].includes(e.key.toLowerCase())) e.preventDefault();
-  };
-  const onUp = (e) => keys.delete(e.key.toLowerCase());
-  addEventListener('keydown', onDown);
-  addEventListener('keyup', onUp);
+    sample: (pos, t, out) => active.sample(pos, t, out),
+    speedAt: (pos, t) => active.speedAt(pos, t),
+    gustTelegraph: (t) => active.gustTelegraph(t),
+    eventsBetween: (a, b) => active.eventsBetween(a, b),
+    rainAt: (t) => active.rainAt(t),
+    dirAt: (t) => active.dirAt(t),
 
-  const pos = new THREE.Vector3(0, heightAt(0, 6), 6);
-  const move = new THREE.Vector3();
-  const fwd = new THREE.Vector3();
-  const right = new THREE.Vector3();
-  let facing = 0;
-
-  const hx = YARD.width / 2 - 0.5, hz = YARD.depth / 2 - 0.5;
-
-  return {
-    pos,
-    carrying: null,
-    busy: false,
-    mesh,
-
-    update(dt) {
-      const yaw = cameraRig.yaw;
-      // Camera-relative: forward is where the camera is looking, flattened.
-      fwd.set(-Math.sin(yaw), 0, -Math.cos(yaw));
-      right.set(Math.cos(yaw), 0, -Math.sin(yaw));
-
-      move.set(0, 0, 0);
-      if (keys.has('w') || keys.has('arrowup')) move.add(fwd);
-      if (keys.has('s') || keys.has('arrowdown')) move.sub(fwd);
-      if (keys.has('d') || keys.has('arrowright')) move.add(right);
-      if (keys.has('a') || keys.has('arrowleft')) move.sub(right);
-
-      if (move.lengthSq() > 0) {
-        move.normalize().multiplyScalar((keys.has('shift') ? RUN : WALK) * dt);
-        pos.x = Math.max(-hx, Math.min(hx, pos.x + move.x));
-        pos.z = Math.max(-hz, Math.min(hz, pos.z + move.z));
-        facing = Math.atan2(move.x, move.z);
-      }
-      pos.y = world.heightAt(pos.x, pos.z);
-
-      mesh.position.set(pos.x, pos.y + 0.85, pos.z);   // capsule centre
-      mesh.rotation.y = facing;
+    setShelters(list) {
+      for (const w of all) w.setShelters(list);
+      return router;
+    },
+    setSheltersFromTrees(trees, o = {}) {
+      return router.setShelters(trees.map((tr) => ({
+        x: tr.pos ? tr.pos.x : tr.x,
+        z: tr.pos ? tr.pos.z : tr.z,
+        radius: o.radius ?? tr.radius ?? 3,
+        strength: o.strength ?? 0.45,
+        length: o.length ?? 14,
+      })));
     },
 
-    dispose() {
-      removeEventListener('keydown', onDown);
-      removeEventListener('keyup', onUp);
-    },
+    get duration() { return active.duration; },
+    get gusts() { return active.gusts; },
+    get def() { return active.def; },
+    get seed() { return active.seed; },
+    get core() { return active.core; },
   };
+  return router;
+}
+
+// ---------------------------------------------------------------------------
+// Debris models
+// ---------------------------------------------------------------------------
+
+/**
+ * Lane E's crates and tubs, keyed by the names storm JSON spawns and debris.js
+ * has radii for. A browser can't glob a directory, so the list is explicit —
+ * and it should stay matched to MODEL_SPEC in debris.js (Lane C's ask: tell them
+ * rather than fighting the radii).
+ *
+ * Missing files are not fatal: debris.js falls back to a graybox box per piece,
+ * which is exactly the degrade-quietly behaviour Lane C designed for.
+ */
+const DEBRIS_MODELS = ['BlueCrate_v2', 'BlackTub_v2', 'WhiteTub_v2', 'WoodenBin_v2'];
+
+async function loadDebrisModels() {
+  const { GLTFLoader } = await import('../vendor/addons/loaders/GLTFLoader.js');
+  const loader = new GLTFLoader();
+  const out = {};
+  await Promise.all(DEBRIS_MODELS.map(async (name) => {
+    try {
+      const gltf = await loader.loadAsync(`./models/debris/${name}.glb`);
+      gltf.scene.traverse((o) => { if (o.isMesh) { o.castShadow = true; o.receiveShadow = true; } });
+      out[name] = gltf.scene;
+    } catch (err) {
+      console.warn(`[main] debris model ${name} unavailable, using graybox:`, err.message);
+    }
+  }));
+  return out;
 }
 
 // ---------------------------------------------------------------------------
@@ -143,7 +167,7 @@ function createPlaceholderPlayer(scene, world, cameraRig) {
  * @param {object} [opts]
  * @param {HTMLCanvasElement} [opts.canvas]
  */
-export function boot(opts = {}) {
+export async function boot(opts = {}) {
   const canvas = opts.canvas ?? document.getElementById('c');
 
   const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
@@ -155,33 +179,154 @@ export function boot(opts = {}) {
 
   const scene = new THREE.Scene();
 
-  // Lane C: swap createStubWind() for your createWeather(). Everything that
-  // moves reads this one object, so that swap is the whole integration.
-  const wind = createStubWind({ calm: true });
+  // --- 1. weather ---------------------------------------------------------
+  // Both storms load up front: the forecast card needs to read storm_02's shape
+  // before the player has agreed to face it.
+  const [calmDef, wildDef] = await Promise.all([loadStorm(CALM_STORM), loadStorm(WILD_STORM)]);
+  const calmWind = createWind(calmDef);
+  const wildWind = createWind(wildDef);
+  const wind = createWindRouter([calmWind, wildWind]);
 
+  // --- world & camera -----------------------------------------------------
   const world = createWorld(scene, { wind });
   const cameraRig = createCameraRig(canvas);
   cameraRig.setSolids(world.solids);
   cameraRig.setGround(world.heightAt);
 
-  const player = createPlaceholderPlayer(scene, world, cameraRig);
+  // Lane C: trees don't shelter anything until they're told where they are.
+  wind.setSheltersFromTrees(world.anchors.filter((a) => a.type === 'tree'));
+
+  // --- 2. player ----------------------------------------------------------
+  const interact = new Interact();
+  const player = await createPlayer(scene, world, cameraRig, { wind, interact });
+
+  // --- 3. sail ------------------------------------------------------------
+  const rig = new SailRig({ anchors: world.anchors });
+  let sailView = null;
+
+  /**
+   * Attach the cloth across 4 anchors and (re)build its view.
+   *
+   * The order here is load-bearing. createSailView reads rig.pos and rig.tris,
+   * which don't exist until attach() allocates them in _build() — build the view
+   * first and it throws on an undefined array. A re-rig can also change the grid,
+   * so the view has to be rebuilt rather than reused. Both facts make this the
+   * single door that boot and Lane B's picking adapter should come through.
+   *
+   * Re-wiring interact each time is deliberate: its targets close over corner
+   * objects and attach() makes a fresh corners array, so stale closures would
+   * point at corners the sim no longer steps. The ids are stable, so this
+   * replaces the old targets rather than stacking duplicates.
+   */
+  async function rigSail(anchorIds, hwChoices, tension = 1.0) {
+    rig.attach(anchorIds, hwChoices, tension);
+    if (sailView) {
+      scene.remove(sailView);
+      sailView.traverse((o) => { o.geometry?.dispose(); o.material?.dispose(); });
+    }
+    sailView = await createSailView(rig);
+    scene.add(sailView);
+    wireYardActions(interact, { sailRig: rig, world });
+    return sailView;
+  }
+
+  // Until Lane B's prep-phase picking adapter lands (SPRINT2 §B.3), rig a
+  // default quad so the yard has a live sail and Lane D has something to
+  // repair. Deliberately the prototype's AUTO loadout — one dodgy carabiner
+  // corner. It also spans most of the yard, which is the 70–192 m² problem
+  // decision 2 fixes in step 6, not a fault in the cloth.
+  await rigSail(['h1', 'h3', 'p2', 'p1'], [HARDWARE[2], HARDWARE[1], HARDWARE[1], HARDWARE[0]]);
+
   const game = createGame();
 
-  // --- dev overlay (temporary — Lane A's hud.js replaces it after M0) ----
+  // --- clocks -------------------------------------------------------------
+  // Two of them, and the distinction matters. `simT` is wall-clock seconds since
+  // boot. `windT` is STORM time — storm JSON is authored with t=0 at the storm's
+  // first gust, so it's phase time during the storm, and off-storm it wraps the
+  // calm day around its own duration so the breeze keeps breathing however long
+  // you spend rigging. Every sim module samples windT; nothing samples simT.
+  let simT = 0;
+  let windT = 0;
+  let acc = 0;
+
+  function windTime() {
+    if (game.phase === 'storm') return game.phaseT;
+    return simT % Math.max(1, calmWind.duration);
+  }
+
+  // --- 4. sky, audio, debris ---------------------------------------------
+  const events = [];
+  const pushEvent = (text) => {
+    events.push({ t: game.phaseT, text });
+    if (events.length > 4) events.shift();
+  };
+
+  const debris = createDebris({
+    wind,
+    scene,
+    heightAt: world.heightAt,
+    // knockdown(t, dirX, dirZ) — the first arg is the sim clock, NOT the impact
+    // magnitude. Passing `impact` here would jam ~40 into the state machine's
+    // start time and the player would never get up. The piece's own velocity is
+    // the direction, so you fall the way the crate was travelling.
+    onHitPlayer: (piece) => player.sim.knockdown(windT, piece.vx, piece.vz),
+    onEvent: pushEvent,
+  });
+  debris.setModels(await loadDebrisModels());
+
+  // skyfx reads the storm's `sky` block at construction (darkness, cloud scroll,
+  // night), so it is rebuilt when the storm changes rather than re-pointed like
+  // wind. dispose() hands world.sun/world.hemi back exactly as they were, which
+  // is what makes that safe to do mid-session.
+  let sky = null;
+  let audioUnlocked = false;
+  function makeSky() {
+    if (sky) sky.dispose();
+    sky = createSkyFx({
+      scene,
+      camera: cameraRig.object,
+      wind,
+      sun: world.sun,
+      hemi: world.hemi,
+      onEvent: pushEvent,
+    });
+    if (audioUnlocked) sky.unlockAudio();
+    return sky;
+  }
+  makeSky();
+
+  // Browsers won't start an AudioContext without a gesture. Without this the
+  // storm is silent, and half of DESIGN.md's threat model is audible.
+  const unlock = () => {
+    if (audioUnlocked) return;
+    audioUnlocked = true;
+    sky?.unlockAudio();
+    removeEventListener('pointerdown', unlock);
+    removeEventListener('keydown', unlock);
+  };
+  addEventListener('pointerdown', unlock);
+  addEventListener('keydown', unlock);
+
+  // --- dev overlay (temporary — hud.js replaces it in step 7) -------------
   const hud = document.getElementById('dev');
   const banner = document.getElementById('banner');
+  addEventListener('keydown', (e) => {
+    if (e.key === 'Enter') game.advance();
+  });
+
+  // --- phases -------------------------------------------------------------
   game.on('phaseChange', ({ to }) => {
+    wind.use(to === 'storm' ? wildWind : calmWind);
+    makeSky();
+    events.length = 0;
     if (banner) {
       banner.textContent = to.toUpperCase();
       banner.style.opacity = '1';
       setTimeout(() => { banner.style.opacity = '0'; }, 1400);
     }
   });
-  addEventListener('keydown', (e) => {
-    if (e.key === 'Enter') game.advance();
-  });
 
-  // --- resize ------------------------------------------------------------
+  // --- resize -------------------------------------------------------------
   function resize() {
     const w = canvas.clientWidth || innerWidth;
     const h = canvas.clientHeight || innerHeight;
@@ -191,18 +336,19 @@ export function boot(opts = {}) {
   addEventListener('resize', resize);
   resize();
 
-  // --- loop --------------------------------------------------------------
+  // --- loop ---------------------------------------------------------------
   const clock = new THREE.Clock();
-  let acc = 0;
-  let simT = 0;
   let frames = 0, fpsT = 0, fps = 0;
 
-  function step(dt, t) {
+  function step(dt) {
     game.tick(dt);
-    world.update(dt, t);
-    player.update(dt, t);
-    // Lane B: sailRig.step(dt, wind, t) goes here.
-    // Lane C: debris.step(dt, wind, t) goes here.
+    simT += dt;
+    windT = windTime();
+    world.update(dt, windT);
+    player.update(dt, windT);
+    rig.step(dt, wind, windT);
+    debris.step(dt, windT, { player: player.sim, sail: rig });
+    sky?.step(dt, windT, { sail: rig });
   }
 
   function frame() {
@@ -212,28 +358,55 @@ export function boot(opts = {}) {
     acc += raw;
     let guard = 0;
     while (acc >= FIXED_DT && guard++ < 60) {
-      step(FIXED_DT, simT);
-      simT += FIXED_DT;
+      step(FIXED_DT);
       acc -= FIXED_DT;
     }
 
     cameraRig.update(raw, player.pos);
+    sailView?.update();
     renderer.render(scene, cameraRig.object);
 
     frames++; fpsT += raw;
     if (fpsT >= 0.5) { fps = frames / fpsT; frames = 0; fpsT = 0; }
     if (hud) {
-      const w = wind.sample(player.pos, simT);
+      const wt = windT;
+      const speed = wind.speedAt(player.pos, wt);
+      const tel = wind.gustTelegraph(wt);
+      const worst = rig.corners.reduce((m, c) => Math.max(m, c.load || 0), 0);
       hud.textContent =
-        `${fps.toFixed(0)} fps | phase ${game.phase} ${game.phaseT.toFixed(1)}s | ` +
-        `wind ${w.length().toFixed(1)} m/s | t ${simT.toFixed(1)}s`;
+        `${fps.toFixed(0)} fps | ${game.phase} ${game.phaseT.toFixed(1)}s | ` +
+        `wind ${speed.toFixed(1)} m/s${tel ? ` | GUST in ${tel.eta.toFixed(1)}s` : ''} | ` +
+        `worst corner ${worst.toFixed(1)} | debris ${debris.pieces.length}` +
+        `${events.length ? ` | ${events[events.length - 1].text}` : ''}`;
     }
     requestAnimationFrame(frame);
   }
   requestAnimationFrame(frame);
 
-  // Handy for poking at the world from the console.
-  const api = { renderer, scene, world, cameraRig, player, game, wind, get simT() { return simT; } };
+  // Handy for poking at the world from the console, and for the selftest-free
+  // hand checks the sprint's acceptance actually turns on.
+  const api = {
+    renderer, scene, world, cameraRig, player, game, wind, rig, rigSail,
+    get sailView() { return sailView; },
+    debris, interact, events,
+    get sky() { return sky; },
+    get simT() { return simT; },
+    windTime,
+    calmWind, wildWind,
+
+    /**
+     * Drive the sim by hand at fixed dt, and draw on demand. rAF is throttled to
+     * a standstill in a hidden tab, so these are the only honest way to
+     * fast-forward a storm or capture one from a headless browser — which is
+     * exactly what this sprint's "90 s storm_02 run captured" acceptance needs.
+     * Same code path the rAF loop uses; no test-only branch to drift.
+     */
+    step,
+    render() {
+      sailView?.update();
+      renderer.render(scene, cameraRig.object);
+    },
+  };
   globalThis.SHADES = api;
   return api;
 }

web/world/js/player.js

@@ -0,0 +1,267 @@
+/**
+ * player.js — the small person: rig, clips, camera-relative control.  (Lane D)
+ *
+ * The deterministic half lives in player.sim.js; this file is the view. It follows the 90sDJsim
+ * DEVMANUAL "Rigged animated characters" rules, which are law here:
+ *   · SkeletonUtils.clone() for instances — a plain .clone() breaks skinned meshes
+ *   · height-normalise off the HEAD BONE and plant the feet — Mixamo scale is unreliable, so the
+ *     scale factor is always MEASURED, never a blind setScalar of a guessed constant
+ *   · canonicalise the bone namespace so any clip binds to any character
+ *
+ * Assets (see models/MODELS.md): player_01.glb is an untouched ped (metre-scale, head bone 1.75 m);
+ * player_anims.glb is an anim-only carrier built by tools/character/build_player_anims.py. The clips
+ * are retargeted onto the ped at load — see _rotOnly for why that is safe at any carrier scale.
+ */
+import * as THREE from '../vendor/three.module.js';
+import { clone as skeletonClone } from '../vendor/addons/utils/SkeletonUtils.js';
+import { GLTFLoader } from '../vendor/addons/loaders/GLTFLoader.js';
+import { PlayerSim, STATES, TUNE } from './player.sim.js';
+
+export { PlayerSim, STATES, TUNE };
+
+export const CHAR_URL = './models/player_01.glb';
+export const ANIM_URL = './models/player_anims.glb';
+
+/**
+ * Canonicalise the Mixamo skeleton namespace (mixamorig4: vs mixamorig12:) so any clip binds to any
+ * character. Every Mixamo auto-rig upload gets its own numbered namespace and three.js binds tracks
+ * BY NODE NAME — a mismatched clip binds to nothing and plays a silent T-pose, with no error.
+ * (Straight from 90sDJsim index.html. The \d+ is deliberate: a bare "mixamorig:" is already canonical.)
+ */
+const _canon = (s) => s.replace(/mixamorig\d+/g, 'mixamorig');
+
+const canonRig = (r) => {
+  if (!r) return r;
+  if (r.scene) r.scene.traverse((o) => { o.name = _canon(o.name); });
+  if (r.anims) r.anims.forEach((a) => a.tracks.forEach((t) => { t.name = _canon(t.name); }));
+  return r;
+};
+
+/**
+ * Shared-clip filter: keep limb/spine rotations only. Drop ALL position tracks (a different-scale
+ * source inflates or crumples the target) AND Hips.quaternion (a different-orientation source lays
+ * the target flat). Quaternions are scale-invariant, which is the whole reason a clip carrier at any
+ * scale retargets cleanly onto the metre-scale ped.
+ *
+ * The cost is that a clip can no longer lie the body down — so the knockdown does NOT come from the
+ * Falling clip's root. player.sim.js pitches the root itself, which is also how the fall gets to go
+ * DOWNWIND of the gust that caused it. The clip only supplies the flail.
+ */
+const _rotOnly = (c) => new THREE.AnimationClip(c.name, c.duration,
+  c.tracks.filter((t) => t.name.endsWith('.quaternion') && !/Hips\.quaternion$/i.test(t.name)));
+
+const _loadGLTF = (loader, url) => new Promise((res, rej) =>
+  loader.load(url, (g) => res({ scene: g.scene, anims: g.animations }), undefined,
+    () => rej(new Error(`player: failed to load ${url}`))));
+
+const UP = new THREE.Vector3(0, 1, 0);
+
+export class PlayerView {
+  /**
+   * @param {object} rig    {scene, anims} — the character
+   * @param {Array}  clips  retargeted AnimationClips
+   * @param {number} height metres to the top of the head
+   */
+  constructor(rig, clips, height = 1.72) {
+    // root: world position + facing + knockdown pitch.  fig: the rig, lifted so its feet sit at y=0.
+    this.root = new THREE.Group();
+    this.root.name = 'player';
+
+    const fig = skeletonClone(rig.scene);
+    this.fig = fig;
+    fig.traverse((o) => { if (o.isMesh) { o.frustumCulled = false; o.castShadow = true; } });
+    this.root.add(fig);
+    this.root.updateWorldMatrix(true, true);
+
+    // measure, then scale — never a blind setScalar (DEVMANUAL). /head/i matches both Head and
+    // HeadTop_End; max() takes the crown, which is what "height" means.
+    const wp = new THREE.Vector3();
+    let headY = 0;
+    fig.traverse((o) => {
+      if (!o.isBone) return;
+      o.getWorldPosition(wp);
+      if (/head/i.test(o.name)) headY = Math.max(headY, wp.y);
+    });
+    if (headY > 1e-4) { fig.scale.setScalar(height / headY); fig.updateWorldMatrix(true, true); }
+    this.height = height;
+
+    // plant the feet: lift the rig so its lowest bone sits on the root's origin
+    let minY = Infinity;
+    fig.traverse((o) => { if (o.isBone) { o.getWorldPosition(wp); minY = Math.min(minY, wp.y); } });
+    if (minY < Infinity) fig.position.y = -minY;
+
+    this.mixer = new THREE.AnimationMixer(fig);
+    this.actions = {};
+    // some characters lack bones a shared clip animates (thumb joints, say) — bind only what exists,
+    // else three.js spams "No target node found" for every missing bone
+    const nodes = new Set();
+    fig.traverse((o) => { if (o.name) nodes.add(o.name); });
+    for (const clip of clips) {
+      const bindable = clip.tracks.filter((t) => nodes.has(t.name.split('.')[0]));
+      if (!bindable.length) continue;
+      const use = bindable.length === clip.tracks.length
+        ? clip : new THREE.AnimationClip(clip.name, clip.duration, bindable);
+      this.actions[clip.name] = this.mixer.clipAction(use);
+    }
+    this.current = null;
+    this._axis = new THREE.Vector3();
+    this._qYaw = new THREE.Quaternion();
+    this._qPitch = new THREE.Quaternion();
+  }
+
+  /** @returns {string[]} clip names that bound to at least one bone */
+  get clipNames() { return Object.keys(this.actions); }
+
+  play(name, loop = true, fade = 0.18) {
+    const next = this.actions[name];
+    if (!next || next === this.current) return;
+    next.reset();
+    next.setEffectiveWeight(1);
+    next.setLoop(loop ? THREE.LoopRepeat : THREE.LoopOnce, loop ? Infinity : 1);
+    next.clampWhenFinished = !loop;
+    if (this.current) next.crossFadeFrom(this.current, fade, false);
+    next.play();
+    this.current = next;
+  }
+
+  /** Push one sim frame onto the rig. dt drives the mixer only — the sim already stepped. */
+  sync(sim, dt) {
+    const st = STATES[sim.state];
+    this.play(st.clip, st.loop !== false);
+
+    this.root.position.set(sim.pos.x, sim.pos.y, sim.pos.z);
+
+    // yaw, then tip over about a world-horizontal axis square to the fall direction, pivoting at the
+    // feet. At pitch 0 this is exactly the yaw, so upright play is untouched.
+    this._qYaw.setFromAxisAngle(UP, sim.facing);
+    if (sim.pitch > 1e-4) {
+      this._axis.set(sim.knockDir.z, 0, -sim.knockDir.x);
+      if (this._axis.lengthSq() < 1e-8) this._axis.set(1, 0, 0);
+      this._qPitch.setFromAxisAngle(this._axis.normalize(), sim.pitch * Math.PI * 0.5);
+      this.root.quaternion.copy(this._qPitch).multiply(this._qYaw);
+    } else {
+      this.root.quaternion.copy(this._qYaw);
+    }
+
+    this.mixer.update(dt);
+  }
+
+  dispose() {
+    this.mixer.stopAllAction();
+    this.root.removeFromParent();
+  }
+}
+
+/**
+ * Load the player and attach it to a scene.
+ * @param {THREE.Scene|THREE.Object3D} scene
+ * @param {object} [opts]  {start, facing, height, groundAt, tune, charUrl, animUrl}
+ * @returns {Promise<{sim: PlayerSim, view: PlayerView, step: function}>}
+ */
+export async function loadPlayer(scene, opts = {}) {
+  const loader = new GLTFLoader();
+  const [rig, animPack] = await Promise.all([
+    _loadGLTF(loader, opts.charUrl || CHAR_URL),
+    _loadGLTF(loader, opts.animUrl || ANIM_URL),
+  ]);
+  canonRig(rig);
+  canonRig(animPack);
+
+  const clips = animPack.anims.map(_rotOnly).filter((c) => c.tracks.length);
+  const view = new PlayerView(rig, clips, opts.height || 1.72);
+  scene.add(view.root);
+
+  const sim = new PlayerSim(opts);
+
+  const missing = Object.values(STATES).map((s) => s.clip).filter((c, i, a) =>
+    a.indexOf(c) === i && !view.actions[c]);
+  if (missing.length) console.warn('player: state machine wants clips that did not bind:', missing);
+
+  return {
+    sim,
+    view,
+    /** Convenience: step the sim then push it to the rig. */
+    step(dt, t, input, wind) {
+      sim.step(dt, t, input, wind);
+      view.sync(sim, dt);
+      return sim.state;
+    },
+  };
+}
+
+/**
+ * The `Player` contract factory (contracts.js) — this is the one main.js calls.
+ * Drop-in for createPlaceholderPlayer(scene, world, cameraRig): same first three args, so boot()
+ * only changes which function it calls. Everything the player needs per frame it pulls itself, so
+ * `update(dt, t)` matches the contract's signature exactly.
+ *
+ * @param {THREE.Object3D} scene
+ * @param {object} world      contracts World — `heightAt(x,z)` clamps the player to the ground
+ * @param {object} cameraRig  contracts Camera — `yaw` is what WASD is relative to
+ * @param {object} [opts]     {wind, interact, start, facing, height, tune, charUrl, animUrl}
+ * @returns {Promise<object>} satisfies checkContract('player', …)
+ */
+export async function createPlayer(scene, world, cameraRig, opts = {}) {
+  const p = await loadPlayer(scene, {
+    ...opts,
+    groundAt: world && world.heightAt ? (x, z) => world.heightAt(x, z) : undefined,
+    start: opts.start || { x: 0, y: 0, z: 6 },
+  });
+  const keyboard = new KeyboardInput();
+  const { sim, view } = p;
+
+  return {
+    get pos() { return sim.pos; },
+    get carrying() { return sim.carrying; },
+    set carrying(v) { sim.carrying = v; },
+    get busy() { return sim.busy; },
+
+    /** @param {number} dt @param {number} t — main.js's fixed-dt loop drives this */
+    update(dt, t) {
+      const input = keyboard.read(cameraRig ? cameraRig.yaw || 0 : 0);
+      sim.step(dt, t, input, opts.wind);
+      if (opts.interact) opts.interact.step(dt, t, sim, keyboard.holding);
+      view.sync(sim, dt);
+    },
+
+    /** The Object3D to follow/frame. Lane A's camera wants this, not the raw rig. */
+    get object() { return view.root; },
+    sim,
+    view,
+    keyboard,
+    dispose() { keyboard.dispose(); view.dispose(); },
+  };
+}
+
+/**
+ * Keyboard → the sim's input shape. Camera yaw comes from Lane A's camera each frame.
+ * Kept out of PlayerSim so the sim stays headless.
+ */
+export class KeyboardInput {
+  constructor(target = window) {
+    this.keys = new Set();
+    this._down = (e) => {
+      this.keys.add(e.code);
+      if (/^(Arrow|Space)/.test(e.code)) e.preventDefault();
+    };
+    this._up = (e) => this.keys.delete(e.code);
+    target.addEventListener('keydown', this._down);
+    target.addEventListener('keyup', this._up);
+    this._target = target;
+  }
+
+  get holding() { return this.keys.has('KeyE'); }
+
+  /** @param {number} camYaw radians */
+  read(camYaw = 0) {
+    const k = this.keys;
+    const x = (k.has('KeyD') || k.has('ArrowRight') ? 1 : 0) - (k.has('KeyA') || k.has('ArrowLeft') ? 1 : 0);
+    const z = (k.has('KeyW') || k.has('ArrowUp') ? 1 : 0) - (k.has('KeyS') || k.has('ArrowDown') ? 1 : 0);
+    return { x, z, run: k.has('ShiftLeft') || k.has('ShiftRight'), camYaw };
+  }
+
+  dispose() {
+    this._target.removeEventListener('keydown', this._down);
+    this._target.removeEventListener('keyup', this._up);
+  }
+}

web/world/js/player.sim.js

@@ -0,0 +1,246 @@
+/**
+ * player.sim.js — the small person's deterministic core.  (Lane D)
+ *
+ * Zero imports, on purpose. PLAN3D §0 requires the sim to be fast-forwardable in selftest with a
+ * fixed dt and no renderer, so nothing in here touches THREE, the DOM, rAF, Date.now() or
+ * Math.random(). `step(dt, t, …)` is the entire clock: same inputs → same trace, every run.
+ *
+ * player.js owns the view (rig, clips, camera). This file owns the truth: where the person is,
+ * what state they're in, and what the wind is doing to them.
+ */
+
+/**
+ * The state machine, as a table (PLAN3D §5-D.5 asks for a table test).
+ *  clip   — clip name in player_anims.glb
+ *  locked — movement input is ignored, and `player.busy` is true
+ *  secs   — timed states auto-advance to `next` after this long
+ * Invariant the selftest enforces: every locked state either has a `next` (so it drains on its own)
+ * or is released by an external actor. `busy` is the only externally-released state — interact.js
+ * both enters and leaves it, so a dropped release can't strand the player.
+ */
+export const STATES = {
+  idle:    { clip: 'Idle',          locked: false, loop: true },
+  walk:    { clip: 'Walk',          locked: false, loop: true },
+  run:     { clip: 'Run',           locked: false, loop: true },
+  busy:    { clip: 'Idle',          locked: true,  loop: true, releasedBy: 'interact' },
+  stagger: { clip: 'Reaction',      locked: true,  loop: false, secs: 0.9, next: 'idle' },
+  knocked: { clip: 'Falling',       locked: true,  loop: false, secs: 1.4, next: 'getup' },
+  getup:   { clip: 'CrouchToStand', locked: true,  loop: false, secs: 1.3, next: 'idle' },
+};
+
+/**
+ * Tuning. Ported from the 2D prototype's shape (prototype/game.js:250-252), retuned to metres and
+ * m/s per PLAN3D §1 ("port the behaviour, retune the constants").
+ */
+export const TUNE = {
+  walkSpeed: 1.5,       // m/s — a person crossing a 30 m yard, unhurried
+  runSpeed: 4.4,        // m/s — shift
+  accel: 16,            // m/s² toward the wanted velocity
+  turnRate: 11,         // rad/s — facing chases the movement direction
+
+  // prototype: slow = 1 - min(0.35, wind.speed / 160). Its wind ran ~4 (calm) to ~38 (gust peak),
+  // which is already m/s-shaped, so the curve ports across directly.
+  slowMax: 0.35,
+  slowRef: 160,
+
+  // prototype: push = ws*ws*0.55 — "wind pressure goes with speed², gusts have teeth"; and shove
+  // only applied while wind.gust > 8, never from the base wind.
+  shoveK: 0.0035,       // shove accel (m/s²) = shoveK · ws²  → ~3.2 m/s² in a 30 m/s gust
+  shoveGustMin: 8,      // m/s of gust (over baseline) before the wind can push you at all
+  shoveDamp: 2.5,       // 1/s foot-friction bleed → terminal drift ≈ shoveK·ws²/shoveDamp
+
+  // Baseline tracker: contracts.js exposes wind.sample() (total) and wind.gustTelegraph() (before
+  // the gust), but nothing reports gust magnitude DURING the hold. Rather than widen Lane C's
+  // contract, we recover it: a slow EMA of local wind speed is the base curve, and everything above
+  // it is gust. Self-calibrating to whatever storm JSON Lane C authors.
+  baseTrack: 0.25,      // 1/s — ~4 s memory; gust holds are ~1.7 s, so they read as gust, not base
+
+  // Knockdown mirrors the sail's failure rule (PLAN3D §1: break after 0.4 s SUSTAINED overload) —
+  // same verb for cloth and for people, so the player reads one language.
+  knockWind: 30,        // m/s sustained local wind → you go down
+  knockSustain: 0.5,    // s above knockWind before it happens
+  knockBleed: 2,        // exposure drains this many × faster than it fills
+  pitchSecs: 0.35,      // s for the body to swing down / back up (view reads sim.pitch)
+};
+
+const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+
+/** Shortest-arc angle step from a toward b, at most `maxStep` radians. */
+function turnToward(a, b, maxStep) {
+  let d = (b - a) % (Math.PI * 2);
+  if (d > Math.PI) d -= Math.PI * 2;
+  if (d < -Math.PI) d += Math.PI * 2;
+  return a + clamp(d, -maxStep, maxStep);
+}
+
+export class PlayerSim {
+  /**
+   * @param {object}   [opts]
+   * @param {object}   [opts.start]     {x,y,z} spawn, metres
+   * @param {function} [opts.groundAt]  (x,z) -> y. Lane A's world.js provides the real one.
+   * @param {object}   [opts.tune]      overrides for TUNE
+   */
+  constructor(opts = {}) {
+    const s = opts.start || { x: 0, y: 0, z: 0 };
+    this.pos = { x: s.x, y: s.y || 0, z: s.z };
+    this.vel = { x: 0, z: 0 };          // intended (input-driven) velocity
+    this.shove = { x: 0, z: 0 };        // wind-driven velocity, decays through foot friction
+    this.facing = opts.facing || 0;     // yaw; models face +Z at 0 (90sDJsim convention)
+
+    this.state = 'idle';
+    this.stateT = 0;
+    this.carrying = null;               // contract: player.carrying — one item, hands-full rule
+    this.events = [];                   // {type:'state'|'drop'|'knockdown', …} drained by the view/HUD
+
+    this.exposure = 0;                  // s spent above knockWind
+    this.windBase = 0;                  // EMA baseline (see TUNE.baseTrack)
+    this.windSpeed = 0;                 // last sampled local speed, m/s — HUD/audio read this
+    this.gust = 0;                      // windSpeed - windBase, clamped ≥0
+    this.pitch = 0;                     // 0 upright … 1 flat on the ground
+    this.knockDir = { x: 0, z: 1 };     // which way the body went down
+
+    this.groundAt = opts.groundAt || (() => 0);
+    this.tune = { ...TUNE, ...(opts.tune || {}) };
+  }
+
+  /** contract: player.busy */
+  get busy() { return !!STATES[this.state].locked; }
+  get clip() { return STATES[this.state].clip; }
+  get speed() { return Math.hypot(this.vel.x, this.vel.z); }
+
+  setState(s, t = 0) {
+    if (this.state === s) return false;
+    if (!STATES[s]) throw new Error(`player: unknown state ${s}`);
+    this.state = s;
+    this.stateT = 0;
+    this.events.push({ type: 'state', state: s, t });
+    return true;
+  }
+
+  /** Drop whatever's carried (knockdown does this per PLAN3D §5-D.3). */
+  drop(t = 0) {
+    if (!this.carrying) return null;
+    const item = this.carrying;
+    this.carrying = null;
+    this.events.push({ type: 'drop', item, t });
+    return item;
+  }
+
+  /** @returns {boolean} true if the pickup was accepted (hands-full rule). */
+  pickUp(item, t = 0) {
+    if (this.carrying || this.busy) return false;
+    this.carrying = item;
+    this.events.push({ type: 'pickup', item, t });
+    return true;
+  }
+
+  /** Light hit — a glancing debris clip. Ignored if already down. */
+  staggerHit(t = 0) {
+    if (this.state === 'knocked' || this.state === 'getup') return false;
+    return this.setState('stagger', t);
+  }
+
+  /**
+   * Put the player on the ground. debris.js (Lane C) calls this on a solid hit; the sim calls it
+   * itself on sustained extreme wind.
+   * @param {number} [dirX] @param {number} [dirZ] which way to fall — defaults to downwind/facing.
+   */
+  knockdown(t = 0, dirX, dirZ) {
+    if (this.state === 'knocked' || this.state === 'getup') return false;
+    let x = dirX, z = dirZ;
+    if (x === undefined || (x === 0 && z === 0)) { x = Math.sin(this.facing); z = Math.cos(this.facing); }
+    const m = Math.hypot(x, z) || 1;
+    this.knockDir = { x: x / m, z: z / m };
+    this.setState('knocked', t);
+    this.exposure = 0;
+    this.vel.x = this.vel.z = 0;
+    this.drop(t);
+    this.events.push({ type: 'knockdown', t, dir: { ...this.knockDir } });
+    return true;
+  }
+
+  /**
+   * @param {number} dt   fixed step, seconds
+   * @param {number} t    storm time, seconds
+   * @param {object} input {x,z} camera-relative axes in -1..1, {run}, {camYaw} radians
+   * @param {object} wind  contracts wind ({sample(pos,t)->Vector3}) or a plain {x,z} vector
+   */
+  step(dt, t, input = {}, wind = null) {
+    const T = this.tune;
+    this.stateT += dt;
+
+    // --- local wind, and how much of it is gust ---
+    let wx = 0, wz = 0;
+    if (wind) {
+      const v = typeof wind.sample === 'function' ? wind.sample(this.pos, t) : wind;
+      if (v) { wx = v.x || 0; wz = v.z || 0; }
+    }
+    const ws = Math.hypot(wx, wz);
+    this.windSpeed = ws;
+    this.windBase += (ws - this.windBase) * clamp(dt * T.baseTrack, 0, 1);
+    this.gust = Math.max(0, ws - this.windBase);
+
+    // --- sustained extreme wind puts you down (same rule as a sail corner letting go) ---
+    if (ws > T.knockWind) this.exposure += dt;
+    else this.exposure = Math.max(0, this.exposure - dt * T.knockBleed);
+    if (this.exposure >= T.knockSustain) this.knockdown(t, wx, wz);
+
+    const st = STATES[this.state];
+
+    // --- movement ---
+    const slow = 1 - Math.min(T.slowMax, ws / T.slowRef);   // prototype: rain + wind slow you
+    let wantX = 0, wantZ = 0;
+    if (!st.locked) {
+      const ix = input.x || 0, iz = input.z || 0;
+      const mag = Math.hypot(ix, iz);
+      if (mag > 1e-3) {
+        // camera-relative: at camYaw 0 three.js looks down -Z, so forward = (-sin, -cos).
+        const cy = input.camYaw || 0;
+        const sin = Math.sin(cy), cos = Math.cos(cy);
+        const nx = ix / mag, nz = iz / mag;
+        const dx = nx * cos - nz * sin;
+        const dz = -nx * sin - nz * cos;
+        const target = (input.run ? T.runSpeed : T.walkSpeed) * Math.min(1, mag) * slow;
+        wantX = dx * target; wantZ = dz * target;
+        this.facing = turnToward(this.facing, Math.atan2(dx, dz), T.turnRate * dt);
+      }
+    }
+    // approach the wanted velocity at a fixed accel (both directions — stopping is the same law)
+    const dvx = wantX - this.vel.x, dvz = wantZ - this.vel.z;
+    const dvm = Math.hypot(dvx, dvz);
+    const step = T.accel * dt;
+    if (dvm <= step || dvm < 1e-6) { this.vel.x = wantX; this.vel.z = wantZ; }
+    else { this.vel.x += dvx / dvm * step; this.vel.z += dvz / dvm * step; }
+
+    // --- gust shove: pressure ∝ speed², gust only, never while you're already on the ground ---
+    const grounded = this.state === 'knocked' || this.state === 'getup';
+    if (!grounded && this.gust > T.shoveGustMin && ws > 1e-3) {
+      const a = T.shoveK * ws * ws;
+      this.shove.x += (wx / ws) * a * dt;
+      this.shove.z += (wz / ws) * a * dt;
+    }
+    const bleed = Math.exp(-T.shoveDamp * dt);
+    this.shove.x *= bleed; this.shove.z *= bleed;
+
+    this.pos.x += (this.vel.x + this.shove.x) * dt;
+    this.pos.z += (this.vel.z + this.shove.z) * dt;
+    this.pos.y = this.groundAt(this.pos.x, this.pos.z);
+
+    // --- body pitch: the sim owns it so a knockdown is deterministic and falls DOWNWIND,
+    //     which a canned clip can't do. player.js just reads sim.pitch + sim.knockDir. ---
+    const wantPitch = this.state === 'knocked' ? 1
+      : this.state === 'getup' ? Math.max(0, 1 - this.stateT / (st.secs || 1))
+      : 0;
+    const pstep = dt / T.pitchSecs;
+    this.pitch = clamp(this.pitch + clamp(wantPitch - this.pitch, -pstep, pstep), 0, 1);
+
+    // --- locomotion state from actual speed (so shove/slow can't desync the feet) ---
+    if (!st.locked) {
+      const sp = this.speed;
+      this.setState(sp < 0.15 ? 'idle' : sp > T.walkSpeed * 1.35 ? 'run' : 'walk', t);
+    } else if (st.secs && this.stateT >= st.secs && st.next) {
+      this.setState(st.next, t);
+    }
+    return this.state;
+  }
+}

web/world/js/rigging.js

@@ -0,0 +1,157 @@
+/**
+ * rigging.js — prep-phase rig selection and hardware economy.  [Lane B]
+ *
+ * The money half of the sail. Ports the prototype's economy verbatim ($80
+ * budget, $5/$15/$30 hardware, $15 spare) and adds the state machine around it:
+ * which anchors are rigged, what hangs at each corner, how tight, how many
+ * spares in the bag.
+ *
+ * Kept three-free and DOM-free like sail.js so it is testable headless. The
+ * picking/DOM layer is deliberately NOT here yet — it needs Lane A's camera and
+ * anchor markers, which do not exist at time of writing; see createRiggingUI at
+ * the bottom for the seam it will plug into.
+ */
+
+import { HARDWARE, START_BUDGET, SPARE_COST } from './contracts.js';
+import { orderRing, TENSION_MIN, TENSION_MAX } from './sail.js';
+
+export { START_BUDGET, SPARE_COST };
+export const MAX_CORNERS = 4;
+export const DEFAULT_TENSION = 1.0;
+
+const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+
+const OK = { ok: true };
+const fail = (reason) => ({ ok: false, reason });
+
+export class RiggingSession {
+  /**
+   * @param {object} opts
+   * @param {Array}  opts.anchors  world.anchors — [{id, pos, type, sway?}]
+   * @param {number} opts.budget   starting cash
+   */
+  constructor({ anchors = [], budget = START_BUDGET } = {}) {
+    this.anchors = anchors;
+    this.budget = budget;
+    this.tension = DEFAULT_TENSION;
+    this.spares = 0;
+    /** @type {{anchorId: string, hw: object}[]} — ring-ordered once 4 are rigged */
+    this.picks = [];
+  }
+
+  get spent() { return START_BUDGET - this.budget; }
+  get canStart() { return this.picks.length === MAX_CORNERS; }
+  isRigged(anchorId) { return this.picks.some((p) => p.anchorId === anchorId); }
+  pickOf(anchorId) { return this.picks.find((p) => p.anchorId === anchorId) || null; }
+
+  /** Charge (or refund, when amount is negative) against the budget. */
+  _spend(amount) {
+    if (this.budget - amount < 0) return false;
+    this.budget -= amount;
+    return true;
+  }
+
+  /** Rig a corner at an anchor, starting on the cheapest hardware (prototype). */
+  rig(anchorId) {
+    const a = this.anchors.find((x) => x.id === anchorId);
+    if (!a) return fail('no such anchor');
+    if (this.isRigged(anchorId)) return fail('already rigged');
+    if (this.picks.length >= MAX_CORNERS) return fail('a sail has four corners');
+    if (!this._spend(HARDWARE[0].cost)) return fail('not enough budget');
+    this.picks.push({ anchorId, hw: HARDWARE[0] });
+    this._reorder();
+    return OK;
+  }
+
+  /**
+   * Unrig a corner and refund its hardware. Not in the prototype (which had no
+   * way back from a misclick) but it is a pure refund, so it costs the economy
+   * nothing and saves the player a restart.
+   */
+  unrig(anchorId) {
+    const i = this.picks.findIndex((p) => p.anchorId === anchorId);
+    if (i < 0) return fail('not rigged');
+    this.budget += this.picks[i].hw.cost;
+    this.picks.splice(i, 1);
+    return OK;
+  }
+
+  /** Cycle a corner's hardware to the next tier, paying (or refunding) the difference. */
+  cycleHardware(anchorId) {
+    const p = this.pickOf(anchorId);
+    if (!p) return fail('not rigged');
+    const next = HARDWARE[(HARDWARE.indexOf(p.hw) + 1) % HARDWARE.length];
+    if (!this._spend(next.cost - p.hw.cost)) return fail('not enough budget');
+    p.hw = next;
+    return OK;
+  }
+
+  setHardware(anchorId, hw) {
+    const p = this.pickOf(anchorId);
+    if (!p) return fail('not rigged');
+    if (!HARDWARE.includes(hw)) return fail('unknown hardware');
+    if (!this._spend(hw.cost - p.hw.cost)) return fail('not enough budget');
+    p.hw = hw;
+    return OK;
+  }
+
+  /** 0.6 loose (soaks gusts, flogs) .. 1.4 drum tight (no flap, shock-loads). */
+  setTension(v) {
+    this.tension = clamp(v, TENSION_MIN, TENSION_MAX);
+    return this.tension;
+  }
+
+  /** Spares are what Lane D's hold-E re-rig consumes mid-storm. */
+  setSpares(n) {
+    n = Math.max(0, Math.floor(n));
+    const delta = (n - this.spares) * SPARE_COST;
+    if (!this._spend(delta)) return fail('not enough budget');
+    this.spares = n;
+    return OK;
+  }
+
+  /**
+   * Ring-order the picks by angle around their ground-plane centroid, so corner
+   * i of the cloth grid always maps to a neighbouring anchor. Without it,
+   * picking anchors in a silly order knots the sail through itself.
+   */
+  _reorder() {
+    if (this.picks.length < MAX_CORNERS) return;
+    const byId = new Map(this.picks.map((p) => [p.anchorId, p]));
+    const ring = orderRing(this.picks.map((p) => this.anchors.find((a) => a.id === p.anchorId)));
+    this.picks = ring.map((a) => byId.get(a.id));
+  }
+
+  /** Hand the finished rig to the sim. Mirrors contracts.js sailRig.attach(). */
+  commit(rig) {
+    if (!this.canStart) throw new Error(`sail needs ${MAX_CORNERS} corners, have ${this.picks.length}`);
+    return rig.attach(this.picks.map((p) => p.anchorId), this.picks.map((p) => p.hw), this.tension);
+  }
+
+  /** Everything the HUD needs to draw the prep panel, in one read. */
+  get summary() {
+    return {
+      budget: this.budget,
+      spent: this.spent,
+      tension: this.tension,
+      spares: this.spares,
+      canStart: this.canStart,
+      corners: this.picks.map((p) => ({ anchorId: p.anchorId, hw: p.hw.name, rating: p.hw.rating, cost: p.hw.cost })),
+      weakest: this.picks.length
+        ? this.picks.reduce((w, p) => (p.hw.rating < w.hw.rating ? p : w)).anchorId
+        : null,
+    };
+  }
+}
+
+/**
+ * Prep-phase picking UI.
+ *
+ * Deliberately unimplemented: it needs Lane A's camera, renderer canvas and
+ * anchor markers to raycast against, none of which exist yet. RiggingSession
+ * above holds all the rules and is fully tested, so this stays a thin
+ * click-to-session adapter once M0 lands. See THREADS.md.
+ */
+export async function createRiggingUI() {
+  throw new Error('rigging UI lands once Lane A has a camera and anchor markers — see THREADS.md');
+}

web/world/js/rigging.selftest.js

@@ -0,0 +1,195 @@
+/**
+ * rigging.selftest.js — assert suite for the prep-phase economy.  [Lane B]
+ *
+ * Same shape as sail.selftest.js: exports RIGGING_TESTS as [name, fn] pairs so
+ * one set of asserts runs under both Lane A's selftest.html (via
+ * js/tests/b.test.js) and node.
+ */
+
+import { RiggingSession } from './rigging.js';
+import { SailRig, TENSION_MIN, TENSION_MAX } from './sail.js';
+import { HARDWARE, START_BUDGET, SPARE_COST } from './contracts.js';
+
+const [CARABINER, SHACKLE, RATED] = HARDWARE;
+
+/** Lane A's real yard (THREADS: "yard layout is now FACT"), trimmed to what the economy needs. */
+export const ANCHORS = [
+  { id: 'h1', type: 'house', pos: { x: -5, y: 2.6, z: -9.9 } },
+  { id: 'h2', type: 'house', pos: { x: 0, y: 2.6, z: -9.9 } },
+  { id: 'h3', type: 'house', pos: { x: 5, y: 2.6, z: -9.9 } },
+  { id: 't1', type: 'tree', pos: { x: -9, y: 3.2, z: 2 } },
+  { id: 't2', type: 'tree', pos: { x: 8, y: 3.1, z: -2 } },
+  { id: 'p1', type: 'post', pos: { x: -6.4, y: 3.9, z: 7.4 } },
+  { id: 'p2', type: 'post', pos: { x: 5.3, y: 3.9, z: 8 } },
+].map((a) => ({ ...a, sway: () => a.pos }));
+
+const session = () => new RiggingSession({ anchors: ANCHORS });
+
+const TESTS = [];
+const test = (name, fn) => TESTS.push([name, fn]);
+const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
+
+test('rigging four corners charges the cheapest hardware each', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) assert(s.rig(id).ok, `rig ${id} failed`);
+  assert(s.budget === START_BUDGET - 4 * CARABINER.cost, `budget $${s.budget}`);
+  assert(s.canStart, 'four corners should be startable');
+  return `$${START_BUDGET} -> $${s.budget} after four carabiners`;
+});
+
+test('a sail has four corners, not five', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);
+  const r = s.rig('t1');
+  assert(!r.ok && r.reason === 'a sail has four corners', `fifth corner allowed: ${JSON.stringify(r)}`);
+  assert(s.budget === START_BUDGET - 4 * CARABINER.cost, 'refused corner should not be charged');
+  return 'fifth pick refused and not charged';
+});
+
+test('hardware cycles up, charging only the difference', () => {
+  const s = session();
+  s.rig('h1');
+  assert(s.cycleHardware('h1').ok, 'cycle to shackle failed');
+  assert(s.pickOf('h1').hw === SHACKLE, 'expected shackle');
+  assert(s.budget === START_BUDGET - SHACKLE.cost, `budget $${s.budget} should be $${START_BUDGET - SHACKLE.cost}`);
+  s.cycleHardware('h1');
+  assert(s.pickOf('h1').hw === RATED, 'expected rated shackle');
+  assert(s.budget === START_BUDGET - RATED.cost, `budget $${s.budget}`);
+  return `carabiner -> shackle -> rated, paid $${RATED.cost} total`;
+});
+
+test('cycling past the top tier wraps and refunds', () => {
+  const s = session();
+  s.rig('h1');
+  s.cycleHardware('h1'); s.cycleHardware('h1'); // -> rated
+  s.cycleHardware('h1');                        // -> wraps to carabiner
+  assert(s.pickOf('h1').hw === CARABINER, 'expected wrap back to carabiner');
+  assert(s.budget === START_BUDGET - CARABINER.cost, `budget $${s.budget} — wrap should refund the difference`);
+  return `wrapped and refunded back to $${s.budget}`;
+});
+
+test('unrig refunds exactly what the corner cost', () => {
+  const s = session();
+  s.rig('h1');
+  s.cycleHardware('h1'); s.cycleHardware('h1'); // rated, $30
+  assert(s.unrig('h1').ok, 'unrig failed');
+  assert(s.budget === START_BUDGET, `budget $${s.budget} should be back to $${START_BUDGET}`);
+  assert(!s.isRigged('h1'), 'h1 should be free again');
+  return 'full refund, no leak';
+});
+
+test('spares cost real money and refund', () => {
+  const s = session();
+  assert(s.setSpares(1).ok, 'buying a spare failed');
+  assert(s.budget === START_BUDGET - SPARE_COST, `budget $${s.budget}`);
+  s.setSpares(0);
+  assert(s.budget === START_BUDGET && s.spares === 0, 'selling the spare back should restore budget');
+  return `spare costs $${SPARE_COST}, refunds clean`;
+});
+
+test('budget is a real wall', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);   // $20, $60 left
+  s.cycleHardware('h1'); s.cycleHardware('h1');           // -> rated, $25 more, $35 left
+  s.cycleHardware('h3'); s.cycleHardware('h3');           // -> rated, $25 more, $10 left
+  s.cycleHardware('p1');                                  // -> shackle, $10, $0 left
+  const broke = s.cycleHardware('p2');
+  assert(!broke.ok && broke.reason === 'not enough budget', `overspend allowed: ${JSON.stringify(broke)}`);
+  assert(s.budget === 0, `budget $${s.budget}`);
+  assert(s.pickOf('p2').hw === CARABINER, 'refused upgrade should not have applied');
+  return 'refused the upgrade that would have gone negative';
+});
+
+// DESIGN.md: "good hardware everywhere is unaffordable. You *will* field one
+// dodgy corner — the game is choosing which one." If this ever passes, the
+// central economic tension of the game is gone and the budget is decoration.
+// contracts.js's HARDWARE comment names this as the shape retuning had to keep.
+test('you cannot afford good hardware on all four corners', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);
+  let upgraded = 0;
+  for (const id of ['h1', 'h3', 'p1', 'p2']) if (s.setHardware(id, RATED).ok) upgraded++;
+  assert(upgraded < 4, `all four corners got rated shackles with $${START_BUDGET} — no compromise left to make`);
+  assert(upgraded >= 2, `only ${upgraded} rated corners affordable — budget may be too tight to be interesting`);
+  return `$${START_BUDGET} buys ${upgraded}/4 rated corners, then you are choosing your weak link`;
+});
+
+test('picks come back ring-ordered however you click them', () => {
+  const s = session();
+  // deliberately crossing order: two diagonals first
+  for (const id of ['h1', 'p2', 'h3', 'p1']) s.rig(id);
+  const ids = s.picks.map((p) => p.anchorId);
+  // a valid ring puts h1 opposite p2 (they are diagonal across the yard)
+  const opposite = ids[(ids.indexOf('h1') + 2) % 4];
+  assert(opposite === 'p2', `h1 should sit opposite p2 in the ring, got ${ids.join(',')}`);
+  return `clicked h1,p2,h3,p1 -> ring ${ids.join(' -> ')}`;
+});
+
+test('tension clamps to the rigging range', () => {
+  const s = session();
+  assert(s.setTension(99) === TENSION_MAX, 'over-tight should clamp');
+  assert(s.setTension(0) === TENSION_MIN, 'over-loose should clamp');
+  s.setTension(1.15);
+  assert(s.tension === 1.15, 'in-range tension should pass through');
+  return `clamped to ${TENSION_MIN}..${TENSION_MAX}`;
+});
+
+test('commit hands a working rig to the sim', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);
+  s.setHardware('h1', RATED);
+  s.setTension(1.1);
+  const rig = s.commit(new SailRig({ anchors: ANCHORS }));
+  assert(rig.rigged, 'rig should be rigged');
+  assert(rig.corners.length === 4, 'rig should have four corners');
+  assert(rig.tension === 1.1, `rig tension ${rig.tension}`);
+  assert(rig.corners.find((c) => c.anchorId === 'h1').hw === RATED, 'h1 should have carried its rated shackle into the sim');
+  const wind = { sample: () => ({ x: 0, y: 0, z: 12 }) };
+  for (let i = 0; i < 240; i++) rig.step(1 / 60, wind, i / 60);
+  assert(rig.corners.every((c) => Number.isFinite(c.load)), 'committed rig went NaN');
+  return `committed and stepped 4 s clean over the real yard, max load ${(rig.maxLoad() / 1000).toFixed(2)} kN`;
+});
+
+test('commit refuses an unfinished rig', () => {
+  const s = session();
+  s.rig('h1'); s.rig('h3');
+  let threw = false;
+  try { s.commit(new SailRig({ anchors: ANCHORS })); } catch { threw = true; }
+  assert(threw, 'committing two corners should throw');
+  return 'two corners refused';
+});
+
+test('summary names the weak link for the HUD', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);
+  s.setHardware('h1', RATED); s.setHardware('h3', SHACKLE); s.setHardware('p1', SHACKLE);
+  const sum = s.summary;
+  assert(sum.weakest === 'p2', `weakest should be the lone carabiner p2, got ${sum.weakest}`);
+  assert(sum.corners.length === 4, 'summary should list four corners');
+  return `weak link flagged: ${sum.weakest}, $${sum.budget} left`;
+});
+
+export const RIGGING_TESTS = TESTS;
+
+export function runRiggingSelftest() {
+  const results = TESTS.map(([name, fn]) => {
+    try { return { name, pass: true, detail: fn() || '' }; }
+    catch (e) { return { name, pass: false, detail: e.message }; }
+  });
+  return { pass: results.every((r) => r.pass), results };
+}
+
+function report(out) {
+  const lines = out.results.map(
+    (r) => `${r.pass ? 'PASS' : 'FAIL'}  ${r.name}${r.detail ? `\n        ${r.detail}` : ''}`
+  );
+  return `${lines.join('\n')}\n\n${out.pass ? 'ALL GREEN' : 'FAILURES'} — ${out.results.filter((r) => r.pass).length}/${out.results.length}`;
+}
+
+if (typeof process !== 'undefined' && process.versions?.node && import.meta.filename === process.argv[1]) {
+  const out = runRiggingSelftest();
+  console.log(report(out));
+  process.exit(out.pass ? 0 : 1);
+}
+
+export { report };

web/world/js/sail.js

@@ -0,0 +1,635 @@
+/**
+ * sail.js — shade sail cloth simulation, corner loads, hardware failure.  [Lane B]
+ *
+ * A 3D verlet cloth on a bilinear patch between 4 anchors. Wind pressure is
+ * applied per FACE, not per node, which is the whole point: a twisted (hypar)
+ * sail turns most of its faces edge-on to the wind and sheds load, while a flat
+ * one presents every face square-on and catches everything. That difference is
+ * the game's thesis and it is asserted in sail.selftest.js.
+ *
+ * Units are SI throughout: metres, kilograms, seconds, newtons. Corner loads
+ * come out in real newtons and hardware ratings are real working load limits,
+ * so a 5x5 m sail in a 34 m/s storm genuinely puts ~1-4 kN on a corner — which
+ * is genuinely why real shade sails use 3 kN+ shackles.
+ *
+ * The sim core holds no THREE types: nodes are plain Float64Arrays, so the hot
+ * loop allocates nothing, replays bit-for-bit, and runs headless under node
+ * (see sail.selftest.js) as well as in Lane A's selftest.html. three.js only
+ * appears in createSailView(), which is imported lazily.
+ */
+
+import { Emitter, FIXED_DT, HARDWARE } from './contracts.js';
+
+export { HARDWARE };
+
+// ---------- sim tunables ----------
+const SIM_DT = FIXED_DT;      // sim always steps at a fixed rate; step() accumulates
+const MAX_SUBSTEPS = 5;       // spiral-of-death guard when the frame hitches
+const RELAX_ITERS = 5;        // FABRIC_K is calibrated against this; changing it rescales loads
+const GRAVITY = -9.81;
+
+// ---------- aerodynamics ----------
+// 0.5 * air density (1.225) * flat-plate drag coefficient (~1.4).
+// Newtons per m^2 of face area per (m/s)^2 of normal-on airflow.
+const PRESSURE_COEFF = 0.86;
+const TANGENT_COEFF = 0.02;   // skin friction dragging along the face
+const MAX_NORMAL_SPEED = 45;  // clamp on the normal-on component, m/s — stability in extreme gusts
+
+// ---------- fabric ----------
+const FABRIC_DENSITY = 0.32;  // kg/m^2, typical knitted shade cloth
+// Axial stiffness of one grid spring, N/m — roughly E*t*width/length for
+// knitted HDPE mesh. Fed to the solver as a compliance (1/k), not used to
+// convert stretch into force: see _measureLoads for why that distinction is
+// the whole ballgame.
+const FABRIC_K = 100000;
+const K_COMPRESS = 0.08;      // cloth resists stretch hard, compression barely (from prototype)
+const K_BEND = 0.04;
+const COMP_STRETCH = 1 / FABRIC_K;
+const COMP_COMPRESS = 1 / (FABRIC_K * K_COMPRESS);
+const COMP_BEND = 1 / (FABRIC_K * K_BEND);
+const VEL_DAMP = 0.995;       // light; relative-wind drag supplies the real damping
+
+// ---------- failure ----------
+const OVERLOAD_SECS = 0.4;    // prototype: 0.4 s sustained overload before it lets go
+const OVERLOAD_RECOVER = 2.0; // prototype: overload timer bleeds off at 2x
+const LOAD_TAU = 0.11;        // load meter smoothing time constant, s
+
+export const TENSION_MIN = 0.6;
+export const TENSION_MAX = 1.4;
+
+/**
+ * How much pre-strain the tension dial actually commands, per unit of dial.
+ * Dial 1.0 is neutral (rest length = as-cut), 1.4 is drum tight, 0.6 is loose.
+ *
+ * The prototype used `rest = rest / tension`, which on its 2D arbitrary scale
+ * was harmless. In real newtons it is not: it asks for 17% pre-strain at dial
+ * 1.2 and 29% at 1.4 — i.e. stretching an 18 m sail by three metres — and it
+ * put 68 kN on a corner of the real yard's biggest quad before any wind blew.
+ *
+ * 0.10 puts dial 1.4 at 4% pre-strain. Measured: it swings a 5x5 m rig's peak
+ * load 2.1x from loose to tight, so the dial is a real decision; and it redlines
+ * the yard's 192 m2 quad at 8.3 kN drum-tight, which blows even a rated shackle
+ * — correctly, because you cannot drum-tighten 192 m2 of cloth on $30 of
+ * hardware. The load bars show that during prep, which is where it should be
+ * learned.
+ */
+const PRE_STRAIN = 0.10;
+const TRIM_MIN = 0.85;
+const TRIM_MAX = 1.15;
+
+const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+
+/**
+ * Order 4 anchors into a non-self-intersecting ring by angle around their
+ * centroid, projected onto the ground plane. Ported from the prototype's
+ * orderRing; without it, picking corners in a silly order knots the sail.
+ */
+export function orderRing(anchors) {
+  const n = anchors.length;
+  let cx = 0, cz = 0;
+  for (const a of anchors) { cx += a.pos.x; cz += a.pos.z; }
+  cx /= n; cz /= n;
+  return [...anchors].sort(
+    (a, b) => Math.atan2(a.pos.z - cz, a.pos.x - cx) - Math.atan2(b.pos.z - cz, b.pos.x - cx)
+  );
+}
+
+export class SailRig {
+  /**
+   * @param {object}   opts
+   * @param {Array}    opts.anchors  world.anchors — see contracts.js Anchor
+   * @param {number}   opts.gridN    nodes per side (default 10)
+   * @param {number}   opts.porosity 0 = solid membrane, ~0.3 = knitted shade cloth (blows through, less load)
+   */
+  constructor({ anchors = [], gridN = 10, porosity = 0 } = {}) {
+    this.anchors = anchors;
+    this.N = gridN;
+    this.porosity = porosity;
+    this.corners = [];
+    /** Emits 'break' and 'repair' as {type, corner} — contracts.js SailRig. */
+    this.events = new Emitter();
+    this.tension = 1.0;
+    this.t = 0;
+    this.rigged = false;
+    this._acc = 0;
+    // scratch, reused every face to keep the hot loop allocation-free
+    this._probe = { x: 0, y: 0, z: 0 };
+  }
+
+  /**
+   * Rig the sail across 4 anchors.
+   * @param {string[]} anchorIds  4 anchor ids; reordered into a ring internally
+   * @param {object[]} hwChoices  hardware per anchor id, same order as anchorIds
+   * @param {number}   tension    0.6 (loose, flogs) .. 1.4 (drum tight, shock-loads)
+   */
+  attach(anchorIds, hwChoices, tension = 1.0) {
+    if (anchorIds.length !== 4) throw new Error(`sail needs exactly 4 corners, got ${anchorIds.length}`);
+
+    const picked = anchorIds.map((id) => {
+      const a = this.anchors.find((x) => x.id === id);
+      if (!a) throw new Error(`unknown anchor "${id}"`);
+      return a;
+    });
+    const hwById = new Map(anchorIds.map((id, i) => [id, hwChoices[i] || HARDWARE[0]]));
+
+    const ring = orderRing(picked);
+    this.tension = clamp(tension, TENSION_MIN, TENSION_MAX);
+    this.corners = ring.map((a) => ({
+      anchorId: a.id,
+      anchor: a,
+      hw: hwById.get(a.id),
+      load: 0,
+      peakLoad: 0,
+      overload: 0,
+      broken: false,
+      trim: 1.0,
+      loadVec: { x: 0, y: 0, z: 0 }, // reaction direction, not just magnitude — see _measureLoads
+    }));
+
+    this._build(ring);
+    this.rigged = true;
+    return this;
+  }
+
+  _build(ring) {
+    const N = this.N;
+    const nodeCount = N * N;
+    this.pos = new Float64Array(nodeCount * 3);
+    this.prev = new Float64Array(nodeCount * 3);
+    this.force = new Float64Array(nodeCount * 3);
+    this.invMass = new Float64Array(nodeCount);
+
+    // Bilinear patch across the 4 corners. Because the anchors sit at different
+    // heights, this initial surface is already a hypar — the sim just relaxes it.
+    const [c0, c1, c2, c3] = ring.map((a) => a.pos);
+    for (let v = 0; v < N; v++) {
+      for (let u = 0; u < N; u++) {
+        const fu = u / (N - 1), fv = v / (N - 1);
+        const i = (v * N + u) * 3;
+        for (let k = 0; k < 3; k++) {
+          const ax = ['x', 'y', 'z'][k];
+          const top = (1 - fu) * c0[ax] + fu * c1[ax];
+          const bot = (1 - fu) * c3[ax] + fu * c2[ax];
+          this.pos[i + k] = this.prev[i + k] = (1 - fv) * top + fv * bot;
+        }
+      }
+    }
+
+    const idx = (u, v) => v * N + u;
+    this.cornerIdx = [idx(0, 0), idx(N - 1, 0), idx(N - 1, N - 1), idx(0, N - 1)];
+
+    // springs: structural + shear carry load; bend only resists folding
+    this.springs = [];
+    const link = (a, b, kind) => {
+      const ax = a * 3, bx = b * 3;
+      const dx = this.pos[bx] - this.pos[ax];
+      const dy = this.pos[bx + 1] - this.pos[ax + 1];
+      const dz = this.pos[bx + 2] - this.pos[ax + 2];
+      this.springs.push({ a, b, restBase: Math.hypot(dx, dy, dz), rest: 0, kind });
+    };
+    for (let v = 0; v < N; v++) {
+      for (let u = 0; u < N; u++) {
+        if (u < N - 1) link(idx(u, v), idx(u + 1, v), 'struct');
+        if (v < N - 1) link(idx(u, v), idx(u, v + 1), 'struct');
+        if (u < N - 1 && v < N - 1) {
+          link(idx(u, v), idx(u + 1, v + 1), 'shear');
+          link(idx(u + 1, v), idx(u, v + 1), 'shear');
+        }
+        if (u < N - 2) link(idx(u, v), idx(u + 2, v), 'bend');
+        if (v < N - 2) link(idx(u, v), idx(u, v + 2), 'bend');
+      }
+    }
+
+    // XPBD Lagrange multipliers, one per spring, reset every substep
+    this.lambda = new Float64Array(this.springs.length);
+
+    // Springs meeting each corner, kept as {spring, index} so the load meter can
+    // look up each one's multiplier. Bend springs are included: the hardware
+    // physically carries every element that touches it, and leaving them out
+    // under-reports the reaction and breaks the statics balance.
+    this.cornerSprings = this.cornerIdx.map((ci) =>
+      this.springs
+        .map((s, si) => ({ s, si }))
+        .filter(({ s }) => s.a === ci || s.b === ci)
+    );
+
+    // triangles: wind acts per face, and coverage raycasts against these
+    this.tris = new Uint16Array((N - 1) * (N - 1) * 6);
+    let ti = 0;
+    for (let v = 0; v < N - 1; v++) {
+      for (let u = 0; u < N - 1; u++) {
+        const a = idx(u, v), b = idx(u + 1, v), c = idx(u + 1, v + 1), d = idx(u, v + 1);
+        this.tris[ti++] = a; this.tris[ti++] = b; this.tris[ti++] = c;
+        this.tris[ti++] = a; this.tris[ti++] = c; this.tris[ti++] = d;
+      }
+    }
+
+    // grid-space proximity of every node to each corner, for per-corner trim
+    this._cornerWeight = [];
+    for (let k = 0; k < 4; k++) {
+      const cu = [0, N - 1, N - 1, 0][k], cv = [0, 0, N - 1, N - 1][k];
+      const w = new Float64Array(nodeCount);
+      for (let v = 0; v < N; v++) {
+        for (let u = 0; u < N; u++) {
+          const dist = Math.hypot(u - cu, v - cv) / (N - 1);
+          w[idx(u, v)] = Math.max(0, 1 - dist);
+        }
+      }
+      this._cornerWeight.push(w);
+    }
+
+    this.area = this._surfaceArea();
+    const mass = (FABRIC_DENSITY * this.area) / nodeCount;
+    this.nodeMass = mass;
+    this.invMass.fill(1 / mass);
+
+    this._applyRestLengths();
+    this._repin(0);
+  }
+
+  /** Rest lengths shrink as the tension dial rises, modulated per corner by trim. */
+  _applyRestLengths() {
+    for (const s of this.springs) {
+      let wsum = 0, tsum = 0;
+      for (let k = 0; k < 4; k++) {
+        const w = this._cornerWeight[k][s.a] + this._cornerWeight[k][s.b];
+        wsum += w;
+        tsum += w * this.corners[k].trim;
+      }
+      const trim = wsum > 1e-9 ? tsum / wsum : 1;
+      s.rest = s.restBase * (1 - PRE_STRAIN * (this.tension * trim - 1));
+    }
+  }
+
+  /** Pinned corners are infinite-mass so springs stretch honestly against them. */
+  _repin(t) {
+    for (let k = 0; k < 4; k++) {
+      const c = this.corners[k];
+      const ci = this.cornerIdx[k];
+      if (c.broken) {
+        this.invMass[ci] = 1 / this.nodeMass; // freed node — flogging falls out of this
+        continue;
+      }
+      this.invMass[ci] = 0;
+      const p = this._anchorPos(c.anchor, t);
+      this.pos[ci * 3] = p.x; this.pos[ci * 3 + 1] = p.y; this.pos[ci * 3 + 2] = p.z;
+      this.prev[ci * 3] = p.x; this.prev[ci * 3 + 1] = p.y; this.prev[ci * 3 + 2] = p.z;
+    }
+  }
+
+  /**
+   * Where a corner is pinned right now. `sway(t)` is the ABSOLUTE world
+   * position, not an offset from `pos` (contracts.js Anchor; Lane A called this
+   * out in THREADS). House and post anchors return a constant; tree anchors
+   * wander, and that wander is dynamic load — the reason a tree is the scary
+   * anchor. The returned vector is shared and reused between calls, so read it
+   * immediately and never store it.
+   */
+  _anchorPos(a, t) {
+    return a.sway ? a.sway(t) : a.pos;
+  }
+
+  _surfaceArea() {
+    let total = 0;
+    for (let i = 0; i < this.tris.length; i += 3) {
+      const a = this.tris[i] * 3, b = this.tris[i + 1] * 3, c = this.tris[i + 2] * 3;
+      const e1x = this.pos[b] - this.pos[a], e1y = this.pos[b + 1] - this.pos[a + 1], e1z = this.pos[b + 2] - this.pos[a + 2];
+      const e2x = this.pos[c] - this.pos[a], e2y = this.pos[c + 1] - this.pos[a + 1], e2z = this.pos[c + 2] - this.pos[a + 2];
+      const nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+      total += Math.hypot(nx, ny, nz) * 0.5;
+    }
+    return total;
+  }
+
+  /**
+   * Advance the sim. Accumulates real time and burns it in fixed SIM_DT chunks,
+   * so a variable-rate render loop and a fast-forwarded selftest produce
+   * identical traces. Never reads a clock.
+   *
+   * @param {number} dt    seconds elapsed since last call
+   * @param {object} wind  { sample(pos, t) -> {x,y,z} }
+   * @param {number} t     world time, seconds
+   */
+  step(dt, wind, t) {
+    if (!this.rigged) return;
+    this._acc += dt;
+    let n = 0;
+    while (this._acc >= SIM_DT && n < MAX_SUBSTEPS) {
+      this._substep(SIM_DT, wind, this.t);
+      this._acc -= SIM_DT;
+      this.t += SIM_DT;
+      n++;
+    }
+    if (n === MAX_SUBSTEPS) this._acc = 0; // dropped frames: don't try to catch up
+  }
+
+  _substep(dt, wind, t) {
+    this._accumulateWind(wind, t, dt);
+    this._integrate(dt);
+    this.lambda.fill(0); // XPBD multipliers are per-substep
+    for (let i = 0; i < RELAX_ITERS; i++) this._relax(dt * dt);
+    this._pinCorners(t);
+    this._measureLoads(dt);
+    this._checkFailure(dt);
+  }
+
+  /** Wind force per FACE — the hypar mechanic lives here. */
+  _accumulateWind(wind, t, dt) {
+    const pos = this.pos, prev = this.prev, F = this.force;
+    F.fill(0);
+    const coeff = PRESSURE_COEFF * (1 - this.porosity);
+    const tanCoeff = TANGENT_COEFF * (1 - this.porosity);
+    const invDt = 1 / dt;
+    const probe = this._probe;
+
+    for (let i = 0; i < this.tris.length; i += 3) {
+      const ia = this.tris[i] * 3, ib = this.tris[i + 1] * 3, ic = this.tris[i + 2] * 3;
+
+      const e1x = pos[ib] - pos[ia], e1y = pos[ib + 1] - pos[ia + 1], e1z = pos[ib + 2] - pos[ia + 2];
+      const e2x = pos[ic] - pos[ia], e2y = pos[ic + 1] - pos[ia + 1], e2z = pos[ic + 2] - pos[ia + 2];
+      // |cross| is twice the area and its direction is the face normal
+      let nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+      const len = Math.hypot(nx, ny, nz);
+      if (len < 1e-9) continue;
+      const area = len * 0.5;
+      nx /= len; ny /= len; nz /= len;
+
+      probe.x = (pos[ia] + pos[ib] + pos[ic]) / 3;
+      probe.y = (pos[ia + 1] + pos[ib + 1] + pos[ic + 1]) / 3;
+      probe.z = (pos[ia + 2] + pos[ib + 2] + pos[ic + 2]) / 3;
+      const w = wind.sample(probe, t);
+
+      // Relative wind, not absolute: as the cloth accelerates downwind the load
+      // bleeds off by itself. This is what stops flogging from exploding.
+      const vx = (pos[ia] - prev[ia] + pos[ib] - prev[ib] + pos[ic] - prev[ic]) / 3 * invDt;
+      const vy = (pos[ia + 1] - prev[ia + 1] + pos[ib + 1] - prev[ib + 1] + pos[ic + 1] - prev[ic + 1]) / 3 * invDt;
+      const vz = (pos[ia + 2] - prev[ia + 2] + pos[ib + 2] - prev[ib + 2] + pos[ic + 2] - prev[ic + 2]) / 3 * invDt;
+      const rx = w.x - vx, ry = w.y - vy, rz = w.z - vz;
+
+      const d = clamp(rx * nx + ry * ny + rz * nz, -MAX_NORMAL_SPEED, MAX_NORMAL_SPEED);
+      // d*|d| rather than d^2: keeps the v^2 magnitude but points the force the
+      // way the wind is actually blowing. A sail is double-sided.
+      const p = coeff * area * d * Math.abs(d);
+
+      const tx = (rx - nx * d) * tanCoeff * area;
+      const ty = (ry - ny * d) * tanCoeff * area;
+      const tz = (rz - nz * d) * tanCoeff * area;
+
+      const fx = (nx * p + tx) / 3, fy = (ny * p + ty) / 3, fz = (nz * p + tz) / 3;
+      F[ia] += fx; F[ia + 1] += fy; F[ia + 2] += fz;
+      F[ib] += fx; F[ib + 1] += fy; F[ib + 2] += fz;
+      F[ic] += fx; F[ic + 1] += fy; F[ic + 2] += fz;
+    }
+  }
+
+  _integrate(dt) {
+    const pos = this.pos, prev = this.prev, F = this.force, im = this.invMass;
+    const dt2 = dt * dt;
+    for (let n = 0; n < im.length; n++) {
+      if (im[n] === 0) continue; // pinned
+      const i = n * 3;
+      for (let k = 0; k < 3; k++) {
+        const a = F[i + k] * im[n] + (k === 1 ? GRAVITY : 0);
+        const x = pos[i + k];
+        const nx = x + (x - prev[i + k]) * VEL_DAMP + a * dt2;
+        prev[i + k] = x;
+        pos[i + k] = nx;
+      }
+    }
+  }
+
+  /**
+   * XPBD constraint solve. The plain-PBD version of this is simpler, but its
+   * position corrections carry no force information — the leftover stretch
+   * after a fixed iteration count is solver error, not fabric strain, so
+   * reading load off it measures the solver. XPBD's Lagrange multiplier lambda
+   * is the real constraint impulse, so lambda/dt^2 is a genuine newton value
+   * and the corner reactions balance the applied wind by construction.
+   */
+  _relax(dt2) {
+    const pos = this.pos, im = this.invMass, lam = this.lambda;
+    for (let si = 0; si < this.springs.length; si++) {
+      const s = this.springs[si];
+      const wa = im[s.a], wb = im[s.b];
+      const w = wa + wb;
+      if (w === 0) continue; // both ends pinned
+      const ia = s.a * 3, ib = s.b * 3;
+      const dx = pos[ib] - pos[ia], dy = pos[ib + 1] - pos[ia + 1], dz = pos[ib + 2] - pos[ia + 2];
+      const d = Math.hypot(dx, dy, dz);
+      if (d < 1e-9) continue;
+      const C = d - s.rest;
+      const compliance = s.kind === 'bend' ? COMP_BEND : C > 0 ? COMP_STRETCH : COMP_COMPRESS;
+      const at = compliance / dt2;
+      const dLambda = (-C - at * lam[si]) / (w + at);
+      lam[si] += dLambda;
+      // grad C is -n for node a and +n for node b, with n = (b - a)/d
+      const nx = dx / d, ny = dy / d, nz = dz / d;
+      pos[ia] -= nx * dLambda * wa; pos[ia + 1] -= ny * dLambda * wa; pos[ia + 2] -= nz * dLambda * wa;
+      pos[ib] += nx * dLambda * wb; pos[ib + 1] += ny * dLambda * wb; pos[ib + 2] += nz * dLambda * wb;
+    }
+  }
+
+  _pinCorners(t) {
+    for (let k = 0; k < 4; k++) {
+      const c = this.corners[k];
+      if (c.broken) continue;
+      const ci = this.cornerIdx[k] * 3;
+      const p = this._anchorPos(c.anchor, t);
+      this.pos[ci] = p.x; this.pos[ci + 1] = p.y; this.pos[ci + 2] = p.z;
+    }
+  }
+
+  /**
+   * Corner load = magnitude of the VECTOR sum of the tensions in the springs
+   * meeting that corner, each read off its XPBD multiplier as |lambda|/dt^2.
+   *
+   * Reading tension as FABRIC_K * leftover-stretch instead looks equivalent and
+   * is not: after a fixed 5 iterations the leftover stretch is solver error, so
+   * that number measures the solver rather than the fabric and comes out ~50x
+   * hot. The multiplier is the actual constraint impulse, which is why the
+   * statics assert balances.
+   *
+   * The vector sum (rather than a scalar total) is what
+   * makes DESIGN.md's anchor-angle mechanic fall out for free: edges pulling in
+   * nearly the same direction add up, edges pulling apart partly cancel — so a
+   * pinched corner really does multiply its own load.
+   */
+  _measureLoads(dt) {
+    const pos = this.pos, lam = this.lambda;
+    const invDt2 = 1 / (dt * dt);
+    const alpha = 1 - Math.exp(-dt / LOAD_TAU);
+    for (let k = 0; k < 4; k++) {
+      const c = this.corners[k];
+      if (c.broken) { c.load = 0; c.loadVec.x = c.loadVec.y = c.loadVec.z = 0; continue; }
+      const ci = this.cornerIdx[k], cix = ci * 3;
+      let sx = 0, sy = 0, sz = 0;
+      for (const { s, si } of this.cornerSprings[k]) {
+        if (lam[si] >= 0) continue; // slack or compressed fabric pulls on nothing
+        const tension = -lam[si] * invDt2; // the multiplier IS the impulse; /dt^2 makes it newtons
+        const o = (s.a === ci ? s.b : s.a) * 3;
+        const dx = pos[o] - pos[cix], dy = pos[o + 1] - pos[cix + 1], dz = pos[o + 2] - pos[cix + 2];
+        const d = Math.hypot(dx, dy, dz);
+        if (d < 1e-9) continue;
+        sx += (dx / d) * tension; sy += (dy / d) * tension; sz += (dz / d) * tension;
+      }
+      c.loadVec.x += (sx - c.loadVec.x) * alpha;
+      c.loadVec.y += (sy - c.loadVec.y) * alpha;
+      c.loadVec.z += (sz - c.loadVec.z) * alpha;
+      const raw = Math.hypot(sx, sy, sz);
+      c.load += (raw - c.load) * alpha;
+      if (c.load > c.peakLoad) c.peakLoad = c.load;
+    }
+  }
+
+  /** Ported from the prototype: 0.4 s sustained over the rating and it lets go. */
+  _checkFailure(dt) {
+    for (let k = 0; k < 4; k++) {
+      const c = this.corners[k];
+      if (c.broken) continue;
+      if (c.load > c.hw.rating) c.overload += dt;
+      else c.overload = Math.max(0, c.overload - dt * OVERLOAD_RECOVER);
+      if (c.overload > OVERLOAD_SECS) {
+        c.broken = true;
+        c.overload = 0;
+        c.load = 0;
+        // Hand the node its mass back. Everything good about a failure comes
+        // from this one line: the freed corner stops being pinned, so it flies
+        // on the wind and the flogging is emergent rather than animated.
+        // Without it a "blown" corner stays welded in mid-air.
+        this.invMass[this.cornerIdx[k]] = 1 / this.nodeMass;
+        this.events.emit('break', { type: 'break', corner: c, anchorId: c.anchorId, hw: c.hw.name, t: this.t });
+      }
+    }
+    if (this._dirtyRest) { this._applyRestLengths(); this._dirtyRest = false; }
+  }
+
+  /** Re-rig a blown corner with fresh hardware. Lane D's hold-E repair calls this. */
+  repairCorner(index, hw = HARDWARE[1]) {
+    const c = this.corners[index];
+    if (!c || !c.broken) return false;
+    c.broken = false;
+    c.hw = hw;
+    c.load = 0;
+    c.overload = 0;
+    this._repin(this.t);
+    this.events.emit('repair', { type: 'repair', corner: c, anchorId: c.anchorId, hw: hw.name, t: this.t });
+    return true;
+  }
+
+  /** Turnbuckle trim at ONE corner (Lane D, 1.2 s hold). Tightens/eases locally. */
+  trimCorner(index, delta) {
+    const c = this.corners[index];
+    if (!c) return false;
+    c.trim = clamp(c.trim + delta, TRIM_MIN, TRIM_MAX);
+    this._dirtyRest = true;
+    return true;
+  }
+
+  setTension(tension) {
+    this.tension = clamp(tension, TENSION_MIN, TENSION_MAX);
+    if (this.rigged) this._applyRestLengths();
+  }
+
+  /**
+   * Ground-projected shade over a rect: the fraction of sample points on the
+   * rect that the sail blocks from the sun. This IS the shade mechanic, so it
+   * raycasts toward the real sun rather than projecting straight down — which
+   * is what lets DESIGN.md's moving and seasonal sun change the answer.
+   *
+   * @param {object} rect    world.gardenBed shape: CENTRE (x,z), size (w,d), metres
+   * @param {object} sunDir  world.sunDir — unit vector from the ground TOWARD
+   *                         the sun. A hit means shaded. Defaults to overhead.
+   */
+  coverageOver(rect, sunDir = { x: 0, y: 1, z: 0 }) {
+    if (!this.rigged) return 0;
+    const len = Math.hypot(sunDir.x, sunDir.y, sunDir.z) || 1;
+    const dx = sunDir.x / len, dy = sunDir.y / len, dz = sunDir.z / len;
+    if (dy <= 0.01) return 0; // sun at or below the horizon casts no useful shade
+
+    const COLS = 6, ROWS = 4; // prototype sampled 6x4 over the garden
+    let hit = 0;
+    for (let i = 0; i < COLS; i++) {
+      for (let j = 0; j < ROWS; j++) {
+        // rect is centre-and-size, so samples straddle (rect.x, rect.z)
+        const ox = rect.x + ((i + 0.5) / COLS - 0.5) * rect.w;
+        const oz = rect.z + ((j + 0.5) / ROWS - 0.5) * rect.d;
+        if (this._rayHitsSail(ox, 0, oz, dx, dy, dz)) hit++;
+      }
+    }
+    return hit / (COLS * ROWS);
+  }
+
+  /** Moller-Trumbore against every face; 162 tris, cheap enough to not bother accelerating. */
+  _rayHitsSail(ox, oy, oz, dx, dy, dz) {
+    const pos = this.pos;
+    for (let i = 0; i < this.tris.length; i += 3) {
+      const a = this.tris[i] * 3, b = this.tris[i + 1] * 3, c = this.tris[i + 2] * 3;
+      const e1x = pos[b] - pos[a], e1y = pos[b + 1] - pos[a + 1], e1z = pos[b + 2] - pos[a + 2];
+      const e2x = pos[c] - pos[a], e2y = pos[c + 1] - pos[a + 1], e2z = pos[c + 2] - pos[a + 2];
+      const px = dy * e2z - dz * e2y, py = dz * e2x - dx * e2z, pz = dx * e2y - dy * e2x;
+      const det = e1x * px + e1y * py + e1z * pz;
+      if (Math.abs(det) < 1e-9) continue; // ray parallel to the face
+      const inv = 1 / det;
+      const tx = ox - pos[a], ty = oy - pos[a + 1], tz = oz - pos[a + 2];
+      const u = (tx * px + ty * py + tz * pz) * inv;
+      if (u < 0 || u > 1) continue;
+      const qx = ty * e1z - tz * e1y, qy = tz * e1x - tx * e1z, qz = tx * e1y - ty * e1x;
+      const v = (dx * qx + dy * qy + dz * qz) * inv;
+      if (v < 0 || u + v > 1) continue;
+      const hitT = (e2x * qx + e2y * qy + e2z * qz) * inv;
+      if (hitT > 1e-6) return true;
+    }
+    return false;
+  }
+
+  /** Sum of the aerodynamic + weight force on the whole sail, N. Used by the statics assert. */
+  netAppliedForce(wind, t) {
+    this._accumulateWind(wind, t, SIM_DT);
+    let fx = 0, fy = 0, fz = 0;
+    for (let n = 0; n < this.invMass.length; n++) {
+      fx += this.force[n * 3];
+      fy += this.force[n * 3 + 1] + GRAVITY * this.nodeMass;
+      fz += this.force[n * 3 + 2];
+    }
+    return { x: fx, y: fy, z: fz };
+  }
+
+  maxLoad() {
+    let m = 0;
+    for (const c of this.corners) if (c.load > m) m = c.load;
+    return m;
+  }
+}
+
+/**
+ * three.js view over a rig. Imported lazily so the sim core above stays
+ * headless-runnable; call this only from the browser, after Lane A's vendor/
+ * exists. Returns a THREE.Group to add to the scene, with update() per frame.
+ */
+export async function createSailView(rig, { color = 0xd8c48a } = {}) {
+  const THREE = await import('../vendor/three.module.js');
+
+  const geo = new THREE.BufferGeometry();
+  const verts = new Float32Array(rig.pos.length);
+  geo.setAttribute('position', new THREE.BufferAttribute(verts, 3));
+  geo.setIndex(new THREE.BufferAttribute(new Uint16Array(rig.tris), 1));
+
+  const mat = new THREE.MeshStandardMaterial({
+    color, side: THREE.DoubleSide, roughness: 0.92, metalness: 0.0,
+  });
+  const mesh = new THREE.Mesh(geo, mat);
+  mesh.castShadow = true;    // the shadow IS the product
+  mesh.receiveShadow = true;
+  mesh.frustumCulled = false; // it flogs well outside its initial bounds
+
+  const group = new THREE.Group();
+  group.add(mesh);
+  group.update = () => {
+    verts.set(rig.pos);
+    geo.attributes.position.needsUpdate = true;
+    geo.computeVertexNormals();
+    geo.computeBoundingSphere();
+  };
+  group.update();
+  return group;
+}

web/world/js/sail.selftest.js

@@ -0,0 +1,370 @@
+/**
+ * sail.selftest.js — assert suite for the sail sim.  [Lane B]
+ *
+ * Exports SAIL_TESTS as plain [name, fn] pairs so ONE set of asserts runs in
+ * two harnesses: Lane A's selftest.html (via js/tests/b.test.js) and node
+ * (`node web/world/js/sail.selftest.js`) for fast iteration without a browser.
+ * Drives time with fixed-dt loops only — never rAF, never a clock.
+ *
+ * The headline assert is `hypar sheds load vs flat`: it is the game's thesis
+ * stated as a test. If it ever goes red, the sail has stopped being a sail.
+ */
+
+import { SailRig } from './sail.js';
+import { HARDWARE, FIXED_DT, createStubWind, rng } from './contracts.js';
+
+const SIM_DT = FIXED_DT;
+
+// ---------- deterministic stub wind ----------
+// contracts.js ships createStubWind(), and the integration test below uses it.
+// This local one exists only because the thesis needs the wind DIRECTION swept,
+// which the shared stub does not expose. Lane C's weather.js replaces both.
+
+function makeStubWind({ seed = 7, stormLen = 90, dir = { x: 0, y: 0, z: 1 }, calm = false } = {}) {
+  const rand = rng(seed);
+  const gusts = [];
+  for (let t = 3; t < stormLen; t += 5 + rand() * 7) {
+    gusts.push({ start: t, pow: 12 + rand() * 16 + 10 * (t / stormLen) });
+  }
+  const len = Math.hypot(dir.x, dir.y, dir.z) || 1;
+  const dx = dir.x / len, dy = dir.y / len, dz = dir.z / len;
+  const out = { x: 0, y: 0, z: 0 };
+
+  return {
+    speedAt(t) {
+      if (calm) return 0;
+      let speed = 8 + 26 * Math.min(1, (t / stormLen) * 1.6);
+      for (const g of gusts) {
+        const gt = t - g.start;
+        if (gt < 0 || gt >= 5) continue;
+        if (gt < 1.5) continue;                               // telegraph: seen, not felt
+        else if (gt < 2.3) speed += g.pow * (gt - 1.5) / 0.8; // ramp
+        else if (gt < 4.0) speed += g.pow;                    // hold
+        else speed += g.pow * (5.0 - gt);                     // fade
+      }
+      return speed;
+    },
+    sample(pos, t) {
+      const s = this.speedAt(t);
+      out.x = dx * s; out.y = dy * s; out.z = dz * s;
+      return out;
+    },
+    gustTelegraph: () => null,
+  };
+}
+
+const constantWind = (v) => ({ sample: () => v, speedAt: () => Math.hypot(v.x, v.y, v.z), gustTelegraph: () => null });
+
+// ---------- test rigs ----------
+// Same 5x5 m footprint, same multiset of corner heights {4.0, 4.0, 2.5, 2.5}.
+// Only the ARRANGEMENT differs: coplanar (flat, pitched) vs permuted (twisted
+// hypar). Any load difference is therefore purely geometry, nothing else.
+
+const FOOT = [
+  { x: -2.5, z: -2.5 }, { x: 2.5, z: -2.5 }, { x: 2.5, z: 2.5 }, { x: -2.5, z: 2.5 },
+];
+export const HEIGHTS_FLAT = [4.0, 4.0, 2.5, 2.5];  // y linear in z -> one plane
+export const HEIGHTS_HYPAR = [4.0, 2.5, 4.0, 2.5]; // opposite corners up/down -> saddle
+
+/** Anchors shaped like contracts.js Anchor: sway(t) is the ABSOLUTE position. */
+export const makeAnchors = (heights) =>
+  FOOT.map((f, i) => {
+    const pos = { x: f.x, y: heights[i], z: f.z };
+    return { id: `a${i}`, type: 'post', pos, sway: () => pos };
+  });
+
+const ALL_IDS = ['a0', 'a1', 'a2', 'a3'];
+const UNBREAKABLE = { name: 'test rig', cost: 0, rating: Infinity };
+
+function rig(heights, { hw = UNBREAKABLE, tension = 1.0, porosity = 0 } = {}) {
+  return new SailRig({ anchors: makeAnchors(heights), gridN: 10, porosity })
+    .attach(ALL_IDS, [hw, hw, hw, hw], tension);
+}
+
+/** Fixed-dt fast-forward. Returns the peak corner load over the whole run, N. */
+function runStorm(r, wind, secs, onStep) {
+  const steps = Math.round(secs / SIM_DT);
+  let peak = 0;
+  for (let i = 0; i < steps; i++) {
+    r.step(SIM_DT, wind, i * SIM_DT);
+    const m = r.maxLoad();
+    if (m > peak) peak = m;
+    if (onStep) onStep(r, i);
+  }
+  return peak;
+}
+
+const TESTS = [];
+const test = (name, fn) => TESTS.push([name, fn]);
+const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
+const kN = (n) => `${(n / 1000).toFixed(2)} kN`;
+
+// ---------- the suite ----------
+
+test('sim stays finite through a full storm', () => {
+  const r = rig(HEIGHTS_HYPAR);
+  runStorm(r, makeStubWind({ stormLen: 90 }), 90);
+  for (const v of r.pos) assert(Number.isFinite(v), 'node position went NaN/Infinity');
+  for (const c of r.corners) assert(Number.isFinite(c.load), 'corner load went NaN');
+  return `peak ${kN(r.corners.reduce((m, c) => Math.max(m, c.peakLoad), 0))}`;
+});
+
+test('sail sags under gravity when calm', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 6);
+  const N = r.N, mid = (Math.floor(N / 2) * N + Math.floor(N / 2)) * 3;
+  const midY = r.pos[mid + 1];
+  const cornerMeanY = HEIGHTS_FLAT.reduce((a, b) => a + b) / 4;
+  assert(midY < cornerMeanY, `belly (${midY.toFixed(2)}m) should hang below corner mean (${cornerMeanY}m)`);
+  return `belly sags ${(cornerMeanY - midY).toFixed(2)} m below corner plane`;
+});
+
+// Newton's third law. This is what pins FABRIC_K to real newtons: if the corner
+// reactions don't sum to the actual aerodynamic + weight force on the fabric,
+// the load meter is lying and every kN rating on it is meaningless.
+test('statics: corner reactions balance the applied force', () => {
+  const w = constantWind({ x: 0, y: 0, z: 18 });
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, w, 12); // settle
+  // A membrane in steady wind never fully stops moving, so compare the
+  // TIME-AVERAGED reaction against the time-averaged applied force. That is the
+  // momentum balance that must hold; instant by instant it need not.
+  let n = 0, ax = 0, ay = 0, az = 0, rx = 0, ry = 0, rz = 0;
+  for (let i = 0; i < Math.round(4 / SIM_DT); i++) {
+    const t = 12 + i * SIM_DT;
+    r.step(SIM_DT, w, t);
+    const f = r.netAppliedForce(w, t);
+    ax += f.x; ay += f.y; az += f.z;
+    for (const c of r.corners) { rx += c.loadVec.x; ry += c.loadVec.y; rz += c.loadVec.z; }
+    n++;
+  }
+  ax /= n; ay /= n; az /= n; rx /= n; ry /= n; rz /= n;
+  const appliedMag = Math.hypot(ax, ay, az);
+  const err = Math.hypot(rx - ax, ry - ay, rz - az) / appliedMag;
+  assert(err < 0.2, `reactions ${kN(Math.hypot(rx, ry, rz))} vs applied ${kN(appliedMag)} — ${(err * 100).toFixed(0)}% out of balance`);
+  return `applied ${kN(appliedMag)}, reactions ${kN(Math.hypot(rx, ry, rz))}, residual ${(err * 100).toFixed(1)}%`;
+});
+
+// THE THESIS. A twisted sail resists bellying into one coherent pocket, so its
+// worst moment is gentler than a flat sail's worst moment.
+//
+// Scored on WORST CASE over wind direction, not per-direction. Lane C's storms
+// veer, so the player never gets to choose the wind, and worst-case is what the
+// hardware actually has to survive. Per-direction would be a false assert: a
+// flat sail sitting edge-on to the wind genuinely does have low drag, and from
+// that one angle it beats the hypar. Demanding otherwise would mean tuning the
+// sim into a lie.
+test('hypar sheds load vs flat, worst case over wind direction (the thesis)', () => {
+  const DIRS = [
+    { name: 'N', x: 0, z: 1 }, { name: 'NE', x: 0.707, z: 0.707 },
+    { name: 'E', x: 1, z: 0 }, { name: 'SE', x: 0.707, z: -0.707 },
+    { name: 'S', x: 0, z: -1 }, { name: 'SW', x: -0.707, z: -0.707 },
+    { name: 'W', x: -1, z: 0 }, { name: 'NW', x: -0.707, z: 0.707 },
+  ];
+  const sweep = (heights) => {
+    let worst = 0, at = '';
+    for (const d of DIRS) {
+      const storm = makeStubWind({ seed: 7, stormLen: 45, dir: { x: d.x, y: 0, z: d.z } });
+      const p = runStorm(rig(heights), storm, 45);
+      if (p > worst) { worst = p; at = d.name; }
+    }
+    return { worst, at };
+  };
+  const flat = sweep(HEIGHTS_FLAT);
+  const hypar = sweep(HEIGHTS_HYPAR);
+  assert(
+    hypar.worst < flat.worst * 0.8,
+    `hypar worst ${kN(hypar.worst)} (${hypar.at}) should be well under flat worst ${kN(flat.worst)} (${flat.at})`
+  );
+  return `flat worst ${kN(flat.worst)} from ${flat.at} -> hypar worst ${kN(hypar.worst)} from ${hypar.at} (sheds ${((1 - hypar.worst / flat.worst) * 100).toFixed(0)}%)`;
+});
+
+test('cascade: losing a corner spikes its neighbours', () => {
+  const w = constantWind({ x: 0, y: 0, z: 22 });
+  const r = rig(HEIGHTS_HYPAR);
+  runStorm(r, w, 6); // settle
+  const before = Math.max(r.corners[1].load, r.corners[3].load);
+  r.corners[0].broken = true;
+  r._repin(r.t);
+  runStorm(r, w, 2.5); // let the load redistribute
+  const after = Math.max(r.corners[1].load, r.corners[3].load);
+  assert(after >= before * 2, `neighbour went ${kN(before)} -> ${kN(after)}, wanted >= 2x`);
+  return `neighbour ${kN(before)} -> ${kN(after)} (${(after / before).toFixed(1)}x)`;
+});
+
+test('determinism: identical inputs give byte-equal load traces', () => {
+  const trace = () => {
+    const r = rig(HEIGHTS_HYPAR);
+    const w = makeStubWind({ seed: 3, stormLen: 30 });
+    const out = [];
+    runStorm(r, w, 30, (rr) => { for (const c of rr.corners) out.push(c.load); });
+    return out;
+  };
+  const a = trace(), b = trace();
+  assert(a.length === b.length, 'traces differ in length');
+  for (let i = 0; i < a.length; i++) assert(a[i] === b[i], `sample ${i} diverged: ${a[i]} vs ${b[i]}`);
+  return `${a.length} load samples identical`;
+});
+
+test('determinism: variable frame dt matches fixed dt', () => {
+  // Lane A's render loop delivers ragged dt. The internal accumulator has to
+  // absorb that, or nothing the selftest proves applies to the real game.
+  const w1 = makeStubWind({ seed: 5, stormLen: 20 });
+  const fixed = rig(HEIGHTS_HYPAR);
+  for (let i = 0; i < Math.round(20 / SIM_DT); i++) fixed.step(SIM_DT, w1, i * SIM_DT);
+
+  const w2 = makeStubWind({ seed: 5, stormLen: 20 });
+  const ragged = rig(HEIGHTS_HYPAR);
+  const rand = rng(99);
+  let acc = 0;
+  while (acc < 20) {
+    const dt = 0.004 + rand() * 0.02; // 4-24 ms frames
+    ragged.step(dt, w2, acc);
+    acc += dt;
+  }
+  for (let k = 0; k < 4; k++) {
+    const d = Math.abs(fixed.corners[k].load - ragged.corners[k].load);
+    assert(d < 1e-6, `corner ${k} drifted ${d.toFixed(6)} N between fixed and ragged dt`);
+  }
+  return 'ragged frame times converge on the fixed-dt trace';
+});
+
+test('tension dial changes load (drum tight shock-loads)', () => {
+  const w = constantWind({ x: 0, y: 0, z: 20 });
+  const loosePeak = runStorm(rig(HEIGHTS_HYPAR, { tension: 0.7 }), w, 8);
+  const tightPeak = runStorm(rig(HEIGHTS_HYPAR, { tension: 1.35 }), w, 8);
+  assert(tightPeak > loosePeak, `tight ${kN(tightPeak)} should exceed loose ${kN(loosePeak)}`);
+  return `loose ${kN(loosePeak)} vs tight ${kN(tightPeak)}`;
+});
+
+test('porous shade cloth carries less load than solid membrane', () => {
+  const w = constantWind({ x: 0, y: 0, z: 20 });
+  const solid = runStorm(rig(HEIGHTS_HYPAR, { porosity: 0 }), w, 8);
+  const porous = runStorm(rig(HEIGHTS_HYPAR, { porosity: 0.35 }), w, 8);
+  assert(porous < solid, `porous ${kN(porous)} should be under solid ${kN(solid)}`);
+  return `solid ${kN(solid)} vs porous ${kN(porous)}`;
+});
+
+test('coverage: sail shades the ground under it, not beside it', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4);
+  // world.gardenBed rects are CENTRE + size, so this bed straddles the origin.
+  const under = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 });
+  const beside = r.coverageOver({ x: 14, z: 14, w: 4, d: 4 });
+  assert(under > 0.9, `ground under the sail only ${(under * 100).toFixed(0)}% shaded`);
+  assert(beside === 0, `ground 14 m away reported ${(beside * 100).toFixed(0)}% shaded`);
+  return `under sail ${(under * 100).toFixed(0)}%, off to the side ${(beside * 100).toFixed(0)}%`;
+});
+
+test('coverage tracks a low sun off to the side', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4);
+  const noon = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 }, { x: 0, y: 1, z: 0 });
+  const lowSun = r.coverageOver({ x: 0, z: 0, w: 4, d: 4 }, { x: 0.9, y: 0.25, z: 0 });
+  assert(noon > lowSun, `shadow should slide off the bed as the sun drops (noon ${noon}, low ${lowSun})`);
+  return `noon ${(noon * 100).toFixed(0)}% -> low sun ${(lowSun * 100).toFixed(0)}%`;
+});
+
+// PLAN3D §7 definition of done, in miniature.
+test('cheap flat rig cascades; twisted mixed rig survives', () => {
+  const storm = () => makeStubWind({ seed: 11, stormLen: 90 });
+  const cheap = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.35 });
+  runStorm(cheap, storm(), 90);
+  const cheapBroken = cheap.corners.filter((c) => c.broken).length;
+
+  const good = rig(HEIGHTS_HYPAR, { hw: HARDWARE[2], tension: 0.95 });
+  runStorm(good, storm(), 90);
+  const goodBroken = good.corners.filter((c) => c.broken).length;
+
+  assert(cheapBroken >= 2, `flat drum-tight carabiner rig only lost ${cheapBroken} corners — should cascade`);
+  assert(goodBroken === 0, `twisted rated-shackle rig lost ${goodBroken} corners — should survive`);
+  return `cheap flat lost ${cheapBroken}/4, good hypar lost ${goodBroken}/4`;
+});
+
+// PLAN3D §5-B: "broken corner frees the node -> flogging is emergent". This
+// drives a REAL overload failure rather than setting broken by hand, because
+// hand-setting it was exactly what hid the bug where _checkFailure marked a
+// corner broken but never gave its node its mass back — so a blown corner
+// stayed welded in mid-air and the sail never flogged.
+test('a blown corner is freed and flies (flogging is emergent)', () => {
+  const w = makeStubWind({ seed: 11, stormLen: 90 });
+  const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.3 }); // cheap and tight: this one lets go
+  const broke = [];
+  r.events.on('break', (e) => broke.push(e));
+
+  // step until the first corner lets go
+  let i = 0;
+  for (const end = Math.round(90 / SIM_DT); i < end && !broke.length; i++) r.step(SIM_DT, w, i * SIM_DT);
+  assert(broke.length > 0, 'a carabiner rig should have blown a corner somewhere in a 90 s storm');
+
+  const k = r.corners.indexOf(broke[0].corner);
+  const node = r.cornerIdx[k], ci = node * 3;
+  const anchor = r.corners[k].anchor.pos;
+  const before = [r.pos[ci], r.pos[ci + 1], r.pos[ci + 2]];
+  for (let j = 0; j < Math.round(3 / SIM_DT); j++) r.step(SIM_DT, w, (i + j) * SIM_DT);
+
+  const moved = Math.hypot(r.pos[ci] - before[0], r.pos[ci + 1] - before[1], r.pos[ci + 2] - before[2]);
+  const fromAnchor = Math.hypot(r.pos[ci] - anchor.x, r.pos[ci + 1] - anchor.y, r.pos[ci + 2] - anchor.z);
+
+  assert(r.invMass[node] > 0, 'blown corner still has infinite mass — it is welded in mid-air, not flogging');
+  assert(moved > 0.05, `blown corner only drifted ${moved.toFixed(3)} m in 3 s — it is not flogging`);
+  assert(fromAnchor > 0.2, `blown corner is still ${fromAnchor.toFixed(2)} m from its anchor — it never let go`);
+  return `corner ${broke[0].anchorId} blew at t=${broke[0].t.toFixed(1)}s, tore ${fromAnchor.toFixed(2)} m off its anchor and is flying`;
+});
+
+test('break and repair emit on the events Emitter', () => {
+  const w = constantWind({ x: 0, y: 0, z: 20 });
+  const r = rig(HEIGHTS_HYPAR, { hw: UNBREAKABLE });
+  const seen = [];
+  r.events.on('break', (e) => seen.push(e));
+  r.events.on('repair', (e) => seen.push(e));
+
+  runStorm(r, w, 4);
+  r.corners[0].broken = true;
+  r._repin(r.t);
+  runStorm(r, w, 1);
+  assert(r.corners[0].load === 0, 'broken corner should carry no load');
+
+  assert(r.repairCorner(0, UNBREAKABLE), 'repairCorner should report success');
+  runStorm(r, w, 3);
+  assert(r.corners[0].load > 100, `repaired corner only pulling ${kN(r.corners[0].load)}`);
+  assert(seen.some((e) => e.type === 'repair' && e.corner === r.corners[0]), 'no repair event with {type, corner}');
+  return `repaired corner back to ${kN(r.corners[0].load)}, ${seen.length} event(s) emitted`;
+});
+
+test('runs against the shared contracts.js stub wind', () => {
+  // Proves the rig eats the sanctioned Wind implementation, not just my local
+  // stub — so nothing surprises us when Lane C's weather.js drops in.
+  const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[1] });
+  const wind = createStubWind({ seed: 1, stormLen: 90 });
+  const peak = runStorm(r, wind, 90);
+  for (const v of r.pos) assert(Number.isFinite(v), 'went NaN on the shared stub wind');
+  assert(peak > 0, 'shared stub wind produced no load at all');
+  return `90 s on contracts.js stub wind, peak ${kN(peak)}, ${r.corners.filter((c) => c.broken).length}/4 corners lost`;
+});
+
+export const SAIL_TESTS = TESTS;
+
+export function runSailSelftest() {
+  const results = TESTS.map(([name, fn]) => {
+    try { return { name, pass: true, detail: fn() || '' }; }
+    catch (e) { return { name, pass: false, detail: e.message }; }
+  });
+  return { pass: results.every((r) => r.pass), results };
+}
+
+export function report(out) {
+  const lines = out.results.map(
+    (r) => `${r.pass ? 'PASS' : 'FAIL'}  ${r.name}${r.detail ? `\n        ${r.detail}` : ''}`
+  );
+  return `${lines.join('\n')}\n\n${out.pass ? 'ALL GREEN' : 'FAILURES'} — ${out.results.filter((r) => r.pass).length}/${out.results.length}`;
+}
+
+// Run only when invoked directly; importing this module must not run the suite.
+if (typeof process !== 'undefined' && process.versions?.node && import.meta.filename === process.argv[1]) {
+  const out = runSailSelftest();
+  console.log(report(out));
+  process.exit(out.pass ? 0 : 1);
+}
+
+export { makeStubWind };

web/world/js/skyfx.js

@@ -337,10 +337,19 @@ export function createSkyFx(o = {}) {
   dome.renderOrder = -1;
   if (scene) scene.add(dome);
 
-  // remember what world.js handed us, so dispose() puts it back exactly
+  // Remember what world.js handed us, so dispose() puts it back exactly.
+  // Fog is captured BY VALUE, not by reference: step() mutates that very object
+  // in place, so `scene.fog = original.fog` restores the object we just spent a
+  // storm wrecking. Lane A caught it — sun and hemi came back exactly and the fog
+  // stayed where the storm left it. Harmless today only because the next skyfx
+  // immediately re-drives it, which is exactly the kind of bug that waits.
+  const ownsFog = !!scene && !scene.fog;
   const original = {
     background: scene ? scene.background : null,
     fog: scene ? scene.fog : null,
+    fogColor: scene && scene.fog ? scene.fog.color.clone() : null,
+    fogNear: scene && scene.fog ? scene.fog.near : 0,
+    fogFar: scene && scene.fog ? scene.fog.far : 0,
     sun: sun ? sun.intensity : 0,
     hemi: hemi ? hemi.intensity : 0,
   };
@@ -454,7 +463,14 @@ export function createSkyFx(o = {}) {
         scene.remove(rain.mesh);
         scene.remove(dome);
         scene.background = original.background;
-        scene.fog = original.fog;
+        if (ownsFog) {
+          scene.fog = null;                        // we brought it; we take it
+        } else if (original.fog) {
+          scene.fog = original.fog;
+          original.fog.color.copy(original.fogColor);
+          original.fog.near = original.fogNear;
+          original.fog.far = original.fogFar;
+        }
       }
       if (sun) sun.intensity = original.sun;
       if (hemi) hemi.intensity = original.hemi;

web/world/js/tests/b.test.js

@@ -1,26 +1,34 @@
 /**
- * Lane B selftests — cloth, corner loads, failure cascade.
+ * Lane B selftests — cloth, corner loads, failure cascade, prep economy.
  *
- * Lane B owns this file. Lane A pre-created it so that adding your suite never
- * means editing selftest.html — if all five lanes shared that file it would be
- * the one guaranteed merge conflict in the repo.
+ * The asserts themselves live next to the code they test, in
+ * `js/sail.selftest.js` and `js/rigging.selftest.js`, exported as [name, fn]
+ * pairs. This file is only the adapter that hands them to Lane A's Suite.
  *
- * The asserts PLAN3D §5-B asks for, once sail.js lands:
- *   1. hypar sheds load — twisted rig's peak corner load < flat rig's peak,
- *      same storm, same hardware. This is the thesis of the whole game; if it
- *      doesn't hold, the wind force is being applied per-node instead of
- *      per-face.
- *   2. cascade — break one corner at a fixed t, a neighbour's load spikes ≥2×.
- *   3. determinism — two runs, same inputs, byte-equal load traces.
+ * The reason for the indirection: those two modules also run under plain
+ * `node web/world/js/sail.selftest.js` — no browser, no server, no renderer,
+ * ~6 s — which is how the cloth got proven before M0 landed. Keeping the
+ * asserts there means the browser suite and the headless suite can never drift,
+ * because they are literally the same array.
  *
- * Useful imports when you get there:
- *   import { FIXED_DT, STORM_LEN, HARDWARE, createStubWind } from '../contracts.js';
- *   import { assert, assertLess, fixedLoop } from '../testkit.js';
- * Drive time with fixedLoop(), never rAF. Use createStubWind({seed}) until
- * Lane C's weather.js lands — but don't tune against it, it's uniform in space.
+ * PLAN3D §5-B asked for three asserts. All three are in there, plus a statics
+ * balance that pins the load meter to real newtons:
+ *   1. hypar sheds load — scored on WORST CASE over eight wind directions
+ *      rather than one, because Lane C's storms veer and the player never gets
+ *      to pick the wind. Per-direction would be a false assert: a flat sail
+ *      sitting edge-on to the wind genuinely has low drag and beats the hypar
+ *      from that one angle. Worst-case is what the hardware has to survive.
+ *   2. cascade — break a corner at fixed t, a neighbour's load spikes >= 2x.
+ *   3. determinism — byte-equal load traces, plus ragged frame dt converging on
+ *      the fixed-dt trace (Lane A's render loop delivers ragged dt, so the
+ *      accumulator has to absorb it or none of this applies to the real game).
  */
 
+import { SAIL_TESTS } from '../sail.selftest.js';
+import { RIGGING_TESTS } from '../rigging.selftest.js';
+
 /** @param {import('../testkit.js').Suite} t */
 export default function run(t) {
-  t.skip('sail.js not landed yet — Lane B');
+  for (const [name, fn] of SAIL_TESTS) t.test(name, fn);
+  for (const [name, fn] of RIGGING_TESTS) t.test(`rigging: ${name}`, fn);
 }

web/world/js/tests/c.test.js

@@ -15,8 +15,10 @@
 
 import * as THREE from '../../vendor/three.module.js';
 import { assert, fixedLoop } from '../testkit.js';
-import { FIXED_DT, checkContract } from '../contracts.js';
+import { FIXED_DT, checkContract, DEBRIS_PIECE_FIELDS } from '../contracts.js';
 import { loadStorm, createWind } from '../weather.js';
+import { createDebris } from '../debris.js';
+import { createSkyFx } from '../skyfx.js';
 import { weatherCases } from './weather.selftest.js';
 
 const STORMS = ['storm_01_gentle', 'storm_02_wildnight'];
@@ -43,12 +45,34 @@ export default async function run(t) {
     const pos = new THREE.Vector3(3, 0, -2);
     const a = wind.sample(pos, 12.5);
     assert(a instanceof THREE.Vector3, 'sample did not return a THREE.Vector3');
-    assert(a.y === 0, `wind should be horizontal, got y=${a.y}`);
+    assert(Number.isFinite(a.x) && Number.isFinite(a.y) && Number.isFinite(a.z),
+      `sample returned a non-finite vector: ${a.x},${a.y},${a.z}`);
     // out param must not change the answer, only where it lands
     const out = new THREE.Vector3();
     const b = wind.sample(pos, 12.5, out);
     assert(b === out, 'out param was ignored');
-    assert(a.x === b.x && a.z === b.z, 'out param changed the result');
+    assert(a.x === b.x && a.y === b.y && a.z === b.z, 'out param changed the result');
+  });
+
+  // This assert used to read `a.y === 0` — "wind should be horizontal". SPRINT2
+  // decision 3 made that false on purpose: gusts now descend, which is what makes
+  // a flat sail pay. Keeping the useful half — y is downward-or-zero, never up,
+  // and never garbage — so player shove and rain angle can still trust the sign.
+  t.test('vertical wind is downward-only, and only during gusts', () => {
+    const wind = createWind(storms.storm_02_wildnight);
+    const pos = new THREE.Vector3(0, 1.7, 0);
+    const v = new THREE.Vector3();
+    let sawDown = false;
+    fixedLoop(wind.duration, FIXED_DT, (dt, time) => {
+      wind.sample(pos, time, v);
+      assert(v.y <= 1e-9, `wind blew UP (y=${v.y.toFixed(3)}) at t=${time.toFixed(2)}`);
+      if (v.y < -1) sawDown = true;
+    });
+    assert(sawDown, 'never saw a downdraft worth the name in a whole wild night');
+    // and the wind meter must stay horizontal — a falling gust shouldn't spike the HUD
+    const calm = wind.speedAt(pos, 0.5);
+    assert(Math.abs(calm - Math.hypot(wind.sample(pos, 0.5).x, wind.sample(pos, 0.5).z)) < 1e-9,
+      'speedAt() is not the horizontal magnitude of sample()');
   });
 
   // Lifted from a.test.js onto the real wind (Lane A's note in this file's
@@ -70,6 +94,66 @@ export default async function run(t) {
     assert(edges >= 5, `only ${edges} gusts telegraphed in a ${wind.duration}s storm — too quiet to test`);
   });
 
+  // --- SPRINT2 decision 5: debris.pieces is Lane B's to read, so it's frozen ---
+  t.test('debris conforms and its pieces match the frozen shape', () => {
+    const wind = createWind(storms.storm_02_wildnight);
+    const debris = createDebris({ wind });
+    assert(checkContract('debris', debris).length === 0, checkContract('debris', debris).join('; '));
+
+    const p = debris.spawn({ model: 'BlueCrate_v2', lateral: 0 }, 40);
+    for (const [field, want] of Object.entries(DEBRIS_PIECE_FIELDS)) {
+      const got = typeof p[field];
+      assert(got === want, `piece.${field} is ${got}, contract says ${want}`);
+      if (want === 'number') assert(Number.isFinite(p[field]), `piece.${field} is not finite`);
+    }
+    assert(debris.pieces.includes(p), 'spawn() returned a piece that is not in pieces');
+    assert(p.r > 0 && p.mass > 0, 'a piece with no radius or no mass cannot be collided with');
+
+    // The array is mutated in place and pieces are spliced on despawn — that's
+    // documented, and B reads it fresh inside step(). Prove clear() empties it
+    // rather than swapping in a new array behind their reference.
+    const ref = debris.pieces;
+    debris.clear();
+    assert(ref === debris.pieces && debris.pieces.length === 0,
+      'clear() replaced the pieces array instead of emptying it — B holds a reference');
+  });
+
+  // Lane A rebuilds skyfx on every phase change, so dispose() is on the hot path.
+  // They verified sun/hemi restore exactly and spotted that fog didn't; this pins
+  // both. The vacuity guards matter — a restore test where nothing ever moved is
+  // a test that passes forever and checks nothing.
+  t.test('skyfx.dispose() hands the scene back exactly as it found it', () => {
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x9fc4e8);
+    scene.fog = new THREE.Fog(0x9fc4e8, 30, 140);
+    const camera = new THREE.PerspectiveCamera();
+    const sun = new THREE.DirectionalLight(0xfff4e0, 2.0);
+    const hemi = new THREE.HemisphereLight(0xbfd8ff, 0x3a4a2a, 1.8);
+    const before = {
+      bg: scene.background, fogColor: scene.fog.color.getHex(),
+      fogNear: scene.fog.near, fogFar: scene.fog.far,
+      sun: sun.intensity, hemi: hemi.intensity, children: scene.children.length,
+    };
+
+    const wind = createWind(storms.storm_02_wildnight);
+    const sky = createSkyFx({ scene, camera, wind, sun, hemi });
+    fixedLoop(40, FIXED_DT, (dt, time) => sky.step(dt, time, {}));
+
+    assert(sun.intensity < before.sun * 0.9, 'the storm never dimmed the sun — this test proves nothing');
+    assert(scene.fog.near !== before.fogNear, 'the storm never touched the fog — this test proves nothing');
+
+    sky.dispose();
+    assert(sun.intensity === before.sun, `sun left at ${sun.intensity}, want ${before.sun}`);
+    assert(hemi.intensity === before.hemi, `hemi left at ${hemi.intensity}, want ${before.hemi}`);
+    assert(scene.background === before.bg, 'scene.background not restored');
+    assert(scene.fog.color.getHex() === before.fogColor,
+      `fog colour left at #${scene.fog.color.getHex().toString(16)}, want #${before.fogColor.toString(16)}`);
+    assert(scene.fog.near === before.fogNear && scene.fog.far === before.fogFar,
+      `fog left at near=${scene.fog.near} far=${scene.fog.far}, want ${before.fogNear}/${before.fogFar}`);
+    assert(scene.children.length === before.children,
+      `skyfx left ${scene.children.length - before.children} object(s) in the scene`);
+  });
+
   t.test('every storm in data/storms/ loads and validates', () => {
     // loadStorm throws on invalid, so reaching here with all of them is the pass
     assert(Object.keys(storms).length === STORMS.length, 'a storm failed to load');

web/world/js/tests/d.test.js

@@ -1,26 +1,295 @@
 /**
- * Lane D selftests — player state machine and interactions.
+ * Lane D selftests — player state machine, weather effects, interactions.  (PLAN3D §5-D.5)
  *
- * Lane D owns this file. Lane A pre-created it so adding your suite never means
- * editing selftest.html.
+ * Everything asserted here is renderer-free: player.sim.js and interact.js import nothing, so this
+ * suite is pure logic driven at fixed dt, never rAF. (rAF being throttled in a hidden tab is not
+ * theoretical — this lane's dev harness froze mid-knockdown at stateT=0.333 until it was driven by
+ * a fixed loop, which is exactly the trap Lane A called out.)
  *
- * The asserts PLAN3D §5-D asks for, once player.js lands:
- *   1. anim state machine table test — every state reachable, none stuck
- *      (idle/walk/run + one-shot interact + knockdown → get-up).
- *   2. interact radius respects the busy and carrying flags.
- *
- * Note for integration: main.js currently drives a placeholder capsule that
- * satisfies the Player contract ({pos, carrying, busy, update}). When player.js
- * lands, Lane A swaps the factory call in boot() and deletes the placeholder —
- * you shouldn't need to touch main.js yourself. Ping THREADS.md when you're
- * ready and Lane A will do the swap.
- *
- * Useful imports:
- *   import { FIXED_DT, createStubWind } from '../contracts.js';
- *   import { assert, assertEq, fixedLoop } from '../testkit.js';
+ * The rig half of player.js — bone binding, head-bone scale, clip retarget — can't be asserted
+ * headlessly; it needs a GL context and two GLB fetches. That is verified by hand in
+ * web/world/dev_player.html and written up in THREADS.md: head bone 1.715 m at fig scale 0.983,
+ * all six clips bound, Hips tracks correctly absent.
  */
+import { PlayerSim, STATES, TUNE } from '../player.sim.js';
+import { Interact, wireYardActions } from '../interact.js';
+import { assert, assertEq, assertClose, assertLess, fixedLoop } from '../testkit.js';
+import { FIXED_DT } from '../contracts.js';
+
+const DT = FIXED_DT;
+
+/** Steady wind blowing +X at `speed` m/s. */
+const windX = (speed) => ({ x: speed, y: 0, z: 0 });
+
+/** Drive the sim for `secs` at fixed dt. */
+const drive = (sim, secs, input = {}, wind = null, t0 = 0) =>
+  fixedLoop(secs, DT, (dt, t) => sim.step(dt, t0 + t, input, wind));
 
 /** @param {import('../testkit.js').Suite} t */
 export default function run(t) {
-  t.skip('player.js not landed yet — Lane D');
+  // ---------------------------------------------------------------- state machine table
+  t.test('state table: every state\'s clip exists in player_anims.glb', () => {
+    const clips = new Set(['Idle', 'Walk', 'Run', 'Falling', 'CrouchToStand', 'Reaction']);
+    for (const [name, st] of Object.entries(STATES)) {
+      assert(clips.has(st.clip), `state ${name} wants missing clip ${st.clip}`);
+    }
+  });
+
+  t.test('state table: no stuck states — every locked state drains to a free one', () => {
+    for (const [name, st] of Object.entries(STATES)) {
+      if (!st.locked) continue;
+      assert((st.next && st.secs > 0) || !!st.releasedBy,
+        `locked state ${name} has neither a timed exit nor an external releaser`);
+      if (st.next) assert(!!STATES[st.next], `state ${name}.next=${st.next} is not a state`);
+    }
+    for (const name of Object.keys(STATES)) {
+      let cur = name, hops = 0;
+      const seen = new Set();
+      while (STATES[cur].locked && STATES[cur].next && hops < 16 && !seen.has(cur)) {
+        seen.add(cur); cur = STATES[cur].next; hops++;
+      }
+      assert(!STATES[cur].locked || !!STATES[cur].releasedBy,
+        `state ${name} chains into a dead end at ${cur}`);
+    }
+  });
+
+  // ---------------------------------------------------------------- locomotion
+  t.test('locomotion: idle -> walk -> run -> idle at the tuned speeds', () => {
+    const sim = new PlayerSim();
+    assertEq(sim.state, 'idle', 'spawns idle');
+    assert(!sim.busy, 'idle is not busy');
+
+    drive(sim, 1.0, { x: 0, z: 1, camYaw: 0 });
+    assertEq(sim.state, 'walk', 'W walks');
+    assertClose(sim.speed, TUNE.walkSpeed, 0.05, 'walk speed');
+
+    drive(sim, 1.0, { x: 0, z: 1, run: true, camYaw: 0 });
+    assertEq(sim.state, 'run', 'shift runs');
+    assertClose(sim.speed, TUNE.runSpeed, 0.05, 'run speed');
+
+    drive(sim, 1.0, {});
+    assertEq(sim.state, 'idle', 'releasing input returns to idle');
+    assertLess(sim.speed, 0.15, 'and stops');
+  });
+
+  t.test('locomotion: movement is relative to camera.yaw', () => {
+    const a = new PlayerSim(); drive(a, 1.0, { x: 0, z: 1, camYaw: 0 });
+    assertLess(a.pos.z, -0.5, 'at yaw 0, W drives -Z (three.js camera-forward)');
+    assertClose(a.pos.x, 0, 1e-6, 'and not sideways');
+
+    const b = new PlayerSim(); drive(b, 1.0, { x: 0, z: 1, camYaw: Math.PI / 2 });
+    assertLess(b.pos.x, -0.5, 'at yaw 90 deg, the same key drives -X');
+    assertClose(b.pos.z, 0, 1e-6, 'and not forward');
+
+    assertClose(Math.abs(a.facing), Math.PI, 0.05, 'facing chases the movement direction');
+  });
+
+  // ---------------------------------------------------------------- weather on the player
+  t.test('weather: wind slows you, capped at TUNE.slowMax', () => {
+    const calm = new PlayerSim(); drive(calm, 2, { x: 0, z: 1, camYaw: 0 }, windX(0));
+    const blow = new PlayerSim(); drive(blow, 2, { x: 0, z: 1, camYaw: 0 }, windX(20));
+    assertLess(blow.speed, calm.speed, 'wind slows you');
+
+    // Isolate the slow curve from the knockdown — in a real 1e4 m/s you are flat on your back
+    // inside half a second (which is correct, and is what this assert used to accidentally measure).
+    const gale = new PlayerSim({ tune: { knockWind: Infinity } });
+    drive(gale, 2, { x: 0, z: 1, camYaw: 0 }, windX(1e4));
+    assertClose(gale.speed, TUNE.walkSpeed * (1 - TUNE.slowMax), 0.05,
+      'slow saturates at slowMax and never goes past it');
+  });
+
+  t.test('weather: steady wind reads as baseline, not as a gust', () => {
+    const s = new PlayerSim();
+    drive(s, 60, {}, windX(20));
+    assertLess(s.gust, 1.0, 'the EMA learns a constant 20 m/s as base');
+    assertLess(Math.hypot(s.shove.x, s.shove.z), 0.05, 'so it does not shove you forever');
+  });
+
+  t.test('weather: a gust over the baseline shoves you downwind, and scales with speed squared', () => {
+    const s = new PlayerSim();
+    drive(s, 30, {}, windX(6));            // learn a calm baseline
+    const x0 = s.pos.x;
+    drive(s, 1.6, {}, windX(22), 30);      // 16 m/s over baseline -> past shoveGustMin
+    assert(s.pos.x - x0 > 0.05, `gust should shove downwind, dx=${(s.pos.x - x0).toFixed(3)}`);
+
+    const push = (ws) => {
+      const p = new PlayerSim();
+      drive(p, 30, {}, windX(2));
+      const p0 = p.pos.x;
+      drive(p, 1.0, {}, windX(ws), 30);
+      return p.pos.x - p0;
+    };
+    const p15 = push(15), p30 = push(30);
+    assert(p30 > p15 * 2.5,
+      `shove must grow faster than linearly with speed: ${p15.toFixed(3)} -> ${p30.toFixed(3)}`);
+  });
+
+  // ---------------------------------------------------------------- knockdown
+  t.test('knockdown: needs SUSTAINED overload, like a sail corner letting go', () => {
+    const brief = new PlayerSim();
+    drive(brief, 0.3, {}, windX(TUNE.knockWind + 5));
+    assert(brief.state !== 'knocked', 'a brief spike must not put you down');
+
+    const held = new PlayerSim();
+    held.carrying = 'spare';
+    drive(held, TUNE.knockSustain + 0.2, {}, windX(TUNE.knockWind + 5));
+    assertEq(held.state, 'knocked', 'sustained overload does');
+    assertEq(held.carrying, null, 'and drops what you were carrying');
+    assert(held.knockDir.x > 0.99, 'and you fall downwind');
+  });
+
+  t.test('knockdown: exposure bleeds off — flickering gusts never creep into one', () => {
+    const s = new PlayerSim();
+    fixedLoop(10, DT, (dt, t) => {
+      const on = Math.round(t / DT) % 40 < 10;        // 0.17 s on, 0.5 s off
+      s.step(dt, t, {}, windX(on ? TUNE.knockWind + 5 : 5));
+    });
+    assert(s.state !== 'knocked',
+      `flickering gusts must not accumulate (exposure=${s.exposure.toFixed(3)})`);
+  });
+
+  t.test('knockdown: knocked -> getup -> idle, unaided, and upright again', () => {
+    const s = new PlayerSim();
+    s.knockdown(0);
+    assert(s.busy, 'knocked is locked');
+    drive(s, 0.5, { x: 0, z: 1, camYaw: 0 });
+    assertClose(s.pos.z, 0, 1e-9, 'knocked ignores movement input');
+    assert(s.pitch > 0.99, 'body goes flat');
+    drive(s, 1.1, {});
+    assertEq(s.state, 'getup', 'knocked drains to getup on its own');
+    drive(s, 1.4, {});
+    assertEq(s.state, 'idle', 'getup drains to idle on its own');
+    assertLess(s.pitch, 0.01, 'and the body is upright again');
+    assert(!s.busy, 'player is free');
+  });
+
+  // ---------------------------------------------------------------- determinism (PLAN3D §4)
+  t.test('determinism: two identical 50 s runs produce byte-equal traces', () => {
+    const trace = () => {
+      const s = new PlayerSim();
+      const out = [];
+      fixedLoop(50, DT, (dt, tt) => {
+        const w = { x: 6 + 24 * Math.max(0, Math.sin(tt * 0.7)), y: 0, z: 3 * Math.cos(tt * 0.31) };
+        s.step(dt, tt, { x: Math.sin(tt), z: Math.cos(tt * 0.5), run: tt % 4 < 2, camYaw: tt * 0.2 }, w);
+        out.push(`${s.state}|${s.pos.x.toFixed(9)}|${s.pos.z.toFixed(9)}|${s.pitch.toFixed(9)}`);
+      });
+      return out.join(';');
+    };
+    assertEq(trace(), trace(), 'same inputs must give the same trace');
+  });
+
+  // ---------------------------------------------------------------- interact
+  const mk = () => {
+    const sim = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    let done = 0;
+    it.register({ id: 'x', pos: { x: 0, y: 0, z: 0 }, radius: 1.5, holdSecs: 1, label: 'do it',
+      onDone: () => { done++; } });
+    return { sim, it, done: () => done };
+  };
+
+  t.test('interact: radius gates the action', () => {
+    const { sim, it, done } = mk();
+    sim.pos.x = 5;
+    fixedLoop(2, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(done(), 0, 'out of radius never fires');
+    assert(!sim.busy, 'and never makes you busy');
+  });
+
+  t.test('interact: hold to completion fires once and hands the player back', () => {
+    const { sim, it, done } = mk();
+    fixedLoop(70 * DT, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(done(), 1, 'fires once');
+    assert(!sim.busy && sim.state === 'idle', 'player released');
+    assert(it.events.some((e) => e.type === 'done' && e.id === 'x'), 'emits a done event');
+  });
+
+  t.test('interact: player is busy mid-hold, with a partial radial', () => {
+    const { sim, it } = mk();
+    fixedLoop(30 * DT, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assert(sim.busy && sim.state === 'busy', 'busy while holding');
+    assert(it.progress > 0.4 && it.progress < 0.6, `radial partway, got ${it.progress.toFixed(2)}`);
+  });
+
+  t.test('interact: one press, one action — a held key must not re-arm itself', () => {
+    const { sim, it, done } = mk();
+    fixedLoop(6.7, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(done(), 1, 'holding E for 6.7 s over a 1 s action still fires once');
+    it.step(DT, 7, sim, false);
+    fixedLoop(70 * DT, DT, (dt, tt) => it.step(dt, 7 + tt, sim, true));
+    assertEq(done(), 2, 'releasing re-arms it');
+  });
+
+  t.test('interact: releasing or walking away cancels the hold', () => {
+    const a = mk();
+    fixedLoop(30 * DT, DT, (dt, tt) => a.it.step(dt, tt, a.sim, true));
+    a.it.step(DT, 0.5, a.sim, false);
+    assertEq(a.it.progress, 0, 'release cancels');
+    assert(!a.sim.busy && a.sim.state === 'idle', 'and frees the player');
+
+    const b = mk();
+    fixedLoop(30 * DT, DT, (dt, tt) => b.it.step(dt, tt, b.sim, true));
+    b.sim.pos.x = 9;
+    b.it.step(DT, 0.5, b.sim, true);
+    assertEq(b.it.progress, 0, 'leaving the radius cancels');
+    assertEq(b.done(), 0, 'without firing');
+  });
+
+  t.test('interact: a knockdown mid-hold aborts without stomping the knocked state', () => {
+    const { sim, it, done } = mk();
+    fixedLoop(30 * DT, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    sim.knockdown(0.5);
+    it.step(DT, 0.51, sim, true);
+    assertEq(it.progress, 0, 'hold aborted');
+    assertEq(done(), 0, 'action did not fire');
+    assertEq(sim.state, 'knocked', 'and the abort did not overwrite the knocked state');
+  });
+
+  t.test('interact: canUse() gates on the carrying flag', () => {
+    const sim = new PlayerSim();
+    const it = new Interact();
+    let fired = 0;
+    it.register({ id: 'gated', pos: { x: 0, y: 0, z: 0 }, radius: 2, holdSecs: 0.5,
+      canUse: (p) => !p.carrying, onDone: () => { fired++; } });
+    sim.carrying = 'spare';
+    fixedLoop(1, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(fired, 0, 'hands full: gated');
+    assert(!sim.busy, 'and never went busy');
+    sim.carrying = null;
+    fixedLoop(1, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(fired, 1, 'fires once the gate opens');
+  });
+
+  // ---------------------------------------------------------------- hands-full + wiring
+  t.test('hands-full rule: one item at a time', () => {
+    const sim = new PlayerSim();
+    assertEq(sim.pickUp('spare'), true, 'first item accepted');
+    assertEq(sim.pickUp('wrench'), false, 'second refused');
+    assertEq(sim.carrying, 'spare', 'still holding the first');
+    assertEq(sim.drop(), 'spare', 'drop returns it');
+    assertEq(sim.carrying, null, 'hands empty');
+  });
+
+  t.test('wireYardActions: duck-types against a half-landed world', () => {
+    const empty = new Interact();
+    wireYardActions(empty, {});
+    assertEq(empty.targets.size, 0, 'no sailRig yet (Lane B) -> no actions, no crash');
+
+    const it = new Interact();
+    const corners = [{ anchorId: 'p1', broken: true, pos: { x: 0, y: 2, z: 0 }, load: 0 }];
+    let repaired = -1;
+    wireYardActions(it, {
+      sailRig: { corners, repair: (i) => { repaired = i; }, trim: () => {} },
+      world: { shedTable: { pos: { x: 10, y: 0, z: 0 } } },
+    });
+    assertEq(it.targets.size, 3, 're-rig + trim + spare table');
+
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assertEq(repaired, -1, 're-rig refuses without a spare');
+    p.carrying = 'spare';
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, 10 + tt, p, true));
+    assertEq(repaired, 0, 're-rig fires with a spare');
+    assertEq(p.carrying, null, 'and consumes it');
+  });
 }

web/world/js/tests/e.test.js

@@ -1,28 +1,160 @@
 /**
  * Lane E selftests — asset sanity.
+ * Lane E owns this file. Other lanes: yours is js/tests/<letter>.test.js.
  *
- * Lane E owns this file. Lane A pre-created it so adding your suite never means
- * editing selftest.html.
+ * Why this exists when build_yard_assets.py already verifies: the Blender side
+ * re-imports every GLB and asserts dims, tri budget and node names, but it
+ * CANNOT catch an axis error. Blender exports Z-up→Y-up and imports Y-up→Z-up,
+ * so a broken `export_yup` flips back on the way in and round-trips green. Only
+ * a native glTF reader can prove the file is right, and this is the only one in
+ * the repo. So this suite targets the failures that silently break other lanes:
+ *   1. the GLB loads at all through the vendored loader;
+ *   2. it's in metres with its height on +Y — a model exported in centimetres
+ *      looks fine alone and absurd next to a person;
+ *   3. the nodes other lanes query by name survived the export. glTF has no
+ *      "empty" type, so anchors arrive as bare Object3D and are exactly what an
+ *      exporter prunes.
  *
- * Most of Lane E's verification is the Blender-side contact sheet against the
- * 1.7 m ref capsule (PLAN3D §5-E), which this harness can't see. What IS worth
- * asserting here, once the GLBs land, is the stuff that silently breaks the
- * other lanes:
- *   1. every GLB loads without error through the vendored GLTFLoader.
- *   2. scale sanity — a loaded tree's bounding box is 4–9 m tall, the fence
- *      panel is ~1.6 m, the shackle is ~0.1 m. A model exported in centimetres
- *      looks fine alone and absurd next to a person.
- *   3. the named nodes the other lanes query actually exist:
- *      tree_gum_01 → `trunk`, `canopy_*`, `branch_anchor_*`
- *      house_yardside → `fascia_anchor_*`
- *      Lane A sways the canopies by name; Lane B reads branch anchors.
- *
- * Loading is async — `export default async function run(t)` is supported.
- * Useful import:
- *   import { GLTFLoader } from '../../vendor/addons/loaders/GLTFLoader.js';
+ * Standalone version with a fuller report: tools/assetcheck/.
  */
 
-/** @param {import('../testkit.js').Suite} t */
-export default function run(t) {
-  t.skip('yard asset GLBs not landed yet — Lane E');
+import * as THREE from '../../vendor/three.module.js';
+import { assert } from '../testkit.js';
+
+// GLTFLoader is imported DYNAMICALLY, below, and that is deliberate.
+//
+// Every three.js addon imports the bare specifier `three`, which only resolves
+// via an <script type="importmap">. No page in this repo has one yet — index.html
+// and selftest.html both import `../vendor/three.module.js` by relative path and
+// so never needed it. A static import here would throw at module load, and
+// selftest.html turns an un-importable lane module into a hard FAIL, which would
+// redden Lane A's merge gate over a harness gap rather than a real defect.
+//
+// So: try it at runtime and skip with an actionable message if it's absent. The
+// day the importmap lands this suite lights up on its own, no edit needed.
+// Need + exact fix are logged in THREADS.md [E] — it blocks Lane D too, which
+// can't load a ped without GLTFLoader/SkeletonUtils.
+const LOADER_PATH = '../../vendor/addons/loaders/GLTFLoader.js';
+
+/** Resolve off import.meta.url, not the document — survives selftest.html moving. */
+const url = (a) => new URL(`../../models/${a.sub ?? ''}${a.name}_v1.glb`, import.meta.url).href;
+
+/**
+ * Height ranges rather than exact dims: this guards against unit and axis
+ * regressions, not against Lane E retuning a silhouette. Exact measurements
+ * live in tools/blender/asset_report.json. `nodes` are the names other lanes
+ * query — changing one is a contract break and should fail here.
+ */
+const ASSETS = [
+  { name: 'ref_capsule', h: [1.68, 1.72], nodes: ['ref_capsule_mesh', 'head_height'] },
+  { name: 'tree_gum_01', h: [4.0, 9.0],
+    nodes: ['trunk', 'canopy_01', 'canopy_02', 'canopy_03',
+            'branch_anchor_01', 'branch_anchor_02', 'branch_anchor_03'] },
+  { name: 'tree_gum_02', h: [4.0, 9.0],
+    nodes: ['trunk', 'canopy_01', 'canopy_02', 'branch_anchor_01', 'branch_anchor_02'] },
+  { name: 'fence_post', h: [1.8, 2.2], nodes: ['post'] },
+  { name: 'fence_panel', h: [1.6, 2.0], nodes: ['palings', 'rails'] },
+  { name: 'gate', h: [1.6, 2.0], nodes: ['gate_palings', 'gate_frame', 'hinges', 'hinge_axis'] },
+  { name: 'house_yardside', h: [2.5, 3.5],
+    nodes: ['wall', 'door', 'window', 'roof', 'fascia', 'gutter',
+            'fascia_anchor_01', 'fascia_anchor_02', 'fascia_anchor_03'] },
+  { name: 'shed_01', h: [1.9, 2.4], nodes: ['shell', 'roof', 'doors', 'door_anchor'] },
+  { name: 'shed_table', h: [0.8, 1.0], nodes: ['table_top', 'table_frame', 'pickup_anchor'] },
+  { name: 'garden_bed', h: [0.5, 1.1],
+    nodes: ['bed', 'soil', 'plants_full', 'plants_tattered', 'plants_dead'] },
+  { name: 'sail_post', h: [3.8, 4.2],
+    nodes: ['footing', 'post', 'pad_eye', 'top_anchor', 'rake_pivot'] },
+  { name: 'ladder_01', h: [2.8, 3.2], nodes: ['ladder', 'ladder_base', 'ladder_top'] },
+  { name: 'shackle', h: [0.05, 0.15], nodes: ['bow', 'pin'] },
+  { name: 'carabiner', h: [0.06, 0.15], nodes: ['body', 'gate'] },
+  { name: 'turnbuckle', h: [0.12, 0.25], nodes: ['body', 'eye_a', 'eye_b'] },
+  { name: 'tramp_01', h: [0.6, 1.0], nodes: ['mat', 'rim', 'pad', 'legs'], sub: 'debris/' },
+];
+
+function sizeOf(gltf) {
+  const s = new THREE.Vector3();
+  new THREE.Box3().setFromObject(gltf.scene).getSize(s);
+  return s;
+}
+
+/** @param {import('../testkit.js').Suite} t */
+export default async function run(t) {
+  let GLTFLoader;
+  try {
+    ({ GLTFLoader } = await import(LOADER_PATH));
+  } catch (err) {
+    t.skip('needs an importmap for the bare `three` specifier — see THREADS [E]. ' +
+           'Assets ARE verified meanwhile: tools/assetcheck/ (16/16 green in three.js r175)');
+    return;
+  }
+
+  const loader = new GLTFLoader();
+  const loaded = new Map();
+  const failed = new Map();
+
+  await Promise.all(ASSETS.map(async (a) => {
+    try { loaded.set(a.name, await loader.loadAsync(url(a))); }
+    catch (err) { failed.set(a.name, err?.message ?? String(err)); }
+  }));
+
+  t.test('every yard GLB loads through the vendored GLTFLoader', () => {
+    const lost = [...failed].map(([n, e]) => `${n} (${e})`).join('; ');
+    assert(failed.size === 0, `failed to load: ${lost}`);
+  });
+
+  // The anchor of the whole scale system. If this is wrong, every judgement
+  // made against the contact sheet was made against a lie.
+  t.test('ref_capsule is 1.70 m tall on +Y — the scale everything is judged against', () => {
+    const g = loaded.get('ref_capsule');
+    assert(g, 'ref_capsule did not load');
+    const s = sizeOf(g);
+    assert(Math.abs(s.y - 1.70) < 0.02, `capsule is ${s.y.toFixed(3)} m on Y, want 1.70`);
+    assert(s.x < 0.6 && s.z < 0.6,
+      `capsule is ${s.x.toFixed(2)} x ${s.z.toFixed(2)} in plan — height is not on +Y`);
+  });
+
+  for (const a of ASSETS) {
+    const gltf = loaded.get(a.name);
+    if (!gltf) continue;                      // already reported by the load test
+    const s = sizeOf(gltf);
+
+    t.test(`${a.name}: metre-scale, height on +Y`, () => {
+      assert(s.y >= a.h[0] && s.y <= a.h[1],
+        `${a.name} stands ${s.y.toFixed(3)} m, want ${a.h[0]}–${a.h[1]} m ` +
+        `(box ${s.x.toFixed(2)} x ${s.y.toFixed(2)} x ${s.z.toFixed(2)})`);
+    });
+
+    t.test(`${a.name}: named nodes survive the export`, () => {
+      const names = new Set();
+      gltf.scene.traverse((o) => names.add(o.name));
+      const missing = a.nodes.filter((n) => !names.has(n));
+      assert(missing.length === 0,
+        `${a.name} lost ${missing.join(', ')} — other lanes query these by name`);
+    });
+  }
+
+  // Anchors are the actual product here: Lane B pins cloth corners to them and
+  // Lane A builds world.anchors from them. A surviving name isn't enough — the
+  // position has to be usable.
+  t.test('branch_anchor_01 resolves to a usable world position up the tree', () => {
+    const g = loaded.get('tree_gum_01');
+    assert(g, 'tree_gum_01 did not load');
+    const anchor = g.scene.getObjectByName('branch_anchor_01');
+    assert(anchor, 'branch_anchor_01 missing — glTF has no "empty", check it was not pruned');
+    g.scene.updateWorldMatrix(true, true);
+    const p = new THREE.Vector3().setFromMatrixPosition(anchor.matrixWorld);
+    assert(p.y > 1.0 && p.y < 6.0,
+      `anchor sits at y=${p.y.toFixed(2)} — want 1–6 m up the trunk`);
+    assert(Number.isFinite(p.x) && Number.isFinite(p.z), 'anchor world position is not finite');
+  });
+
+  // One GLB carries three wilt states as siblings; Lane A toggles .visible
+  // rather than reloading, so all three have to be present at once.
+  t.test('garden_bed carries all 3 damage states in one GLB', () => {
+    const g = loaded.get('garden_bed');
+    assert(g, 'garden_bed did not load');
+    for (const state of ['plants_full', 'plants_tattered', 'plants_dead']) {
+      assert(g.scene.getObjectByName(state), `${state} missing — Lane A toggles these by name`);
+    }
+  });
 }

web/world/js/tests/weather.selftest.js

@@ -280,6 +280,97 @@ export function weatherCases(storms) {
     assert(Math.abs(luvS - luvB) < 1e-9, 'upwind side is being sheltered — shadow is pointing the wrong way');
   });
 
+  // ---- 9. vertical gust structure (SPRINT2 decision 3) ----
+  // Cloth pressure goes with dot(wind, normal). A flat horizontal panel's normal
+  // points at the sky, so in a perfectly horizontal wind that dot is ~0 and the
+  // cheapest winning rig is "lie it flat and ignore the storm" — the opposite of
+  // the game. Gust fronts are descending air, and descending air hits a flat
+  // panel square on. Lane B owns the cloth-side assert; these are the wind side.
+  test('gusts carry a downdraft, and still air does not', () => {
+    const f = createWindField(storms.storm_02_wildnight);
+    let peakDown = 0, betweenMax = 0;
+    for (let t = 0; t <= f.duration; t += DT) {
+      const v = f.gustVertical(t);
+      assert(v <= 1e-12, `vertical wind went UP (${v.toFixed(2)}) at t=${t.toFixed(2)} — downdraft only`);
+      const live = f.gusts.some((g) => t > g.t0 && t < g.endAt);
+      if (live) peakDown = Math.min(peakDown, v);
+      else betweenMax = Math.max(betweenMax, Math.abs(v));
+    }
+    metrics['storm_02.peakDowndraft'] = +peakDown.toFixed(2);
+    assert(betweenMax === 0, `air is falling between gusts (${betweenMax}) — downdraft must be a gust feature`);
+    assert(peakDown < -2, `peak downdraft only ${peakDown.toFixed(2)} m/s — a flat sail would still shrug it off`);
+  });
+
+  test('downdraft tracks its own gust and its JSON fraction', () => {
+    const def = storms.storm_02_wildnight;
+    const f = createWindField(def);
+    const frac = def.gusts.downdraft;
+    for (const g of f.gusts) {
+      assert(g.down >= frac * 0.6 - 1e-9 && g.down <= frac * 1.4 + 1e-9,
+        `gust at t=${g.t0.toFixed(1)} has down=${g.down.toFixed(3)}, outside 0.6–1.4× of ${frac}`);
+      // minGap >= GUST.TOTAL means gusts never overlap, so at hold it's exactly this gust
+      const atHold = f.gustVertical(g.t0 + 3);
+      assert(Math.abs(atHold - -(g.pow * g.down)) < 1e-9,
+        `at gust hold vertical is ${atHold.toFixed(3)}, want ${(-g.pow * g.down).toFixed(3)}`);
+    }
+  });
+
+  test('downdraft 0 gives a perfectly horizontal wind', () => {
+    const def = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    def.gusts.downdraft = 0;
+    const f = createWindField(def);
+    const out = { x: 0, y: 0, z: 0 };
+    for (let t = 0; t <= f.duration; t += 0.05) {
+      f.vecAt(2, -1, t, out);
+      assert(out.y === 0, `y=${out.y} at t=${t.toFixed(2)} with downdraft 0 — the opt-out leaks`);
+    }
+  });
+
+  test('downdraft does not re-time the storm', () => {
+    // The vertical draws from its own RNG stream precisely so that adding or
+    // tuning it can't shift gust times or powers. Lane A hand-drove storm_02 and
+    // watched the carabiner blow at t=45.4 and p2 cascade at t=56; a downdraft
+    // tweak silently moving those would be a nasty way to lose an afternoon.
+    const base = storms.storm_02_wildnight;
+    const a = createWindField(base);
+    for (const dd of [0, 0.1, 0.25, 0.5, 1]) {
+      const d = JSON.parse(JSON.stringify(base));
+      d.gusts.downdraft = dd;
+      const b = createWindField(d);
+      assert(a.gusts.length === b.gusts.length, `downdraft ${dd} changed the gust count`);
+      a.gusts.forEach((g, i) => {
+        assert(g.t0 === b.gusts[i].t0,
+          `downdraft ${dd} moved gust ${i} from t=${g.t0.toFixed(3)} to ${b.gusts[i].t0.toFixed(3)}`);
+        assert(g.pow === b.gusts[i].pow, `downdraft ${dd} changed gust ${i}'s power`);
+      });
+    }
+  });
+
+  test('at a gust peak the downdraft is a real fraction of the horizontal', () => {
+    const f = createWindField(storms.storm_02_wildnight);
+    const out = { x: 0, y: 0, z: 0 };
+    let bestRatio = 0, atT = 0;
+    for (let t = 0; t <= f.duration; t += DT) {
+      f.vecAt(0, 0, t, out);
+      const horiz = Math.hypot(out.x, out.z);
+      if (horiz < 1) continue;
+      const r = Math.abs(out.y) / horiz;
+      if (r > bestRatio) { bestRatio = r; atT = t; }
+    }
+    metrics['storm_02.peakVerticalRatio'] = +bestRatio.toFixed(3);
+    assert(bestRatio > 0.12,
+      `strongest downdraft is only ${(bestRatio * 100).toFixed(0)}% of the horizontal wind (t=${atT.toFixed(1)}) — a flat sail still shrugs`);
+  });
+
+  test('validator rejects a bad downdraft', () => {
+    for (const dd of [-0.1, 1.5, NaN, 'lots']) {
+      const d = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+      d.gusts.downdraft = dd;
+      const { ok } = validateStorm(d, 'broken');
+      assert(!ok, `validator ACCEPTED downdraft = ${dd}`);
+    }
+  });
+
   return { cases, metrics };
 }
 

web/world/js/weather.core.js

@@ -130,17 +130,29 @@ function sampleAngleCurve(curve, t) {
 
 // ---------- gust timeline ----------
 // Prototype: pow = 12 + rand*16 + 10*p, next = t + 5 + rand*7. Same shape, from JSON.
+export const DEFAULT_DOWNDRAFT = 0.25;
+
 export function buildGustTimeline(def, seed) {
   const g = def.gusts || {};
   const rng = mulberry32(seed >>> 0);
+  // Vertical draws from its OWN stream, deliberately. Pulling it from `rng`
+  // would shift every subsequent (t0, pow) and silently re-time storms that are
+  // already tuned and hand-verified — A drove storm_02 and watched the carabiner
+  // blow at t=45.4 and cascade at t=56, one second after the change. Adding a
+  // downdraft shouldn't move that.
+  const rngV = mulberry32((seed ^ 0x0d0117) >>> 0);
   const minGap = g.minGap ?? 5, maxGap = g.maxGap ?? 12;
+  const downFrac = g.downdraft ?? DEFAULT_DOWNDRAFT;
   const out = [];
   let t = g.firstAt ?? 3;
   // hard cap: a malformed gap can't spin us forever
   while (t < def.duration && out.length < 512) {
     const p = def.duration > 0 ? t / def.duration : 0;
     const pow = (g.powBase ?? 12) + rng() * (g.powRand ?? 16) + (g.powRamp ?? 10) * p;
-    out.push({ t0: t, pow, rampAt: t + GUST.TELEGRAPH, endAt: t + GUST.TOTAL });
+    // Not every gust slams down the same: some roll through nearly flat, some
+    // are a proper little downburst. 0.6–1.4× the storm's fraction.
+    const down = downFrac * (0.6 + rngV() * 0.8);
+    out.push({ t0: t, pow, down, rampAt: t + GUST.TELEGRAPH, endAt: t + GUST.TOTAL });
     t += minGap + rng() * Math.max(0, maxGap - minGap);
   }
   return out;
@@ -190,6 +202,26 @@ export function createWindField(def, opts = {}) {
     return sampleAngleCurve(def.dirCurve, t) + wAmp * Math.sin(t * wRate);
   }
 
+  /**
+   * Vertical wind, m/s. NEGATIVE = downward. Zero between gusts.
+   *
+   * A gust front is descending air, not just faster air. Without this the field
+   * is perfectly horizontal, and a horizontal sail is a free lunch: cloth
+   * pressure goes with dot(wind, normal), a flat panel's normal points at the
+   * sky, and the dot product is ~0 no matter how hard it blows. So the cheapest
+   * winning rig was "lie it flat and ignore the storm", which is the opposite of
+   * the game (SPRINT2 decision 3). A downdraft hits a flat panel square on.
+   */
+  function gustVertical(t) {
+    let v = 0;
+    for (let i = 0; i < gusts.length; i++) {
+      const g = gusts[i];
+      if (t <= g.t0) break;              // sorted — nothing later is live
+      if (t < g.endAt) v -= gustEnvelope(t - g.t0, g.pow) * g.down;
+    }
+    return v;
+  }
+
   // ---- noise drift ----
   // The noise pattern rides downwind with the mean flow (Taylor's frozen
   // turbulence), so a gust visibly travels ACROSS the yard instead of blinking on
@@ -278,7 +310,13 @@ export function createWindField(def, opts = {}) {
     },
     get shelters() { return shelters; },
 
-    /** Scalar wind speed (m/s) at a point. The cheap path — no allocation. */
+    /**
+     * Scalar wind speed (m/s) at a point — HORIZONTAL only, which is what an
+     * anemometer reads and what the HUD, rain and grass want. The gust downdraft
+     * is deliberately not in here: a wind meter jumping because air is falling
+     * past it would read as a bug. Use vecAt/sample for the full 3D vector.
+     * The cheap path — no allocation.
+     */
     speedAt(x, z, t) {
       const uni = uniformSpeed(t);
       const d = dirAt(t);
@@ -289,16 +327,18 @@ export function createWindField(def, opts = {}) {
     dirAt,
     uniformSpeed,
     gustOnly,
+    gustVertical,
 
     /** Writes wind velocity (m/s) into out {x,y,z}. Ground plane is XZ, +Y up. */
     vecAt(x, z, t, out) {
       const uni = uniformSpeed(t);
       const d = dirAt(t);
       const dirX = Math.cos(d), dirZ = Math.sin(d);
-      let s = uni * spatialFactor(x, z, t) * shelterFactor(x, z, dirX, dirZ);
+      const m = spatialFactor(x, z, t) * shelterFactor(x, z, dirX, dirZ);
+      let s = uni * m;
       if (s < 0) s = 0;
       out.x = dirX * s;
-      out.y = 0;                       // wind is horizontal; lift is the sail's job (Lane B)
+      out.y = gustVertical(t) * m;     // gust fronts descend — see gustVertical()
       out.z = dirZ * s;
       return out;
     },
@@ -375,6 +415,10 @@ export function validateStorm(def, name = 'storm') {
     // Overlapping gusts stack, and a stacked telegraph is unreadable to the player.
     if (minGap < GUST.TOTAL) bad(`gusts.minGap (${minGap}) < gust length ${GUST.TOTAL}s — gusts would overlap`);
     if ((g.powBase ?? 12) < 0) bad('gusts.powBase must be >= 0');
+    const dd = g.downdraft ?? DEFAULT_DOWNDRAFT;
+    if (!Number.isFinite(dd) || dd < 0 || dd > 1) {
+      bad(`gusts.downdraft must be 0..1 — the fraction of gust power that blows DOWN — got ${dd}`);
+    }
   }
 
   for (const e of def.events || []) {

web/world/js/world.js

@@ -343,7 +343,11 @@ export function createWorld(scene, opts = {}) {
     sunDir: SUN_DIR.clone(),
     solids,
     root,
+    // Lane C's skyfx MODULATES these as the storm builds and hands them back
+    // untouched on dispose() — it doesn't own them. That's why the yard exposes
+    // its lights rather than keeping them private.
     sun,
+    hemi,
 
     /** @param {string} id */
     anchor(id) {

web/world/selftest.html

@@ -35,6 +35,10 @@
   <div id="summary">running…</div>
   <div id="out"></div>
 
+<script type="importmap">
+  { "imports": { "three": "./vendor/three.module.js",
+                 "three/addons/": "./vendor/addons/" } }
+</script>
 <script type="module">
 import { runAll } from './js/testkit.js';