Log Sprint 2 landing, and block Lane C's decision 3 on real numbers

Decision 3 doesn't clear its own 60% bar: measured against lane/c over 8
headings and the full 90 s, flat-horizontal is 34% of flat-pitched, not
>=60%. The downdraft is 0.3 of the GUST component only, so storm_02's
strongest is -4.5 m/s against a 32.6 m/s horizontal peak, and pressure
goes as v^2. Needs ~0.55-0.6, or a fraction of total speed.

Also flags for A: rig.step needs the 4th debris arg or crates fly through
the sail; and the cheap-rig cascade fires at t=0.4s from pre-tension on
the 192 m2 quad, which decision 2 fixes.

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
@@ -177,3 +263,324 @@ Format: `[lane letter] YYYY-MM-DD — note`
     ~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
+    put it back the way I found it. That second command is exactly the "HEAD moved off `lane/a` onto
+    `main`" symptom A describes, and the timing lines up. Nothing was lost — the delete reported
+    `was 8338c0f`, i.e. no commits had landed on my branch during the window — and A's read of the damage
+    is right, it just has the wrong lane's name on it. Lane C has been on `~/Documents/shades-laneC/`
+    since. (Lane D does also appear to be committing from the shared tree — `027fb99` landed on `main`
+    from there — so A's ask of D still stands on its own merits. I'm only disowning the checkout.)
+    Apologies for the noise; PLAN3D §0's clone rule earns its keep.
+
+[C] 2026-07-16 — **LANE C LANDED on `lane/c` — weather.js, skyfx.js, debris.js, 2 storms.** Rebased on
+    M0; `c.test.js` is live (19 asserts) and Lane A's selftest reads **37 pass / 3 skip**. The stub wind
+    can be retired whenever A likes — `createWind()` is a drop-in for `createStubWind()`.
+      · `wind.sample(pos,t)` / `wind.gustTelegraph(t)` per contract; `checkContract('wind', …)` clean.
+      · Gusts are a **precomputed timeline**, not an integrator. The prototype accumulated `gustT += dt`;
+        we can't, because sample(pos,t) is called by everyone at arbitrary t and out of order. Same
+        envelope though — telegraph 1.5 / ramp 0.8 / hold 1.7 / fade 1.0, straight off the prototype.
+      · Storms are **data**: `data/storms/*.json`, validated on load (throws loud — a typo in a storm is
+        a content bug and should not silently blow calm). Tune curves without touching code.
+
+[C] 2026-07-16 — **CONTRACT — one addition, backward compatible.** `wind.sample(pos, t, out?)` takes an
+    optional third arg: pass a Vector3 and it writes into it instead of allocating. Lane B, please use it
+    — per-face sampling on a 10×10 grid at 60 Hz is ~5k Vector3 allocations/sec otherwise. Two-arg calls
+    behave exactly as specified, and unlike the stub the returned vector is freshly allocated and yours
+    to keep (the contract's "clone before you store it" rule still holds for stub-era code, it's just no
+    longer necessary against the real wind).
+
+[C] 2026-07-16 — **ASKS, one per lane. All degrade silently — nothing here blocks a merge.**
+      · **Lane A** — trees don't shelter anything until you tell me where they are:
+        `wind.setSheltersFromTrees(world.anchors.filter(a => a.type === 'tree'))` after the yard builds.
+        Unset = no wind shadows, which is just a flatter yard. Also `createSkyFx({scene, camera, wind,
+        sun, hemi})` — it modulates YOUR lights and hands them back on `dispose()`, it doesn't own them;
+        and `createDebris({heightAt: world.heightAt})` so debris bounces off your terrain, not y=0.
+        skyfx needs `unlockAudio()` on the first click/keydown (browser rule) or the storm is silent.
+      · **Lane B** — ❓ **the debris-vs-sail seam is your call.** I have the impulse maths but not your
+        nodes: contracts exposes `sailRig.corners`, not the cloth. Two options — (a) I keep driving it and
+        you expose `sailRig.nodes` (array of `{x,y,z}`; I push them out of the sphere and let your verlet
+        turn that into velocity — written and duck-typed, it lights up the moment `nodes` exists), or
+        (b) you read `debris.pieces` (`{x,y,z,vx,vy,vz,r,mass}`) in `sail.step` and do it yourself, since
+        you own the integrator. I'd take (b) if you want the momentum bookkeeping in one place. Say which
+        and I'll match it.
+      · **Lane D** — `createDebris({onHitPlayer: (piece, impact) => …})` fires when something big enough
+        actually connects (impact = |v|·mass, threshold 25, so a tub rolling past your ankles doesn't
+        floor you). The knockdown state machine is yours per §5-D.3; I only report the hit.
+      · **Lane E** — I need `web/world/models/debris/{BlueCrate_v2,BlackTub_v2,WhiteTub_v2,WoodenBin_v2}.glb`
+        (your §5-E.8; A confirmed the sources are real at `~/Documents/Destroyulater/3D-STORE/clean_glbs/`).
+        Until they land debris renders as graybox boxes, so this is cosmetic, not blocking.
+        `debris.setModels({name: Object3D})`. Collision is one sphere per piece — radii in `MODEL_SPEC` in
+        debris.js assume a ~0.6 m crate; if you scale them differently, tell me rather than fighting it.
+
+[C] 2026-07-16 — **Lane B: tune cloth ρ against these, not against the stub.** Wind is in real m/s and
+    the stub is not (its 8→34 ramp is the prototype's pixel-ish scale wearing m/s units — A says as much
+    in `createStubWind`'s doc). `storm_01_gentle`: sustained peaks 6.5, worst gust 11.3 m/s (41 km/h) —
+    the sail should breathe and nothing should break. `storm_02_wildnight`: sustained peaks 20 (72 km/h),
+    worst gust 32.3 (116 km/h, BOM 'destructive'), southerly change swings 2.09 rad at t=55–59 with the
+    peak landing just after it. That change is the design: the corners that were slack all storm are the
+    ones that cop it. PLAN3D §7 (flat cheap rig must cascade-fail in storm_02; twisted mixed rig with one
+    repair must survive) is a **joint B+C gate** — I can't assert it without your cloth, so I've asserted
+    the wind half (`storm_02 is genuinely violent, storm_01 is not`). Ping me when sail.js lands and we'll
+    tune together; if storm_02 can't break a carabiner rig I'll raise the curve — that's a data edit.
+
+[C] 2026-07-16 — Notes on my own files, so nobody trips over them:
+      · `weather.core.js` imports **nothing** — no THREE, no DOM, no Date.now. Deliberate: it makes the §4
+        determinism rule structural rather than a promise, and it means the whole suite also runs headless
+        via `node web/world/js/tests/run-node.mjs` (~1 s, no browser, no server). Tuning a storm curve
+        through a browser round trip is miserable. `weather.js` is the thin THREE adapter over it.
+      · Cost of that: `weather.core.js` carries its own copy of mulberry32 rather than importing
+        `contracts.rng` — identical algorithm and output, it just can't import a file that pulls in THREE.
+        `debris.js` and `skyfx.js` do use `contracts.rng`. Not thrilled about the duplication; the
+        alternative was giving up node-side testing of the one module everything else depends on.
+      · Asserts live in `js/tests/weather.selftest.js` as a plain case list; `c.test.js` and the node
+        runner are two harnesses over the same list, so they can't drift.
+      · `weather_demo.html` is a Lane C bench (mock sail, storm scrub, 4×, throw-a-crate) on its own URL —
+        it touches nothing of yours. Delete it whenever it stops earning its place.
+      · **Lane A:** a.test.js's 'gust telegraph always gives at least 1.2 s of warning' is now also
+        asserted against the real wind in c.test.js, per your note in the stub. Yours to drop when the
+        stub goes.
+
+[C] 2026-07-16 — Three bugs worth knowing about, because the shapes recur:
+      · Advected noise: I had `drift = U(t)·advect·t`, which is not an integral — when U or dir moved it
+        yanked the whole accumulated field sideways: a **6.8 m/s jump in one frame** at the southerly
+        change. Now integrated once at build time into a table. If you ever advect anything by time,
+        integrate it.
+      · Debris friction: `v *= 0.86` per frame while grounded is `0.86^60` per second — glue, not scrape.
+        It pinned a 9 kg crate at 0.7 m/s in a 19 m/s wind. Anything per-frame that should be per-second
+        needs dt.
+      · `storm_02`'s southerly change blew **north** in its first draft: the wind vector blows toward
+        `(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.
+
+[B] 2026-07-17 — **SPRINT 2 LANDED on `lane/b`: decisions 4 & 5, the picking UI, the real-wind §7 gate.**
+    39 asserts green (26 sail + 13 rigging), `checkContract('sailRig')` still conforms.
+      · **Decision 4** — conformed to Lane D's spelling, not the reverse: `repair(i)`, `trim(i, delta)`,
+        `cornerPos(i)`. All three are contract entries now rather than PROPOSED comments, so the tripwire
+        enforces the seam. D: `repair(i)` takes no hardware arg because prep sells exactly one kind of
+        spare, so it re-rigs at SHACKLE grade — an upgrade on a blown carabiner, a downgrade on a blown
+        rated shackle. `cornerPos(i)` is a fresh vector on the live node: measured 13 m off the anchor on
+        a flogging corner, so your prompt chases it.
+      · **Decision 5** — `sail.step(dt, wind, t, debris)` now applies sphere-vs-cloth impulses. Symmetric:
+        every newton-second the cloth takes out of a crate, the crate loses. Conserves to 0.000% on an
+        interior hit (asserted). Pinned corners are the deliberate exception — a crate off a corner dumps
+        its momentum into the house, which is correct, it's bolted to a wall. **Lane A: this needs the
+        4th arg — `rig.step(dt, wind, windT, debris)` in main.js, or the crates fly through the sail.**
+      · **§7 gate now runs on the real storm JSON**, not my stub. Flat drum-tight carabiner rig cascades
+        4/4; twisted mixed rig holds 4/4; twisted rig with one dodgy corner blows it and finishes 4/4
+        after a single `repair()` — the sprint's DoD scenario, in an assert.
+
+[B] 2026-07-17 — **⚠️ LANE C — decision 3 does NOT clear its own bar yet. Numbers, before you merge.**
+    Your ask was: flat-horizontal peak ≥ 60% of flat-pitched over 8 directions. Measured against your
+    branch, 8 headings, **full 90 s**: **flat-horizontal 0.56 kN vs flat-pitched 1.66 kN = 34%.** Still a
+    free lunch. Why: `downdraft: 0.3` is 0.3 of the **gust component only**, and storm_02's strongest
+    downdraft is **−4.5 m/s** against a **32.6 m/s** horizontal peak (t=75.3 s). Pressure goes as v², so
+    4.5² / (32.6·sin 16.7°)² ≈ ⅓ — which is the 34% almost exactly. To reach 60% the downdraft needs to
+    hit ~7.3 m/s, i.e. **downdraft ≈ 0.55–0.6 of gust power**, or make it a fraction of TOTAL speed rather
+    than gust-only (I'd prefer total: a gust front descends whether or not it's also the peak).
+    Your +116% A/B is real and I reproduced it (twisted rig 1.16 → 2.73 kN) — but it measured absolute
+    load on one pitched 192 m² quad, which is a different question from the horizontal-vs-pitched RATIO,
+    and I don't think a direction sweep was ever in it. Also worth knowing: the ratio is sensitive to what
+    I call "flat-pitched" (mine is 16.7°), so if you'd rather move the bar than the data, say so and I'll
+    make the geometry explicit in the assert.
+    **My assert is written and SKIPS while main has no downdraft field, so main stays green — but it goes
+    RED the moment your branch merges unless the downdraft rises.** You offered "a one-line data edit";
+    this is me taking you up on it. Ping when it's in and I'll re-measure the same sweep.
+    Two other things from your entries, both confirmed: `debris.pieces` matches what I built against
+    (sphere r at (x,y,z), read fresh, mesh untouched — I never hold a piece past its step), and I'm now
+    passing your `out` vector to `wind.sample`, which I'd been ignoring — that was ~9.7k throwaway
+    Vector3s a second. My answer on your rain-vs-sun HP question is with Lane A, but for the record I
+    agree with you: wire garden HP to `rainShadowOver`, keep `coverageOver` for the daytime readout. At
+    night the sun shadow is a number about nothing.
+
+[B] 2026-07-17 — **⚠️ LANE A — the §7 cheap-rig cascade currently fires at t=0.4 s, and it's the yard.**
+    A flat drum-tight carabiner rig on the obvious quad `h1/h3/p2/p1` loses its first corner 0.4 s after
+    the storm starts — not from the storm, from PRE-TENSION alone. 192 m² at tension 1.3 is ~6 kN per
+    corner before any wind blows (measured per-corner peaks: h1 6.10 / h3 6.00 / p2 7.25 / p1 6.01 kN).
+    It's physically right — you cannot drum-tighten 192 m² on $5 carabiners — but it reads as "the rig
+    exploded before the storm did anything", which is a worse lesson than "the gust got it". **Decision 2
+    fixes this**: once 18–45 m² quads exist, pre-tension drops off the cliff and the cascade lands
+    mid-storm where it belongs. Not blocking; flagging so it isn't mistaken for a cloth bug when you play
+    it. Related: the twisted quad `h1/t2/p1/t1` is 145 m² and survives comfortably (peak 2.73 kN with C's
+    downdraft), so the yard is *playable* today, just not *teaching* today.
+    Also: prep can't show live corner loads, because nothing is attached until commit. DESIGN.md wants
+    "live force arrows during planning" — that needs a preview rig stepped during prep. Cheap to do from
+    my side if you want it in the HUD; say the word.
+
+[B] 2026-07-17 — **Lane A — wiring the prep phase (this is your step 8).** `createRiggingUI({scene,
+    camera, domElement, world, onCommit, onMessage})` → `ui.setActive(phase === 'prep')` on phaseChange,
+    `ui.update(dt, t)` each frame, `ui.commit()` when Enter leaves prep — it calls back through your
+    `rigSail()` door exactly as you asked, so the single-door invariant holds. `ui.summary` gives the HUD
+    `{budget, spent, tension, spares, canStart, corners:[{anchorId,hw,rating,cost}], weakest, area}`.
+    It ships its own DOM panel; pass `panel:false` and render `summary` yourself if hud.js wants it.
+    It renders its own anchor markers because the yard has none to raycast against — world.js builds
+    posts and trunks, not pick targets. If you'd rather own them, take `world.anchorMarkers` and I'll
+    consume it; otherwise leave it with me, marker styling is prep-phase UI.
+    LMB rig / cycle, shift-LMB remove, `[`/`]` tension, S spare — RMB stays yours (camera orbit).
+    Verified by hand in `dev_rigging.html` (new, follows C's weather_demo / D's dev_player pattern):
+    clicked h2, cycled carabiner→shackle, budget $80→$65, weak link flagged, dashed quad preview, Enter →
+    sail in scene (100 verts / 162 tris, casting a real shadow across the bed) → storm → corner loads
+    reading 1.0–1.2 kN. **One thing worth stealing: the panel shows live sail AREA.** Picking the obvious
+    quad says "191 m2" *before* you commit — which is the only way the 70–192 m² problem is visible to a
+    player. Retire dev_rigging.html once index.html hosts prep.
+
+[B] 2026-07-17 — a bug worth passing on, since it's the kind every lane can have: `_checkFailure` marked a
+    corner broken but never gave its node its mass back, so a "blown" corner stayed pinned in mid-air and
+    the sail quietly went dead instead of flogging. **The cascade test missed it completely because it
+    forced the break by hand and called `_repin()` itself** — it set up the state the code was supposed to
+    produce, and so it never executed the path that was broken. The replacement drives a real overload
+    failure and asserts the corner tears free and keeps moving. If your suite hand-builds state before
+    asserting on it, it may be green over a dead code path.

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

@@ -0,0 +1,29 @@
+{
+  "name": "Sea Breeze",
+  "blurb": "Fresh afternoon breeze, chance of a light shower. Good day to test a rig.",
+  "rating": 1,
+  "seed": 1017,
+  "duration": 90,
+
+  "baseCurve": [[0, 3.0], [20, 5.0], [50, 6.5], [75, 6.0], [90, 5.5]],
+
+  "gusts": {
+    "firstAt": 4,
+    "minGap": 6,
+    "maxGap": 14,
+    "powBase": 2,
+    "powRand": 3,
+    "powRamp": 2
+  },
+
+  "dirCurve": [[0, 0.9], [45, 1.0], [90, 1.15]],
+  "dirWander": { "amp": 0.35, "rate": 0.09 },
+
+  "spatial": { "amp": 0.15, "scale": 12, "advect": 0.5 },
+
+  "events": [],
+
+  "rain": { "curve": [[0, 0], [30, 0.15], [55, 0.2], [80, 0.08], [90, 0]] },
+
+  "sky": { "darkness": 0.15, "cloudScroll": 0.02 }
+}

web/world/data/storms/storm_02_wildnight.json

@@ -0,0 +1,41 @@
+{
+  "name": "Wild Night",
+  "blurb": "Front crossing after dark. Southerly change around the hour mark, damaging gusts. Rig for the swing, not the lull.",
+  "rating": 4,
+  "seed": 20260716,
+  "duration": 90,
+
+  "_comment": "Sustained builds 7 -> 20 m/s (25 -> 72 km/h); worst gusts land near 33 m/s (~120 km/h), which is BOM 'destructive' and is what shreds a flat drum-tight cheap rig. Peak arrives just AFTER the southerly change, so the corners that were slack all storm are the ones that cop it.",
+
+  "_dirCurve_comment": "Radians in the XZ plane; the wind blows TOWARD (cos d, sin d). contracts.js puts north at -Z, so a southerly (blowing toward the north, into the house) needs sin(d) < 0. Starts ~0.85 = blowing toward the SE, i.e. the hot NW'er before a change; slews to ~-1.35 = blowing toward the NNE, i.e. a SSW buster off the open south side of the yard. 55->59s is the slew: ~110 deg in four seconds.",
+
+  "baseCurve": [[0, 7.0], [15, 11.0], [40, 17.0], [60, 20.0], [78, 19.0], [90, 16.0]],
+
+  "gusts": {
+    "firstAt": 3,
+    "minGap": 5.5,
+    "maxGap": 11,
+    "powBase": 3,
+    "powRand": 5,
+    "powRamp": 7
+  },
+
+  "dirCurve": [[0, 0.85], [50, 0.95], [55, 0.6], [59, -1.25], [70, -1.45], [90, -1.35]],
+  "dirWander": { "amp": 0.25, "rate": 0.13 },
+
+  "spatial": { "amp": 0.2, "scale": 11, "advect": 0.5 },
+
+  "events": [
+    { "t": 38, "type": "debris", "model": "BlueCrate_v2", "lateral": -3.5, "mass": 9, "text": "a crate comes through the fence line" },
+    { "t": 52, "type": "lightning", "power": 0.7 },
+    { "t": 55, "type": "windchange", "telegraph": 6, "over": 6, "text": "the wind swings around" },
+    { "t": 64, "type": "lightning", "power": 1.0 },
+    { "t": 66, "type": "debris", "model": "BlackTub_v2", "lateral": 2.0, "mass": 5, "text": "someone's tub is airborne" },
+    { "t": 74, "type": "debris", "model": "WoodenBin_v2", "lateral": -1.0, "mass": 14, "text": "the neighbour's bin lets go" },
+    { "t": 79, "type": "lightning", "power": 0.5 }
+  ],
+
+  "rain": { "curve": [[0, 0], [10, 0.25], [35, 0.6], [55, 0.85], [70, 1.0], [90, 0.7]] },
+
+  "sky": { "darkness": 0.8, "cloudScroll": 0.09 }
+}

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/dev_rigging.html

@@ -0,0 +1,160 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>SHADES — Lane B rigging harness</title>
+<style>
+  html, body { margin: 0; height: 100%; background: #6f7f8c; overflow: hidden;
+               font: 12px/1.5 ui-monospace, Menlo, monospace; }
+  canvas { display: block; }
+  #dev { position: fixed; bottom: 8px; left: 8px; color: #fff; text-shadow: 0 1px 2px #000;
+         white-space: pre; pointer-events: none; }
+  #hint { position: fixed; bottom: 8px; right: 8px; color: #ffd27a; text-shadow: 0 1px 2px #000;
+          text-align: right; white-space: pre; pointer-events: none; }
+</style>
+<!-- Required: world.js/sail.js pull addons that import the bare 'three' specifier. -->
+<script type="importmap">
+{ "imports": { "three": "./vendor/three.module.js", "three/addons/": "./vendor/addons/" } }
+</script>
+</head>
+<body>
+<canvas id="c"></canvas>
+<div id="dev"></div>
+<div id="hint">Lane B harness — the prep phase only.
+ENTER commits the rig and starts a storm.  R resets to prep.</div>
+
+<script type="module">
+/**
+ * Lane B harness — the prep-phase picking UI against Lane A's real yard.
+ *
+ * Same reason Lane C has weather_demo.html and Lane D has dev_player.html: the
+ * picking UI can't be asserted headless (it is clicks, raycasts and materials),
+ * and it can't be exercised in index.html until Lane A wires it in step 8. This
+ * boots the real world.js, the real anchors and the real cloth so the thing
+ * being verified is the thing that ships. Retire it once index.html hosts prep.
+ */
+import * as THREE from 'three';
+import { createWorld } from './js/world.js';
+import { createCameraRig } from './js/camera.js';
+import { createWind, loadStorm } from './js/weather.js';
+import { SailRig, createSailView } from './js/sail.js';
+import { createRiggingUI } from './js/rigging.js';
+import { FIXED_DT } from './js/contracts.js';
+
+const canvas = document.getElementById('c');
+const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+renderer.shadowMap.enabled = true;
+renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+renderer.toneMapping = THREE.ACESFilmicToneMapping;
+
+const scene = new THREE.Scene();
+
+const [calmDef, wildDef] = await Promise.all([
+  loadStorm('storm_01_gentle'), loadStorm('storm_02_wildnight'),
+]);
+// main.js multiplexes these behind a private router; the harness only ever needs
+// one at a time, so it just swaps the reference when the storm starts.
+const calmWind = createWind(calmDef);
+const wildWind = createWind(wildDef);
+let wind = calmWind;
+const windProxy = {
+  sample: (p, t, out) => wind.sample(p, t, out),
+  gustTelegraph: (t) => wind.gustTelegraph(t),
+  eventsBetween: (a, b) => wind.eventsBetween?.(a, b) ?? [],
+  setSheltersFromTrees: (trees) => { calmWind.setSheltersFromTrees?.(trees); wildWind.setSheltersFromTrees?.(trees); },
+};
+
+const world = createWorld(scene, { wind: windProxy });
+const cameraRig = createCameraRig(canvas);
+cameraRig.setSolids(world.solids);
+cameraRig.setGround(world.heightAt);
+windProxy.setSheltersFromTrees(world.anchors.filter((a) => a.type === 'tree'));
+
+const rig = new SailRig({ anchors: world.anchors });
+let sailView = null;
+
+async function rigSail(anchorIds, hwChoices, tension) {
+  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);
+}
+
+let msg = '';
+let msgT = 0;
+const ui = await createRiggingUI({
+  scene, camera: cameraRig.object, domElement: canvas, world,
+  onCommit: (ids, hw, tension) => { rigSail(ids, hw, tension); wind = wildWind; t = 0; phase = 'storm'; },
+  onMessage: (m) => { msg = m; msgT = 2; },
+});
+
+let phase = 'prep';
+ui.setActive(true);
+
+// harness-only handle, so a debugger (or an agent driving this page) can pick
+// anchors without hunting for pixels. Never imported by the game.
+window.__laneB = {
+  ui, rig, world, cameraRig, scene,
+  get phase() { return phase; },
+  /** rig by id, exactly as if you'd clicked it */
+  pick: (id) => ui.session.rig(id),
+  cycle: (id) => ui.session.cycleHardware(id),
+};
+
+addEventListener('keydown', (e) => {
+  if (e.key === 'Enter' && phase === 'prep') { if (ui.commit()) ui.setActive(false); }
+  if (e.key.toLowerCase() === 'r') {
+    phase = 'prep';
+    wind = calmWind;
+    ui.setActive(true);
+    if (sailView) { scene.remove(sailView); sailView = null; }
+  }
+});
+
+// follow-cam target: the yard centre, so prep reads as a site walk-around
+const focus = new THREE.Vector3(0, 1.2, 0);
+const dev = document.getElementById('dev');
+const clock = new THREE.Clock();
+let t = 0, acc = 0;
+
+renderer.setAnimationLoop(() => {
+  const raw = Math.min(0.25, clock.getDelta());
+  acc += raw;
+  while (acc >= FIXED_DT) {
+    t += FIXED_DT;
+    world.update(FIXED_DT, t);
+    if (phase === 'storm') rig.step(FIXED_DT, windProxy, t);
+    acc -= FIXED_DT;
+    if (msgT > 0) msgT -= FIXED_DT;
+  }
+  ui.update(raw, t);
+  sailView?.update();
+  cameraRig.update(raw, focus);
+
+  const s = ui.summary;
+  const loads = rig.rigged
+    ? rig.corners.map((c) => `${c.anchorId}:${c.broken ? 'BLOWN' : (c.load / 1000).toFixed(1) + 'kN'}`).join('  ')
+    : '(not rigged)';
+  dev.textContent =
+    `${phase.toUpperCase()}   t ${t.toFixed(1)}s   wind ${windProxy.sample(focus, t).length().toFixed(1)} m/s\n` +
+    `budget $${s.budget}  corners ${s.corners.length}/4  area ${s.area ? s.area.toFixed(0) + ' m2' : '—'}\n` +
+    `${loads}` + (msgT > 0 ? `\n!! ${msg}` : '');
+
+  renderer.render(scene, cameraRig.object);
+});
+
+addEventListener('resize', () => {
+  renderer.setSize(innerWidth, innerHeight);
+  cameraRig.object.aspect = innerWidth / innerHeight;
+  cameraRig.object.updateProjectionMatrix();
+});
+renderer.setSize(innerWidth, innerHeight);
+cameraRig.object.aspect = innerWidth / innerHeight;
+cameraRig.object.updateProjectionMatrix();
+</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

@@ -177,9 +177,20 @@ export class Emitter {
  *   angle around their centroid. tension scales spring rest lengths, 0.6–1.4
  *   (low = loose and floggy, high = drum tight and shock-loaded).
  * @property {(dt:number, wind:Wind, t:number) => void} step  Fixed dt. Deterministic.
- * @property {(rect: {x:number,z:number,w:number,d:number}) => number} coverageOver
- *   Ground-projected shade over a rect, 0..1.
+ * @property {(rect: {x:number,z:number,w:number,d:number}, sunDir?: THREE.Vector3, heightAt?: (x:number,z:number)=>number) => number} coverageOver
+ *   Ground-projected shade over a rect, 0..1. Pass world.sunDir and
+ *   world.heightAt so the rays start at the real ground and point at the real
+ *   sun; the defaults (overhead sun, flat y=0) are only for tests.
  * @property {Emitter} events               Emits 'break' and 'repair' as {type, corner}.
+ * @property {(i: number) => void} repair
+ *   Re-rig corner i with the carried spare (shackle grade — the only kind prep
+ *   sells). No-op if the corner isn't broken. Lane D's 2.5 s hold-E.
+ * @property {(i: number, delta: number) => void} trim
+ *   Per-corner turnbuckle; delta is ±, clamped to 0.85–1.15. Lane D's 1.2 s hold.
+ * @property {(i: number) => (THREE.Vector3|null)} cornerPos
+ *   LIVE world position of corner i, as a fresh vector safe to keep. A blown
+ *   corner's node is flying, so an interaction prompt anchored to this chases
+ *   the flogging corner instead of sitting on the dead anchor. null if unrigged.
  */
 
 /**
@@ -253,7 +264,7 @@ export class Emitter {
 export const CONTRACT = {
   wind:     { sample: 'function', gustTelegraph: 'function' },
   world:    { anchors: 'object', heightAt: 'function', gardenBed: 'object', sunDir: 'object', solids: 'object', update: 'function' },
-  sailRig:  { corners: 'object', attach: 'function', step: 'function', coverageOver: 'function', events: 'object' },
+  sailRig:  { corners: 'object', attach: 'function', step: 'function', coverageOver: 'function', events: 'object', repair: 'function', trim: 'function', cornerPos: 'function' },
   player:   { pos: 'object', carrying: '*', busy: '*', update: 'function' },
   interact: { register: 'function' },
   camera:   { object: 'object', yaw: 'number', update: 'function' },

web/world/js/debris.js

@@ -0,0 +1,254 @@
+'use strict';
+// SHADES — Lane C — debris: things that should have been tied down.
+//
+// Hand-rolled kinematic tumble (PLAN3D §5-C.4). No physics engine, no deps.
+// Deterministic: step(dt, t), seeded RNG, no Date.now — so a storm replays.
+//
+// Spawns off `debris` events in the storm JSON, upwind of the yard, and lets the
+// wind field carry it across. Drag goes with speed², same as the sail, so the
+// same gust that spikes a corner is the one that launches the neighbour's bin.
+
+import * as THREE from '../vendor/three.module.js';
+import { rng } from './contracts.js';
+
+const RHO = 1.2;               // air density, kg/m³
+const GRAVITY = -9.81;
+// Deceleration while resting on the ground, m/s². Drag in a 19 m/s wind gives a
+// 9 kg crate ~7 m/s², so it still skitters downwind — which is the whole point.
+const GROUND_FRICTION = 3.5;
+
+// Fallback specs for Lane E's debris set (3D-STORE crates/tubs). Radius is the
+// collision sphere, not the render bounds — a crate is boxy, but a sphere is
+// what you can afford to test 6 of per node per frame.
+const MODEL_SPEC = {
+  BlueCrate_v2: { r: 0.30, mass: 9, cd: 1.05 },
+  BlackTub_v2: { r: 0.34, mass: 5, cd: 1.10 },
+  WhiteTub_v2: { r: 0.34, mass: 5, cd: 1.10 },
+  WoodenBin_v2: { r: 0.42, mass: 14, cd: 1.05 },
+  LibraryTrolley_v1: { r: 0.45, mass: 22, cd: 0.95 },
+};
+const DEFAULT_SPEC = { r: 0.35, mass: 8, cd: 1.05 };
+
+/**
+ * @param {object} o
+ * @param {object} o.wind          from weather.js
+ * @param {THREE.Object3D} o.scene
+ * @param {Object<string,THREE.Object3D>} [o.models]  name -> template (Lane E's GLBs)
+ * @param {function} [o.onHitPlayer]  (piece, impact) — Lane D knocks the player down
+ * @param {function} [o.onEvent]      (text) — HUD ticker
+ * @param {object} [o.bounds]      {x, z} half-extents before despawn
+ */
+export function createDebris(o = {}) {
+  const wind = o.wind;
+  const scene = o.scene || null;
+  const models = o.models || {};
+  const bounds = o.bounds || { x: 26, z: 20 };
+  // contracts.js documents world.heightAt as the thing Lane C bounces debris off.
+  // Flat fallback so this still runs against a graybox yard.
+  const groundAt = o.heightAt || (() => o.groundY ?? 0);
+  const rand = rng(((wind && wind.seed) || 1) ^ 0x5eed1e);
+
+  const pieces = [];
+  const w = new THREE.Vector3();
+  const probe = new THREE.Vector3();
+
+  /** Graybox stand-in so a missing GLB can't break Lane A's merge. */
+  function placeholder(spec) {
+    const g = new THREE.BoxGeometry(spec.r * 1.8, spec.r * 1.8, spec.r * 1.8);
+    const m = new THREE.MeshStandardMaterial({ color: 0x8a6a3a, roughness: 0.9 });
+    return new THREE.Mesh(g, m);
+  }
+
+  function spawn(ev, t) {
+    const spec = { ...(MODEL_SPEC[ev.model] || DEFAULT_SPEC) };
+    if (Number.isFinite(ev.mass)) spec.mass = ev.mass;
+
+    // upwind of the yard, offset sideways, so it crosses the whole thing
+    const d = wind.dirAt(t);
+    const dx = Math.cos(d), dz = Math.sin(d);
+    const lat = ev.lateral ?? 0;
+    const dist = ev.spawnDist ?? 18;
+    const x = -dx * dist - dz * lat;
+    const z = -dz * dist + dx * lat;
+    const y = groundAt(x, z) + spec.r + (ev.height ?? 0.2 + rand() * 1.2);
+
+    const tmpl = models[ev.model];
+    const mesh = tmpl ? tmpl.clone(true) : placeholder(spec);
+    mesh.castShadow = true;
+    if (scene) scene.add(mesh);
+
+    // already moving — it's been blowing across the neighbour's yard for a while
+    probe.set(x, y, z);
+    wind.sample(probe, t, w);
+
+    const piece = {
+      model: ev.model,
+      x, y, z,
+      vx: w.x * 0.8, vy: 0, vz: w.z * 0.8,
+      // spin axis is arbitrary but seeded; rate scales with airspeed in step()
+      sx: rand() * 2 - 1, sy: rand() * 2 - 1, sz: rand() * 2 - 1,
+      spin: 0,
+      phase: rand() * 6.283,       // so two crates don't hop in lockstep
+      r: spec.r, mass: spec.mass, cd: spec.cd,
+      area: Math.PI * spec.r * spec.r,
+      hitPlayer: false,
+      mesh,
+      alive: true,
+    };
+    pieces.push(piece);
+    if (ev.text && o.onEvent) o.onEvent(ev.text);
+    return piece;
+  }
+
+  function despawn(p) {
+    p.alive = false;
+    if (scene && p.mesh) scene.remove(p.mesh);
+  }
+
+  const debris = {
+    get pieces() { return pieces; },
+
+    /** Lane E's GLBs, once they land. name -> Object3D template. */
+    setModels(map) { Object.assign(models, map); return debris; },
+
+    /** Manual spawn — handy for tuning and for Lane A's debug keys. */
+    spawn,
+
+    /**
+     * @param {number} dt fixed step
+     * @param {number} t  storm time
+     * @param {object} [world] {player, sail} — both optional, both duck-typed
+     */
+    step(dt, t, world = {}) {
+      // storm JSON drives the spawns; poll the window so nothing is missed
+      if (wind) {
+        for (const ev of wind.eventsBetween(t - dt, t)) {
+          if (ev.type === 'debris') spawn(ev, t);
+        }
+      }
+
+      const player = world.player;
+      const sail = world.sail;
+
+      for (let i = pieces.length - 1; i >= 0; i--) {
+        const p = pieces[i];
+
+        probe.set(p.x, p.y, p.z);
+        wind.sample(probe, t, w);
+
+        // drag against the AIR, not the ground: F = ½ρ Cd A |w-v| (w-v)
+        const rx = w.x - p.vx, ry = w.y - p.vy, rz = w.z - p.vz;
+        const rel = Math.hypot(rx, ry, rz);
+        const k = 0.5 * RHO * p.cd * p.area * rel / p.mass;
+        p.vx += rx * k * dt;
+        p.vy += ry * k * dt + GRAVITY * dt;
+        p.vz += rz * k * dt;
+
+        // A tumbling bluff body doesn't just get shoved, it gets picked up: lift
+        // flips sign as it rolls, which is why a bin HOPS across a yard instead
+        // of sliding. Wind is horizontal (weather.js keeps y=0), so without this
+        // there is no vertical force at all once it's down and it just skates.
+        p.vy += (0.5 * rel * rel * Math.sin(p.spin * 1.7 + p.phase) / p.mass) * dt;
+
+        p.x += p.vx * dt;
+        p.y += p.vy * dt;
+        p.z += p.vz * dt;
+
+        // ground
+        const floor = groundAt(p.x, p.z) + p.r;
+        if (p.y <= floor) {
+          p.y = floor;
+          if (p.vy < -0.5) {
+            // a real impact: bounce, and lose some tangential speed to the hit
+            p.vy = -p.vy * 0.32;                       // dead-ish, it's a plastic tub
+            p.vx *= 0.72; p.vz *= 0.72;
+          } else {
+            if (p.vy < 0) p.vy = 0;
+            // Resting: rolling friction as a dt-scaled DECELERATION, not a
+            // per-frame multiplier. `v *= 0.86` every frame is 0.86^60 per
+            // second — that isn't scrape, it's glue, and it pinned a 9 kg crate
+            // at 0.7 m/s in a 19 m/s wind.
+            const sp = Math.hypot(p.vx, p.vz);
+            if (sp > 1e-4) {
+              const drop = Math.min(sp, GROUND_FRICTION * dt);
+              p.vx -= (p.vx / sp) * drop;
+              p.vz -= (p.vz / sp) * drop;
+            }
+          }
+        }
+
+        // tumble rate follows airspeed — becalmed debris shouldn't keep spinning
+        p.spin += rel * 0.35 * dt;
+        if (p.mesh) {
+          p.mesh.position.set(p.x, p.y, p.z);
+          p.mesh.rotation.set(p.sx * p.spin, p.sy * p.spin, p.sz * p.spin);
+        }
+
+        // --- sphere vs player: knockdown ---
+        // Contract gives us player.pos; the knockdown itself is Lane D's (§5-D.3),
+        // so we just report the hit and let them run the state machine.
+        if (player && player.pos && !p.hitPlayer) {
+          const px = player.pos.x, pz = player.pos.z;
+          const py = player.pos.y + 0.9;                // centre of mass, not feet
+          const dsq = (p.x - px) ** 2 + (p.y - py) ** 2 + (p.z - pz) ** 2;
+          const hit = p.r + 0.35;
+          if (dsq < hit * hit) {
+            const impact = Math.hypot(p.vx, p.vy, p.vz) * p.mass;
+            // a bin rolling gently past your ankles shouldn't floor you
+            if (impact > 25 && o.onHitPlayer) {
+              p.hitPlayer = true;                      // one knockdown per piece
+              o.onHitPlayer(p, impact);
+              p.vx *= 0.4; p.vz *= 0.4;
+            }
+          }
+        }
+
+        // --- sphere vs sail nodes: impulse ---
+        // Duck-typed: lights up the moment Lane B exposes nodes, silent until
+        // then. See THREADS — B owns sail.js, so this is the seam we agreed on.
+        if (sail && sail.nodes) applyToSail(p, sail);
+
+        if (p.y < groundAt(p.x, p.z) - 5 || Math.abs(p.x) > bounds.x || Math.abs(p.z) > bounds.z) {
+          despawn(p);
+          pieces.splice(i, 1);
+        }
+      }
+    },
+
+    /** Drop everything (phase change, restart). */
+    clear() {
+      for (const p of pieces) despawn(p);
+      pieces.length = 0;
+    },
+  };
+
+  /**
+   * Shove any cloth node the piece is intersecting, and lose some of the piece's
+   * own momentum doing it. Expects sail.nodes: [{x,y,z,px,py,pz}] (verlet, so we
+   * move position and let the integrator turn it into velocity).
+   */
+  function applyToSail(p, sail) {
+    const nodes = sail.nodes;
+    const reach = p.r + 0.15;
+    const reachSq = reach * reach;
+    let hits = 0;
+    for (let i = 0; i < nodes.length; i++) {
+      const n = nodes[i];
+      const dx = n.x - p.x, dy = n.y - p.y, dz = n.z - p.z;
+      const dsq = dx * dx + dy * dy + dz * dz;
+      if (dsq > reachSq || dsq < 1e-9) continue;
+      const d = Math.sqrt(dsq);
+      // push the node out to the sphere surface along the contact normal
+      const push = (reach - d) / d;
+      n.x += dx * push; n.y += dy * push; n.z += dz * push;
+      hits++;
+    }
+    if (hits) {
+      const drag = Math.min(0.5, (hits * p.mass) / 400);
+      p.vx *= 1 - drag; p.vy *= 1 - drag; p.vz *= 1 - drag;
+      if (sail.onDebrisHit) sail.onDebrisHit(p, hits);
+    }
+  }
+
+  return debris;
+}

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

@@ -147,11 +147,262 @@ export class RiggingSession {
 /**
  * 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.
+ * Everything above is the rules; this is only the hands. It renders its own
+ * anchor markers because the yard has none to raycast against — world.js builds
+ * posts and trunks, not pick targets — and marker styling is prep-phase UI, so
+ * it belongs to this lane rather than to the terrain.
+ *
+ * Controls: LMB an anchor to rig it, LMB again to cycle its hardware,
+ * shift-LMB to pull it off for a full refund, [ and ] for tension, S for the
+ * spare. RMB is left alone — that's the camera's orbit. Enter belongs to Lane
+ * A's phase machine, which calls commit() on the way out of prep.
+ *
+ * @param {object}   o
+ * @param {object}   o.scene        THREE.Scene to hang markers in
+ * @param {object}   o.camera       cameraRig.object — what we raycast from
+ * @param {Element}  o.domElement   renderer.domElement — where clicks land
+ * @param {object}   o.world        needs world.anchors
+ * @param {function} o.onCommit     (anchorIds, hwChoices, tension) => void — Lane A's rigSail
+ * @param {function} [o.onMessage]  (text) => void — refusals, for the event ticker
+ * @param {boolean}  [o.panel=true] draw the built-in prep panel; false if hud.js takes it over
  */
-export async function createRiggingUI() {
-  throw new Error('rigging UI lands once Lane A has a camera and anchor markers — see THREADS.md');
+export async function createRiggingUI({
+  scene, camera, domElement, world,
+  onCommit, onMessage = () => {}, panel = true,
+} = {}) {
+  const THREE = await import('../vendor/three.module.js');
+  const session = new RiggingSession({ anchors: world.anchors });
+
+  // --- markers -----------------------------------------------------------
+  const group = new THREE.Group();
+  group.visible = false;
+  scene.add(group);
+
+  const DIM = 0x33424c;
+  const ringGeo = new THREE.TorusGeometry(0.28, 0.05, 8, 20);
+  const dotGeo = new THREE.SphereGeometry(0.1, 10, 8);
+  // What you click is NOT what you see: the ring's tube is 5 cm, which at yard
+  // distance is a couple of pixels and unhittable. Pick against an invisible
+  // sphere big enough to mean "that anchor" and let the ring just be the read.
+  const pickGeo = new THREE.SphereGeometry(0.45, 8, 6);
+  const pickMat = new THREE.MeshBasicMaterial({ visible: false });
+
+  const markers = world.anchors.map((a) => {
+    const mat = new THREE.MeshBasicMaterial({ color: DIM, transparent: true, opacity: 0.9 });
+    const ring = new THREE.Mesh(ringGeo, mat);
+    const dot = new THREE.Mesh(dotGeo, mat);
+    const hit = new THREE.Mesh(pickGeo, pickMat);
+    hit.userData.anchorId = a.id;
+    const holder = new THREE.Group();
+    holder.add(ring, dot, hit, makeLabel(THREE, a.id.toUpperCase()));
+    group.add(holder);
+    return { anchor: a, holder, ring, dot, hit, mat, label: holder.children[3] };
+  });
+  const pickTargets = markers.map((m) => m.hit);
+
+  // --- quad preview ------------------------------------------------------
+  // A closed loop through the ring-ordered picks: this is the shape you are
+  // about to build, drawn before you commit to it.
+  const previewGeo = new THREE.BufferGeometry();
+  previewGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(5 * 3), 3));
+  const preview = new THREE.Line(
+    previewGeo,
+    new THREE.LineDashedMaterial({ color: 0xffd27a, dashSize: 0.35, gapSize: 0.25 }),
+  );
+  preview.frustumCulled = false;
+  group.add(preview);
+
+  // --- panel -------------------------------------------------------------
+  const el = panel ? document.createElement('div') : null;
+  if (el) {
+    el.id = 'rigging-panel';
+    el.style.cssText = `position:fixed;top:12px;left:12px;z-index:20;display:none;
+      background:#0d1418e0;border:1px solid #2c3a44;border-radius:6px;padding:10px 12px;
+      font:12px/1.65 ui-monospace,Menlo,monospace;color:#dde5ea;min-width:280px;
+      white-space:pre;pointer-events:none`;
+    document.body.appendChild(el);
+  }
+
+  let active = false;
+  let hovered = null;
+
+  const ndc = new THREE.Vector2();
+  const ray = new THREE.Raycaster();
+  const scratch = new THREE.Vector3();
+
+  function pickAt(ev) {
+    const r = domElement.getBoundingClientRect();
+    ndc.x = ((ev.clientX - r.left) / r.width) * 2 - 1;
+    ndc.y = -((ev.clientY - r.top) / r.height) * 2 + 1;
+    ray.setFromCamera(ndc, camera);
+    return ray.intersectObjects(pickTargets, false)[0]?.object.userData.anchorId ?? null;
+  }
+
+  function say(result) {
+    if (result && result.ok === false) onMessage(result.reason);
+    return result;
+  }
+
+  function onPointerDown(ev) {
+    if (!active || ev.button !== 0) return; // RMB is the camera's
+    const id = pickAt(ev);
+    if (!id) return;
+    ev.preventDefault();
+    if (!session.isRigged(id)) say(session.rig(id));
+    else if (ev.shiftKey) say(session.unrig(id));
+    else say(session.cycleHardware(id));
+    refresh();
+  }
+
+  function onPointerMove(ev) {
+    if (!active) return;
+    hovered = pickAt(ev);
+    domElement.style.cursor = hovered ? 'pointer' : '';
+  }
+
+  function onKeyDown(ev) {
+    if (!active) return;
+    if (ev.key === '[') session.setTension(session.tension - 0.05);
+    else if (ev.key === ']') session.setTension(session.tension + 0.05);
+    else if (ev.key.toLowerCase() === 's') say(session.setSpares(session.spares ? 0 : 1));
+    else return;
+    ev.preventDefault();
+    refresh();
+  }
+
+  domElement.addEventListener('pointerdown', onPointerDown);
+  domElement.addEventListener('pointermove', onPointerMove);
+  addEventListener('keydown', onKeyDown);
+
+  /** Ground-plane area of the quad as picked, m² — the 70-192 m² problem, visible. */
+  function quadArea() {
+    if (session.picks.length !== MAX_CORNERS) return 0;
+    const p = session.picks.map((k) => world.anchors.find((a) => a.id === k.anchorId).pos);
+    const tri = (a, b, c) =>
+      new THREE.Vector3().subVectors(b, a).cross(new THREE.Vector3().subVectors(c, a)).length() * 0.5;
+    return tri(p[0], p[1], p[2]) + tri(p[0], p[2], p[3]);
+  }
+
+  function refresh() {
+    if (!el) return;
+    const s = session.summary;
+    const rows = world.anchors.map((a) => {
+      const pick = session.pickOf(a.id);
+      if (!pick) return `  ${a.id.padEnd(3)} ${a.type.padEnd(6)} —`;
+      const weak = s.weakest === a.id && session.picks.length > 1 ? '  <- weak link' : '';
+      return `  ${a.id.padEnd(3)} ${pick.hw.name.padEnd(14)} ${(pick.hw.rating / 1000).toFixed(1)} kN  $${pick.hw.cost}${weak}`;
+    });
+    const area = quadArea();
+    el.textContent = [
+      `PREP — rig four corners        $${s.budget} left`,
+      `tension ${s.tension.toFixed(2)}   spare x${s.spares}${area ? `   sail ${area.toFixed(0)} m2` : ''}`,
+      '',
+      ...rows,
+      '',
+      s.canStart ? 'ENTER to start the storm' : `pick ${MAX_CORNERS - session.picks.length} more corner(s)`,
+      'click anchor: rig / cycle hw   shift-click: remove',
+      '[ ] tension    S spare    RMB orbit',
+    ].join('\n');
+  }
+
+  const ui = {
+    session,
+    get summary() { return { ...session.summary, area: quadArea() }; },
+    get canStart() { return session.canStart; },
+    get active() { return active; },
+
+    /** Lane A: call on phaseChange — markers and clicks are prep-only. */
+    setActive(on) {
+      active = !!on;
+      group.visible = active;
+      if (el) el.style.display = active ? 'block' : 'none';
+      if (!active) domElement.style.cursor = '';
+      if (active) refresh();
+      return ui;
+    },
+
+    /** Markers ride the anchors, so a tree corner wanders before you even rig it. */
+    update(dt, t) {
+      if (!active) return;
+      for (const m of markers) {
+        const p = m.anchor.sway ? m.anchor.sway(t) : m.anchor.pos;
+        m.holder.position.set(p.x, p.y, p.z);
+        m.holder.quaternion.copy(camera.quaternion); // rings face the player
+        const pick = session.pickOf(m.anchor.id);
+        m.mat.color.setHex(pick ? pick.hw.color : DIM);
+        const s = (hovered === m.anchor.id ? 1.35 : 1) * (pick ? 1.15 : 1);
+        m.ring.scale.setScalar(s);
+        m.label.visible = !!pick || hovered === m.anchor.id;
+      }
+
+      const pos = previewGeo.attributes.position;
+      if (session.picks.length >= 2) {
+        preview.visible = true;
+        const n = session.picks.length;
+        for (let i = 0; i <= n; i++) {
+          const k = session.picks[i % n];
+          const a = world.anchors.find((x) => x.id === k.anchorId);
+          const p = a.sway ? a.sway(t) : a.pos;
+          scratch.set(p.x, p.y, p.z);
+          pos.setXYZ(i, scratch.x, scratch.y, scratch.z);
+        }
+        // degenerate tail so a partial pick doesn't draw a stale segment
+        for (let i = session.picks.length + 1; i < 5; i++) pos.setXYZ(i, scratch.x, scratch.y, scratch.z);
+        pos.needsUpdate = true;
+        previewGeo.setDrawRange(0, session.picks.length + 1);
+        preview.computeLineDistances();
+      } else {
+        preview.visible = false;
+      }
+    },
+
+    /** Hand the finished rig to Lane A's rigSail. Returns false if it isn't four corners. */
+    commit() {
+      if (!session.canStart) {
+        onMessage(`rig ${MAX_CORNERS - session.picks.length} more corner(s) first`);
+        return false;
+      }
+      onCommit(
+        session.picks.map((p) => p.anchorId),
+        session.picks.map((p) => p.hw),
+        session.tension,
+      );
+      return true;
+    },
+
+    dispose() {
+      domElement.removeEventListener('pointerdown', onPointerDown);
+      domElement.removeEventListener('pointermove', onPointerMove);
+      removeEventListener('keydown', onKeyDown);
+      scene.remove(group);
+      ringGeo.dispose(); dotGeo.dispose(); previewGeo.dispose();
+      preview.material.dispose();
+      for (const m of markers) { m.mat.dispose(); m.label.material.map?.dispose(); m.label.material.dispose(); }
+      el?.remove();
+    },
+  };
+
+  refresh();
+  return ui;
+}
+
+/** A cheap canvas-texture nameplate, so anchors read as h1/t2/p1 rather than dots. */
+function makeLabel(THREE, text) {
+  const c = document.createElement('canvas');
+  c.width = 128; c.height = 64;
+  const g = c.getContext('2d');
+  g.font = 'bold 40px ui-monospace, Menlo, monospace';
+  g.textAlign = 'center';
+  g.textBaseline = 'middle';
+  g.lineWidth = 6;
+  g.strokeStyle = '#0d1418';
+  g.strokeText(text, 64, 32);
+  g.fillStyle = '#dde5ea';
+  g.fillText(text, 64, 32);
+  const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
+    map: new THREE.CanvasTexture(c), depthTest: false, transparent: true,
+  }));
+  sprite.position.set(0, 0.55, 0);
+  sprite.scale.set(0.8, 0.4, 1);
+  return sprite;
 }

web/world/js/sail.js

@@ -18,10 +18,17 @@
  * appears in createSailView(), which is imported lazily.
  */
 
+import * as THREE from '../vendor/three.module.js';
 import { Emitter, FIXED_DT, HARDWARE } from './contracts.js';
 
 export { HARDWARE };
 
+/**
+ * What a carried spare re-rigs a corner with. The prep phase sells exactly one
+ * kind ("spare shackle, $15"), so repair() has no hardware argument to take.
+ */
+const SPARE_HW = HARDWARE[1];
+
 // ---------- 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
@@ -49,6 +56,10 @@ 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
 
+// ---------- debris (SPRINT2 decision 5) ----------
+const DEBRIS_RESTITUTION = 0.1; // a wheelie bin into shade cloth barely bounces
+const DEBRIS_SKIN = 0.06;       // contact margin, ~cloth thickness
+
 // ---------- 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
@@ -114,6 +125,11 @@ export class SailRig {
     this._acc = 0;
     // scratch, reused every face to keep the hot loop allocation-free
     this._probe = { x: 0, y: 0, z: 0 };
+    // Lane C's wind.sample(pos, t, out) takes an out-vector so we don't allocate
+    // one per face per substep — 162 faces at 60 Hz is ~9.7k throwaway Vector3s
+    // a second otherwise. A stub wind that ignores `out` still works: we read
+    // the RETURN value, not this.
+    this._windOut = new THREE.Vector3();
   }
 
   /**
@@ -306,16 +322,20 @@ export class SailRig {
    * 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
+   * @param {number} dt      seconds elapsed since last call
+   * @param {object} wind    { sample(pos, t) -> {x,y,z} }
+   * @param {number} t       world time, seconds
+   * @param {object} [debris] Lane C's debris module, or anything with `.pieces`.
+   *                          Optional — the cloth runs fine without a storm's
+   *                          worth of crates in it.
    */
-  step(dt, wind, t) {
+  step(dt, wind, t, debris = null) {
     if (!this.rigged) return;
+    const pieces = debris ? (debris.pieces ?? debris) : null;
     this._acc += dt;
     let n = 0;
     while (this._acc >= SIM_DT && n < MAX_SUBSTEPS) {
-      this._substep(SIM_DT, wind, this.t);
+      this._substep(SIM_DT, wind, this.t, pieces);
       this._acc -= SIM_DT;
       this.t += SIM_DT;
       n++;
@@ -323,8 +343,9 @@ export class SailRig {
     if (n === MAX_SUBSTEPS) this._acc = 0; // dropped frames: don't try to catch up
   }
 
-  _substep(dt, wind, t) {
+  _substep(dt, wind, t, pieces) {
     this._accumulateWind(wind, t, dt);
+    if (pieces && pieces.length) this._applyDebris(pieces, 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);
@@ -357,7 +378,7 @@ export class SailRig {
       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);
+      const w = wind.sample(probe, t, this._windOut);
 
       // Relative wind, not absolute: as the cloth accelerates downwind the load
       // bleeds off by itself. This is what stops flogging from exploding.
@@ -382,6 +403,88 @@ export class SailRig {
     }
   }
 
+  /**
+   * Sphere-vs-cloth impulses for Lane C's debris (SPRINT2 decision 5, option b).
+   *
+   * The exchange is symmetric: every newton-second the cloth takes out of a
+   * crate, the crate loses. That's the point of the decision — one integrator
+   * does the momentum bookkeeping, so a crate punching through a sail slows
+   * down by exactly as much as it speeds the cloth up. Asserted in
+   * sail.selftest.js.
+   *
+   * Pinned corners are the deliberate exception: they have invMass 0, so a
+   * crate that hits one bounces off and the momentum goes into the house. That
+   * is correct — the anchor is bolted to a wall — and it's why the momentum
+   * assert uses an interior hit.
+   *
+   * @param {Array} pieces  debris.pieces — {x,y,z,vx,vy,vz,r,mass}
+   */
+  _applyDebris(pieces, dt) {
+    const pos = this.pos, prev = this.prev, im = this.invMass;
+    for (const p of pieces) {
+      if (p.alive === false || !Number.isFinite(p.mass) || p.mass <= 0) continue;
+
+      // Swept: main.js steps the sail BEFORE the debris, so these positions are
+      // a frame stale, and a 0.3 m crate at 25 m/s covers 0.42 m in a frame —
+      // enough to pass clean between cloth nodes. Growing the contact radius by
+      // the piece's travel catches both the lag and the tunnelling.
+      const speed = Math.hypot(p.vx, p.vy, p.vz);
+      const solid = p.r + DEBRIS_SKIN;
+      const reach = solid + speed * dt;
+      const reachSq = reach * reach;
+      const wPiece = 1 / p.mass;
+
+      let jx = 0, jy = 0, jz = 0, hits = 0;
+      for (let n = 0; n < im.length; n++) {
+        const i = n * 3;
+        const dx = pos[i] - p.x, dy = pos[i + 1] - p.y, dz = pos[i + 2] - p.z;
+        const dsq = dx * dx + dy * dy + dz * dz;
+        if (dsq > reachSq || dsq < 1e-12) continue;
+        const d = Math.sqrt(dsq);
+        const nx = dx / d, ny = dy / d, nz = dz / d; // piece centre -> node
+
+        // node velocity, read out of verlet
+        const vnx = (pos[i] - prev[i]) / dt;
+        const vny = (pos[i + 1] - prev[i + 1]) / dt;
+        const vnz = (pos[i + 2] - prev[i + 2]) / dt;
+        const vrel = (vnx - p.vx) * nx + (vny - p.vy) * ny + (vnz - p.vz) * nz;
+        if (vrel > 0) continue; // already separating — don't glue them together
+
+        const wNode = im[n];
+        const denom = wNode + wPiece;
+        if (denom < 1e-12) continue;
+        const j = (-(1 + DEBRIS_RESTITUTION) * vrel) / denom;
+        hits++;
+
+        // node takes +j along the contact normal; verlet stores velocity as a
+        // position difference, so the impulse goes in by moving `prev`
+        prev[i] -= nx * j * wNode * dt;
+        prev[i + 1] -= ny * j * wNode * dt;
+        prev[i + 2] -= nz * j * wNode * dt;
+
+        // ...and the piece takes exactly -j. This is the conservation.
+        jx -= nx * j; jy -= ny * j; jz -= nz * j;
+
+        // Depenetrate free nodes by moving pos AND prev together, so pushing
+        // the cloth off the crate doesn't secretly inject velocity.
+        if (wNode > 0 && d < solid) {
+          const push = solid - d;
+          pos[i] += nx * push; prev[i] += nx * push;
+          pos[i + 1] += ny * push; prev[i + 1] += ny * push;
+          pos[i + 2] += nz * push; prev[i + 2] += nz * push;
+        }
+      }
+
+      if (hits) {
+        p.vx += jx * wPiece; p.vy += jy * wPiece; p.vz += jz * wPiece;
+        this.events.emit('debrisHit', {
+          type: 'debrisHit', piece: p, nodes: hits,
+          impulse: Math.hypot(jx, jy, jz), t: this.t,
+        });
+      }
+    }
+  }
+
   _integrate(dt) {
     const pos = this.pos, prev = this.prev, F = this.force, im = this.invMass;
     const dt2 = dt * dt;
@@ -503,8 +606,43 @@ export class SailRig {
     if (this._dirtyRest) { this._applyRestLengths(); this._dirtyRest = false; }
   }
 
+  // --- Lane D's seam (SPRINT2 decision 4) --------------------------------
+  // D landed first and duck-typed these against the rig, so B conforms to D's
+  // spelling rather than the other way round. Thin aliases on purpose: the
+  // behaviour lives in repairCorner/trimCorner, these just match the call sites
+  // in interact.js and are what contracts.js promises.
+
+  /**
+   * Re-rig corner `i` with the spare the player was carrying. The spare is the
+   * "$15 spare shackle" the prep phase sells, so it re-rigs at shackle grade —
+   * which can be an UPGRADE on a corner that blew a carabiner, and a downgrade
+   * on one that blew a rated shackle. That's the prototype's behaviour and it's
+   * a real decision about which corner you run back to.
+   * @param {number} i
+   */
+  repair(i) { this.repairCorner(i, SPARE_HW); }
+
+  /**
+   * Per-corner turnbuckle. @param {number} i @param {number} delta ±, clamped 0.85–1.15.
+   */
+  trim(i, delta) { this.trimCorner(i, delta); }
+
+  /**
+   * Live world position of corner `i`, as a FRESH vector — a blown corner's node
+   * is flying, so Lane D's prompt has to chase it rather than sit on the anchor.
+   * Fresh (not shared scratch) because interact.js holds the result across the
+   * frame and two corners are read back to back.
+   * @param {number} i
+   * @returns {THREE.Vector3|null}
+   */
+  cornerPos(i) {
+    if (!this.rigged || !this.corners[i]) return null;
+    const n = this.cornerIdx[i] * 3;
+    return new THREE.Vector3(this.pos[n], this.pos[n + 1], this.pos[n + 2]);
+  }
+
   /** Re-rig a blown corner with fresh hardware. Lane D's hold-E repair calls this. */
-  repairCorner(index, hw = HARDWARE[1]) {
+  repairCorner(index, hw = SPARE_HW) {
     const c = this.corners[index];
     if (!c || !c.broken) return false;
     c.broken = false;
@@ -539,8 +677,10 @@ export class SailRig {
    * @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.
+   * @param {function} heightAt  world.heightAt — rays start at the real ground.
+   *                         Defaults to a flat y=0, which is only right for tests.
    */
-  coverageOver(rect, sunDir = { x: 0, y: 1, z: 0 }) {
+  coverageOver(rect, sunDir = { x: 0, y: 1, z: 0 }, heightAt = null) {
     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;
@@ -553,7 +693,8 @@ export class SailRig {
         // 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++;
+        const oy = heightAt ? heightAt(ox, oz) : 0;
+        if (this._rayHitsSail(ox, oy, oz, dx, dy, dz)) hit++;
       }
     }
     return hit / (COLS * ROWS);

web/world/js/sail.selftest.js

@@ -12,9 +12,57 @@
 
 import { SailRig } from './sail.js';
 import { HARDWARE, FIXED_DT, createStubWind, rng } from './contracts.js';
+import { createWindField } from './weather.core.js';
 
 const SIM_DT = FIXED_DT;
 
+// ---------- real storm wind (SPRINT2 B-4) ----------
+// The §7 gate used to run on the local stub, which is uniform, horizontal and
+// tuned by nobody. These load the storms design actually ships and drive the
+// cloth with them. weather.core.js is pure and import-free, so the same code
+// path works in node and in Lane A's selftest.html; only reading the JSON off
+// disk differs, and weather.js's own loadStorm can't help there (its STORM_DIR
+// is a file:// URL under node, which fetch won't open).
+
+async function loadStormDef(name) {
+  const url = new URL(`../data/storms/${name}.json`, import.meta.url);
+  if (typeof process !== 'undefined' && process.versions?.node) {
+    const { readFile } = await import('node:fs/promises');
+    return JSON.parse(await readFile(url, 'utf8'));
+  }
+  return (await fetch(url)).json();
+}
+
+const STORM_02 = await loadStormDef('storm_02_wildnight');
+
+/** A Wind over a real storm def. Same field the game flies. */
+function realWind(def = STORM_02, opts = {}) {
+  const field = createWindField(def, opts);
+  const out = { x: 0, y: 0, z: 0 };
+  return {
+    sample(pos, t) { return field.vecAt(pos.x, pos.z, t, out); },
+    speedAt(t) { field.vecAt(0, 0, t, out); return Math.hypot(out.x, out.z); },
+    gustTelegraph: (t) => field.gustTelegraph?.(t) ?? null,
+  };
+}
+
+/** Lane A's yard, verbatim (THREADS: "yard layout is now FACT"). */
+const YARD = [
+  ['h1', 'house', -5, 2.6, -9.9], ['h2', 'house', 0, 2.6, -9.9], ['h3', 'house', 5, 2.6, -9.9],
+  ['t1', 'tree', -9, 3.2, 2], ['t2', 'tree', 8, 3.1, -2],
+  ['p1', 'post', -6.4, 3.9, 7.4], ['p2', 'post', 5.3, 3.9, 8],
+].map(([id, type, x, y, z]) => {
+  const pos = { x, y, z };
+  // Static on purpose: tree sway is world.js's, and mixing it in here would make
+  // a cloth assert fail for a reason that isn't the cloth. Sway is exercised in
+  // the game and in a.test.
+  return { id, type, pos, sway: () => pos };
+});
+
+const yardRig = (ids, hw, tension) =>
+  new SailRig({ anchors: YARD, gridN: 10 })
+    .attach(ids, Array.isArray(hw) ? hw : Array(4).fill(hw), tension);
+
 // ---------- 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,
@@ -66,10 +114,17 @@ const FOOT = [
 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) =>
+/**
+ * Anchors shaped like contracts.js Anchor: sway(t) is the ABSOLUTE position.
+ * `theta` spins the footprint about the yard's Y axis — which is how you sweep
+ * wind direction against a real storm, whose direction curve you don't get to
+ * choose. Rotating the rig under the wind and rotating the wind over the rig are
+ * the same experiment; only one of them is available with authored storm JSON.
+ */
+export const makeAnchors = (heights, theta = 0) =>
   FOOT.map((f, i) => {
-    const pos = { x: f.x, y: heights[i], z: f.z };
+    const c = Math.cos(theta), s = Math.sin(theta);
+    const pos = { x: f.x * c - f.z * s, y: heights[i], z: f.x * s + f.z * c };
     return { id: `a${i}`, type: 'post', pos, sway: () => pos };
   });
 
@@ -332,6 +387,260 @@ test('break and repair emit on the events Emitter', () => {
   return `repaired corner back to ${kN(r.corners[0].load)}, ${seen.length} event(s) emitted`;
 });
 
+// --- SPRINT2 decision 4: the seam Lane D already calls ---------------------
+
+test('decision 4: repair(i) re-rigs a blown corner with the spare', () => {
+  const w = constantWind({ x: 0, y: 0, z: 20 });
+  const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[0] });
+  runStorm(r, w, 4);
+  r.corners[0].broken = true;
+  r._repin(r.t);
+
+  // exactly Lane D's interact.js call: no hardware argument, return ignored
+  r.repair(0);
+  assert(!r.corners[0].broken, 'repair(0) should have re-rigged the corner');
+  assert(r.corners[0].hw === HARDWARE[1], `spare should re-rig at shackle grade, got ${r.corners[0].hw.name}`);
+  assert(r.invMass[r.cornerIdx[0]] === 0, 'repaired corner should be pinned again');
+  runStorm(r, w, 3);
+  assert(r.corners[0].load > 100, `repaired corner only pulling ${kN(r.corners[0].load)}`);
+  return `repair(0) -> ${r.corners[0].hw.name}, back to ${kN(r.corners[0].load)}`;
+});
+
+test('decision 4: repair(i) on an intact corner is a no-op', () => {
+  const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[2] });
+  runStorm(r, constantWind({ x: 0, y: 0, z: 12 }), 2);
+  const hw = r.corners[1].hw;
+  r.repair(1); // D gates on corner.broken, but the rig must not trust that
+  assert(r.corners[1].hw === hw, 'repairing an intact corner downgraded its hardware');
+  return 'intact corner untouched';
+});
+
+test('decision 4: trim(i, delta) tightens one corner only', () => {
+  const r = rig(HEIGHTS_HYPAR);
+  r.trim(0, +0.1);
+  assert(Math.abs(r.corners[0].trim - 1.1) < 1e-9, `corner 0 trim ${r.corners[0].trim}`);
+  assert(r.corners[1].trim === 1.0, 'trim leaked onto a neighbour');
+  for (let i = 0; i < 40; i++) r.trim(0, +0.1); // Lane D can hold the key down
+  assert(r.corners[0].trim <= 1.15 + 1e-9, `trim ran past its clamp: ${r.corners[0].trim}`);
+  return `trim clamps at ${r.corners[0].trim.toFixed(2)}, neighbours unmoved`;
+});
+
+test('decision 4: cornerPos(i) is live, fresh, and chases a flogging corner', () => {
+  const w = makeStubWind({ seed: 11, stormLen: 90 });
+  const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.3 });
+  const anchor = r.corners[0].anchor.pos;
+  const p0 = r.cornerPos(0);
+  assert(Math.hypot(p0.x - anchor.x, p0.y - anchor.y, p0.z - anchor.z) < 1e-6,
+    'an intact corner should report its anchor position');
+  assert(r.cornerPos(0) !== r.cornerPos(0), 'cornerPos must return a FRESH vector, not shared scratch');
+
+  // blow it, then confirm the prompt would follow the flying corner
+  r.corners[0].broken = true;
+  r._repin(r.t);
+  runStorm(r, w, 6);
+  const p1 = r.cornerPos(0);
+  const drift = Math.hypot(p1.x - anchor.x, p1.y - anchor.y, p1.z - anchor.z);
+  assert(drift > 0.3, `blown corner's prompt only moved ${drift.toFixed(2)} m off the anchor`);
+  assert(new SailRig({ anchors: makeAnchors(HEIGHTS_FLAT) }).cornerPos(0) === null,
+    'cornerPos on an unrigged rig should be null, not a throw');
+  return `prompt tracks the blown corner ${drift.toFixed(2)} m off its anchor`;
+});
+
+// --- SPRINT2 decision 5: debris -------------------------------------------
+
+const crate = (over) => ({ x: 0, y: 3.25, z: 0, vx: 0, vy: 0, vz: 14, r: 0.3, mass: 9, alive: true, ...over });
+
+test('decision 5: a crate hitting the sail conserves momentum', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4); // settle, so the cloth isn't ringing
+  // aimed at the belly, not a corner: a pinned corner would (correctly) dump
+  // momentum into the house and there'd be nothing to conserve
+  const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
+  const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.25, z: r.pos[mid * 3 + 2], vy: 6, vz: 0 });
+
+  const clothP = () => {
+    let x = 0, y = 0, z = 0;
+    for (let n = 0; n < r.invMass.length; n++) {
+      if (r.invMass[n] === 0) continue; // pinned: its momentum belongs to the house
+      const i = n * 3;
+      x += (r.pos[i] - r.prev[i]) / SIM_DT * r.nodeMass;
+      y += (r.pos[i + 1] - r.prev[i + 1]) / SIM_DT * r.nodeMass;
+      z += (r.pos[i + 2] - r.prev[i + 2]) / SIM_DT * r.nodeMass;
+    }
+    return { x, y, z };
+  };
+  const total = () => {
+    const c = clothP();
+    return { x: c.x + p.vx * p.mass, y: c.y + p.vy * p.mass, z: c.z + p.vz * p.mass };
+  };
+
+  const before = total();
+  r._applyDebris([p], SIM_DT);
+  const after = total();
+
+  const drift = Math.hypot(after.x - before.x, after.y - before.y, after.z - before.z);
+  const scale = Math.hypot(before.x, before.y, before.z);
+  assert(scale > 1, 'test crate carries no momentum to conserve');
+  assert(drift / scale < 0.01, `momentum drifted ${drift.toFixed(3)} of ${scale.toFixed(1)} kg·m/s (${(drift / scale * 100).toFixed(1)}%)`);
+  assert(p.vy < 6, `the crate should have LOST speed to the cloth, still at ${p.vy.toFixed(2)} m/s`);
+  return `crate ${scale.toFixed(0)} kg·m/s, exchange conserves to ${(drift / scale * 100).toFixed(3)}%`;
+});
+
+test('decision 5: a crate through the sail shoves the cloth and emits', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4);
+  const hits = [];
+  r.events.on('debrisHit', (e) => hits.push(e));
+
+  const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
+  const before = r.pos[mid * 3 + 1];
+  const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.6, z: r.pos[mid * 3 + 2], vy: 12, vz: 0 });
+  const v0 = p.vy;
+
+  // Peak, not final: the crate crosses the cloth in about three frames and the
+  // membrane springs back well inside the run, so sampling the end measures the
+  // recovery rather than the punch.
+  const wind = makeStubWind({ calm: true });
+  let peak = before;
+  for (let i = 0; i < 30; i++) {
+    r.step(SIM_DT, wind, i * SIM_DT, { pieces: [p] });
+    p.y += p.vy * SIM_DT; p.z += p.vz * SIM_DT;
+    peak = Math.max(peak, r.pos[mid * 3 + 1]);
+  }
+  assert(hits.length > 0, 'crate passed through the cloth without a single contact');
+  assert(peak > before + 0.05, `belly only lifted ${(peak - before).toFixed(3)} m — the crate went straight through`);
+  assert(p.vy < v0, `crate left at ${p.vy.toFixed(2)} m/s, never paid for the punch (entered at ${v0})`);
+  return `${hits.length} contacts, belly punched ${(peak - before).toFixed(2)} m, crate ${v0} -> ${p.vy.toFixed(1)} m/s`;
+});
+
+test('decision 5: no debris and empty debris are both fine', () => {
+  const w = makeStubWind({ seed: 2, stormLen: 20 });
+  const a = rig(HEIGHTS_HYPAR), b = rig(HEIGHTS_HYPAR);
+  for (let i = 0; i < 600; i++) {
+    a.step(SIM_DT, w, i * SIM_DT);                    // Lane A's 3-arg call still works
+    b.step(SIM_DT, makeStubWind({ seed: 2, stormLen: 20 }), i * SIM_DT, { pieces: [] });
+  }
+  for (let k = 0; k < 4; k++) {
+    assert(Math.abs(a.corners[k].load - b.corners[k].load) < 1e-9,
+      'an empty debris list changed the sim');
+  }
+  return 'empty and absent debris both no-op';
+});
+
+// --- SPRINT2 B-4: the §7 gate, against the wind the game actually flies ------
+
+// PLAN3D §7: "A flat drum-tight cheap rig MUST cascade-fail in storm_02; a
+// well-twisted mixed rig with one mid-storm repair MUST be survivable." The old
+// version of this proved it against my own stub wind, which is uniform,
+// horizontal and tuned by nobody — so it proved the cloth was self-consistent,
+// not that the game works. This is the real storm JSON, the real yard, and the
+// same two rig shapes Lane C measured decision 3 against.
+test('§7 gate on REAL storm_02: cheap flat rig cascades', () => {
+  const rig = yardRig(['h1', 'h3', 'p2', 'p1'], HARDWARE[0], 1.3); // drum-tight carabiners
+  const broke = [];
+  rig.events.on('break', (e) => broke.push(e));
+  const w = realWind();
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) rig.step(SIM_DT, w, i * SIM_DT);
+  const lost = rig.corners.filter((c) => c.broken).length;
+  assert(lost >= 2, `flat drum-tight carabiner rig only lost ${lost}/4 in the real storm_02 — no cascade`);
+  return `lost ${lost}/4, first at t=${broke[0].t.toFixed(1)}s (${broke[0].anchorId}, ${broke[0].hw})`;
+});
+
+test('§7 gate on REAL storm_02: twisted mixed rig survives', () => {
+  // Lane C's shape: h1 (house, 2.6) / t2 (tree, 3.1) / p1 (post, 3.9) / t1 (tree, 3.2)
+  // — corners at four different heights, i.e. an actual hypar, eased off tight.
+  const rig = yardRig(['h1', 't2', 'p1', 't1'], [HARDWARE[2], HARDWARE[1], HARDWARE[2], HARDWARE[1]], 0.85);
+  const w = realWind();
+  let peak = 0;
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
+    rig.step(SIM_DT, w, i * SIM_DT);
+    peak = Math.max(peak, rig.maxLoad());
+  }
+  const lost = rig.corners.filter((c) => c.broken).length;
+  assert(lost === 0, `well-twisted mixed rig lost ${lost}/4 in storm_02 — §7 says it must be survivable`);
+  return `all 4 corners held, peak ${kN(peak)} (area ${rig.area.toFixed(0)} m2)`;
+});
+
+test('§7 gate on REAL storm_02: twisted rig + one repair on the dodgy corner', () => {
+  // The other half of §7: "a well-twisted mixed rig with ONE mid-storm repair
+  // MUST be survivable". The twisted rig above already survives outright, so
+  // the interesting scenario is DESIGN.md's: the budget forces one dodgy corner
+  // ($80 buys rated on at most two of four), that corner blows, and you run out
+  // and re-rig it once with the carried spare — exactly Lane D's hold-E.
+  // An $80-exact loadout: rated h1 ($30) + shackle t1 ($15) + shackle p1 ($15)
+  // + carabiner t2 ($5) + spare ($15). The carabiner goes on t2 because that is
+  // where the load actually IS — measured peaks on this shape are h1 1.68 /
+  // t2 2.73 / p1 2.17 / t1 0.81 kN. Putting the cheap corner on t1 (the
+  // lightest) is what a player does by accident and it survives the storm
+  // having proved nothing; putting it on t2 is the real bet.
+  const rig = yardRig(
+    ['h1', 't2', 'p1', 't1'],
+    [HARDWARE[2], HARDWARE[0], HARDWARE[1], HARDWARE[1]],
+    0.85,
+  );
+  const w = realWind();
+  let repairs = 0;
+  rig.events.on('break', () => { /* seen below; repairing inside the emit would reenter step */ });
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
+    rig.step(SIM_DT, w, i * SIM_DT);
+    if (repairs === 0) {
+      const k = rig.corners.findIndex((c) => c.broken);
+      if (k >= 0) { rig.repair(k); repairs++; }
+    }
+  }
+  const lost = rig.corners.filter((c) => c.broken).length;
+  if (repairs === 0) {
+    // A vacuous pass is worse than a skip: "nothing broke" would let this go
+    // green forever while proving nothing. Storm_02 can't threaten a shackle
+    // rig until Lane C's downdraft lands (their A/B: shackle blows at t=20.8 s
+    // with downdraft 0.3, never without). Lights up by itself on merge.
+    assert(
+      !STORM_02.gusts?.downdraft,
+      'storm_02 HAS a downdraft and still could not blow a shackle rig — the repair scenario is vacuous',
+    );
+    return 'SKIPPED — nothing blew; needs Lane C decision 3 downdraft to threaten a shackle rig';
+  }
+  assert(lost <= 1, `after one repair the rig still lost ${lost}/4 — not survivable`);
+  return `${repairs} repair, finished ${4 - lost}/4 corners intact`;
+});
+
+// --- SPRINT2 decision 3 / B-6: the flat-horizontal loophole ------------------
+
+// My Sprint 1 finding: a flat HORIZONTAL sail was the lowest-load rig of all
+// (1.14 kN vs a pitched flat's 3.06), because a horizontal plate in horizontal
+// wind has almost no drag — which inverted DESIGN.md's "big, flat, low = death
+// in a storm". Lane C closed it by making gusts descend. This is the assert
+// decision 3 asks Lane B for.
+test('decision 3: flat-horizontal is no longer a free lunch', () => {
+  const downdraft = STORM_02.gusts?.downdraft ?? 0;
+  if (!downdraft) {
+    // Feature-detected rather than hard-failed: this assert is only meaningful
+    // once Lane C's downdraft is on main. It lights up by itself on merge.
+    return 'SKIPPED — storm_02 has no gusts.downdraft yet (Lane C decision 3 not merged)';
+  }
+  const FLAT_H = [3.25, 3.25, 3.25, 3.25];
+  // Spin the rig through 8 headings under the real storm. (Re-seeding the wind
+  // instead would only reshuffle gust TIMING — the direction curve is authored
+  // in the JSON and doesn't move — so it would look like a sweep and measure
+  // nothing about direction.)
+  const sweep = (heights) => {
+    let worst = 0;
+    for (let k = 0; k < 8; k++) {
+      const r = new SailRig({ anchors: makeAnchors(heights, (k / 8) * Math.PI * 2), gridN: 10 })
+        .attach(ALL_IDS, Array(4).fill(UNBREAKABLE), 1.0);
+      // full duration: storm_02's own note says the peak lands just AFTER the
+      // southerly change, so a 45 s sweep measures the wrong half of the storm
+      worst = Math.max(worst, runStorm(r, realWind(), STORM_02.duration));
+    }
+    return worst;
+  };
+  const pitched = sweep(HEIGHTS_FLAT);
+  const horizontal = sweep(FLAT_H);
+  const ratio = horizontal / pitched;
+  assert(ratio >= 0.6, `flat-horizontal peaks at only ${(ratio * 100).toFixed(0)}% of flat-pitched (${kN(horizontal)} vs ${kN(pitched)}) — still a free lunch`);
+  return `flat-horizontal ${kN(horizontal)} vs flat-pitched ${kN(pitched)} = ${(ratio * 100).toFixed(0)}% (downdraft ${downdraft})`;
+});
+
 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.

web/world/js/skyfx.js

@@ -0,0 +1,470 @@
+'use strict';
+// SHADES — Lane C — skyfx: rain, storm sky, lightning, and the noise of it all.
+//
+// PLAN3D §5-C.2/§5-C.3. Lane A's world.js owns the calm sky and the base lights;
+// this MODULATES them as the storm builds and hands them back on dispose(), so
+// two lanes never fight over one scene.
+//
+// Everything is duck-typed and optional — no sun light, no audio, no sail? Then
+// those layers just don't run. Lane A can wire the pieces as they land.
+//
+// Audio is synthesized, not sampled: web/world/audio/ is empty, we ship no CDN
+// and no deps, and a filtered-noise bed tracks wind speed better than a loop.
+
+import * as THREE from '../vendor/three.module.js';
+import { rng } from './contracts.js';
+import { valueNoise2 } from './weather.core.js';
+
+const lerp = (a, b, k) => a + (b - a) * k;
+const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);
+
+const CALM_SKY = new THREE.Color(0x9fc4e8);
+const STORM_SKY = new THREE.Color(0x2a2f3a);
+const NIGHT_SKY = new THREE.Color(0x11141c);
+
+// ---------------------------------------------------------------- rain
+function createRain(opts) {
+  const max = opts.maxDrops ?? 3000;
+  const half = opts.half ?? 18;          // box half-extent around the camera
+  const height = opts.height ?? 24;
+  const groundY = opts.groundY ?? 0;
+  const rand = rng(0xd309);
+
+  // one thin quadish streak, instanced — cheap and reads as rain in motion
+  const geo = new THREE.BoxGeometry(0.015, 1, 0.015);
+  const mat = new THREE.MeshBasicMaterial({
+    color: 0xb4d2ff, transparent: true, opacity: 0.34,
+    depthWrite: false, fog: false,
+  });
+  const mesh = new THREE.InstancedMesh(geo, mat, max);
+  mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+  mesh.frustumCulled = false;
+  mesh.renderOrder = 2;
+  mesh.count = 0;
+
+  const px = new Float32Array(max), py = new Float32Array(max), pz = new Float32Array(max);
+  const jitter = new Float32Array(max);
+  for (let i = 0; i < max; i++) {
+    px[i] = (rand() * 2 - 1) * half;
+    py[i] = groundY + rand() * height;
+    pz[i] = (rand() * 2 - 1) * half;
+    jitter[i] = 0.75 + rand() * 0.5;     // not every drop is the same drop
+  }
+
+  const m = new THREE.Matrix4();
+  const q = new THREE.Quaternion();
+  const up = new THREE.Vector3(0, 1, 0);
+  const vel = new THREE.Vector3();
+  const scale = new THREE.Vector3(1, 1, 1);
+  const zero = new THREE.Vector3();
+
+  return {
+    mesh,
+    /** @param {THREE.Vector3} camPos @param {THREE.Vector3} w local wind */
+    step(dt, camPos, w, intensity) {
+      const n = Math.floor(max * clamp01(intensity));
+      mesh.count = n;
+      if (n === 0) return;
+
+      const fall = 9 + intensity * 4;
+      // rain leans into the wind; that lean IS the readout of how hard it's blowing
+      vel.set(w.x * 0.55, -fall, w.z * 0.55);
+      const speed = vel.length() || 1;
+      q.setFromUnitVectors(up, vel.clone().divideScalar(speed));
+      // streak stretches with speed — drizzle is dots, a squall is lines
+      scale.set(1, Math.min(2.6, 0.35 + speed * 0.055), 1);
+      m.compose(zero, q, scale);
+
+      const top = groundY + height;
+      for (let i = 0; i < n; i++) {
+        const j = jitter[i];
+        px[i] += w.x * 0.55 * j * dt;
+        py[i] -= fall * j * dt;
+        pz[i] += w.z * 0.55 * j * dt;
+
+        // wrap the box around the camera instead of respawning — no bookkeeping,
+        // and the rain is always exactly where the player is looking
+        let d = px[i] - camPos.x;
+        if (d > half) px[i] -= half * 2; else if (d < -half) px[i] += half * 2;
+        d = pz[i] - camPos.z;
+        if (d > half) pz[i] -= half * 2; else if (d < -half) pz[i] += half * 2;
+        if (py[i] < groundY) py[i] += height;
+        else if (py[i] > top) py[i] -= height;
+
+        m.elements[12] = px[i];
+        m.elements[13] = py[i];
+        m.elements[14] = pz[i];
+        mesh.setMatrixAt(i, m);
+      }
+      mesh.instanceMatrix.needsUpdate = true;
+    },
+    dispose() { geo.dispose(); mat.dispose(); },
+  };
+}
+
+// ------------------------------------------------------------ cloud dome
+function cloudTexture(size = 256, seed = 7) {
+  const cv = document.createElement('canvas');
+  cv.width = cv.height = size;
+  const ctx = cv.getContext('2d');
+  const img = ctx.createImageData(size, size);
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      // fbm at integer frequencies, each octave wrapped at its own period, so
+      // the texture tiles: it's set to repeat(3,2) and it scrolls forever, and
+      // an unwrapped octave puts a dead straight seam across the sky.
+      let n = 0, amp = 0.5, f = 4;
+      for (let o = 0; o < 4; o++) {
+        n += amp * valueNoise2((x / size) * f, (y / size) * f, seed + o * 977, f);
+        amp *= 0.5; f *= 2;
+      }
+      const v = clamp01((n - 0.28) * 2.2);
+      const i = (y * size + x) * 4;
+      const shade = 150 + v * 70;
+      img.data[i] = shade; img.data[i + 1] = shade; img.data[i + 2] = shade + 12;
+      img.data[i + 3] = v * 235;
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+  const tex = new THREE.CanvasTexture(cv);
+  tex.wrapS = tex.wrapT = THREE.RepeatWrapping;
+  tex.repeat.set(3, 2);
+  return tex;
+}
+
+// ---------------------------------------------------------------- audio
+// Synthesized layers. WebAudio won't start until a gesture (browser rule), so
+// everything is built lazily on unlock() and silently absent before it.
+function createAudio(seed = 1) {
+  let ctx = null, master = null;
+  let windGain, windFilter, windHowl, howlGain;
+  let rainGain, rainFilter;
+  let gustGain, gustFilter;
+  let noiseBuf = null;
+  let creakNext = 0, flogNext = 0;
+  let started = false;
+
+  function noiseBuffer(c) {
+    const len = c.sampleRate * 4;
+    const buf = c.createBuffer(1, len, c.sampleRate);
+    const d = buf.getChannelData(0);
+    const rand = rng(seed ^ 0x0157);
+    let last = 0;
+    for (let i = 0; i < len; i++) {
+      const white = rand() * 2 - 1;
+      last = (last + 0.02 * white) / 1.02;      // brown-ish: weight to the low end
+      d[i] = last * 3.5;
+    }
+    return buf;
+  }
+
+  function loop(buf, dest, filter) {
+    const src = ctx.createBufferSource();
+    src.buffer = buf; src.loop = true;
+    src.connect(filter); filter.connect(dest);
+    src.start();
+    return src;
+  }
+
+  return {
+    get ready() { return started; },
+    /** 'running' | 'suspended' | 'closed' | 'none'. `ready` only means the graph
+     *  got built — a suspended context is still silent, so the HUD reports this. */
+    get state() { return ctx ? ctx.state : 'none'; },
+    /** Current layer gains — for the HUD and for asserting the bed tracks wind. */
+    levels() {
+      if (!started) return null;
+      return {
+        wind: +windGain.gain.value.toFixed(4),
+        howl: +howlGain.gain.value.toFixed(4),
+        rain: +rainGain.gain.value.toFixed(4),
+        cutoff: Math.round(windFilter.frequency.value),
+      };
+    },
+
+    /** Call from the first click/keydown. Safe to call repeatedly. */
+    unlock() {
+      if (started) return;
+      const AC = window.AudioContext || window.webkitAudioContext;
+      if (!AC) return;
+      ctx = new AC();
+      if (ctx.state === 'suspended') ctx.resume();
+      master = ctx.createGain();
+      master.gain.value = 0.55;
+      master.connect(ctx.destination);
+      noiseBuf = noiseBuffer(ctx);
+
+      // wind bed: brown noise through a lowpass that opens as it blows harder
+      windGain = ctx.createGain(); windGain.gain.value = 0;
+      windFilter = ctx.createBiquadFilter();
+      windFilter.type = 'lowpass'; windFilter.frequency.value = 400;
+      windGain.connect(master);
+      loop(noiseBuf, windGain, windFilter);
+
+      // howl: a resonant band on top — this is the bit that sounds like a gale
+      howlGain = ctx.createGain(); howlGain.gain.value = 0;
+      windHowl = ctx.createBiquadFilter();
+      windHowl.type = 'bandpass'; windHowl.frequency.value = 500; windHowl.Q.value = 6;
+      howlGain.connect(master);
+      loop(noiseBuf, howlGain, windHowl);
+
+      rainGain = ctx.createGain(); rainGain.gain.value = 0;
+      rainFilter = ctx.createBiquadFilter();
+      rainFilter.type = 'highpass'; rainFilter.frequency.value = 1800;
+      rainGain.connect(master);
+      loop(noiseBuf, rainGain, rainFilter);
+
+      gustGain = ctx.createGain(); gustGain.gain.value = 0;
+      gustFilter = ctx.createBiquadFilter();
+      gustFilter.type = 'bandpass'; gustFilter.frequency.value = 300; gustFilter.Q.value = 2.5;
+      gustGain.connect(master);
+      loop(noiseBuf, gustGain, gustFilter);
+
+      started = true;
+    },
+
+    /** One-shot filtered noise burst — the workhorse for creak/flog/thunder. */
+    burst({ freq, q, gain, attack, decay, type = 'bandpass' }) {
+      if (!started) return;
+      const now = ctx.currentTime;
+      const src = ctx.createBufferSource();
+      src.buffer = noiseBuf;
+      src.loop = true;
+      const f = ctx.createBiquadFilter();
+      f.type = type; f.frequency.value = freq; f.Q.value = q ?? 4;
+      const g = ctx.createGain();
+      g.gain.setValueAtTime(0.0001, now);
+      g.gain.exponentialRampToValueAtTime(Math.max(0.0002, gain), now + attack);
+      g.gain.exponentialRampToValueAtTime(0.0001, now + attack + decay);
+      src.connect(f); f.connect(g); g.connect(master);
+      src.start(now);
+      src.stop(now + attack + decay + 0.05);
+    },
+
+    /** @param {number} speed m/s @param {number} rain 0..1 */
+    setLevels(speed, rain) {
+      if (!started) return;
+      const now = ctx.currentTime;
+      const s = clamp01(speed / 32);
+      // gain and brightness both climb — a 30 m/s wind isn't just a louder 5 m/s one
+      windGain.gain.setTargetAtTime(0.05 + s * 0.5, now, 0.15);
+      windFilter.frequency.setTargetAtTime(220 + s * 900, now, 0.2);
+      howlGain.gain.setTargetAtTime(s * s * 0.28, now, 0.2);
+      windHowl.frequency.setTargetAtTime(320 + s * 700, now, 0.25);
+      rainGain.gain.setTargetAtTime(rain * 0.34, now, 0.3);
+      rainFilter.frequency.setTargetAtTime(1500 + rain * 900, now, 0.3);
+    },
+
+    /** Telegraph cue: you hear it coming before you feel it. */
+    whoosh(power, eta) {
+      if (!started) return;
+      const now = ctx.currentTime;
+      const p = clamp01(power / 18);
+      gustGain.gain.cancelScheduledValues(now);
+      gustGain.gain.setValueAtTime(gustGain.gain.value, now);
+      gustGain.gain.linearRampToValueAtTime(0.05 + p * 0.3, now + Math.max(0.05, eta));
+      gustGain.gain.linearRampToValueAtTime(0.0001, now + Math.max(0.05, eta) + 2.2);
+      gustFilter.frequency.cancelScheduledValues(now);
+      gustFilter.frequency.setValueAtTime(220, now);
+      gustFilter.frequency.linearRampToValueAtTime(240 + p * 700, now + Math.max(0.05, eta) + 0.8);
+    },
+
+    /** Rope creak — rate and pitch both ride the worst corner. */
+    creak(dt, loadFrac) {
+      if (!started || loadFrac < 0.35) return;
+      creakNext -= dt;
+      if (creakNext > 0) return;
+      creakNext = lerp(1.1, 0.16, clamp01((loadFrac - 0.35) / 0.65));
+      this.burst({
+        freq: 180 + loadFrac * 420, q: 9,
+        gain: 0.05 + loadFrac * 0.22, attack: 0.012, decay: 0.16,
+      });
+    },
+
+    /** Freed corner: canvas cracking itself to pieces. */
+    flog(dt, speed) {
+      if (!started) return;
+      flogNext -= dt;
+      if (flogNext > 0) return;
+      flogNext = Math.max(0.09, 0.5 - speed * 0.011);
+      this.burst({ freq: 900 + speed * 26, q: 1.2, gain: 0.1 + clamp01(speed / 30) * 0.3, attack: 0.005, decay: 0.1 });
+    },
+
+    thunder(power) {
+      if (!started) return;
+      this.burst({ type: 'lowpass', freq: 90 + power * 60, q: 0.7, gain: 0.25 + power * 0.5, attack: 0.06, decay: 2.6 + power * 1.6 });
+    },
+
+    dispose() { if (ctx) ctx.close(); started = false; },
+  };
+}
+
+// ---------------------------------------------------------------- skyfx
+/**
+ * @param {object} o
+ * @param {THREE.Scene} o.scene
+ * @param {THREE.Camera} o.camera
+ * @param {object} o.wind                 from weather.js
+ * @param {THREE.Light} [o.sun]           Lane A's directional light — we dim it
+ * @param {THREE.Light} [o.hemi]          Lane A's hemisphere light
+ * @param {boolean} [o.night]             storm_02 is a wild NIGHT
+ * @param {function} [o.onEvent]          (text) HUD ticker
+ */
+export function createSkyFx(o = {}) {
+  const { scene, camera, wind } = o;
+  const sun = o.sun || null;
+  const hemi = o.hemi || null;
+  const def = (wind && wind.def) || {};
+  const skyDef = def.sky || {};
+  const darkness = skyDef.darkness ?? 0.7;
+  const scroll = skyDef.cloudScroll ?? 0.06;
+  const target = (o.night ?? darkness > 0.6) ? NIGHT_SKY : STORM_SKY;
+
+  const rain = createRain({ groundY: o.groundY ?? 0 });
+  if (scene) scene.add(rain.mesh);
+
+  const audio = createAudio((wind && wind.seed) || 1);
+
+  // cloud dome rides the camera so it can't clip the far plane whatever Lane A set
+  const domeTex = cloudTexture(256, ((wind && wind.seed) || 7) & 0xffff);
+  const dome = new THREE.Mesh(
+    new THREE.SphereGeometry(180, 24, 16),
+    new THREE.MeshBasicMaterial({
+      map: domeTex, side: THREE.BackSide, transparent: true,
+      depthWrite: false, fog: false, opacity: 0,
+    }),
+  );
+  dome.renderOrder = -1;
+  if (scene) scene.add(dome);
+
+  // remember what world.js handed us, so dispose() puts it back exactly
+  const original = {
+    background: scene ? scene.background : null,
+    fog: scene ? scene.fog : null,
+    sun: sun ? sun.intensity : 0,
+    hemi: hemi ? hemi.intensity : 0,
+  };
+  const baseSky = (scene && scene.background && scene.background.isColor)
+    ? scene.background.clone() : CALM_SKY.clone();
+
+  const skyCol = baseSky.clone();
+  if (scene) {
+    scene.background = skyCol;
+    if (!scene.fog) scene.fog = new THREE.Fog(skyCol.getHex(), 30, 140);
+  }
+
+  let flash = 0;              // decaying lightning brightness
+  let flashQueue = [];        // {at, power} — double-strike
+  let lastTelegraph = null;
+  const camPos = new THREE.Vector3();
+  const w = new THREE.Vector3();
+
+  const fx = {
+    rain, audio, dome,
+    get flash() { return flash; },
+
+    /** Wire to the first click/keydown — browsers won't start audio otherwise. */
+    unlockAudio() { audio.unlock(); },
+
+    /**
+     * @param {number} dt
+     * @param {number} t   storm time
+     * @param {object} [world] {sail} — duck-typed, for creak/flog
+     */
+    step(dt, t, world = {}) {
+      if (!camera) return;
+      camera.getWorldPosition(camPos);
+      wind.sample(camPos, t, w);
+      const speed = Math.hypot(w.x, w.z);
+      const intensity = wind.rainAt(t);
+      const storminess = clamp01(Math.max(intensity, speed / 26));
+
+      // --- events: lightning + the ticker ---
+      for (const ev of wind.eventsBetween(t - dt, t)) {
+        if (ev.type === 'lightning') {
+          const p = ev.power ?? 0.7;
+          flashQueue.push({ at: t, power: p });
+          flashQueue.push({ at: t + 0.09 + p * 0.07, power: p * 0.55 });  // the stutter
+          // thunder lags the flash — distance you can hear
+          const delay = (ev.distance ?? 1.2) * 0.9;
+          flashQueue.push({ at: t + delay, power: 0, thunder: p });
+        } else if (ev.type === 'windchange' && ev.text && o.onEvent) {
+          o.onEvent(ev.text);
+        }
+      }
+      for (let i = flashQueue.length - 1; i >= 0; i--) {
+        if (flashQueue[i].at <= t) {
+          const f = flashQueue[i];
+          if (f.thunder) audio.thunder(f.thunder);
+          else flash = Math.max(flash, f.power);
+          flashQueue.splice(i, 1);
+        }
+      }
+      flash *= Math.max(0, 1 - dt * 7);
+      if (flash < 0.004) flash = 0;
+
+      // --- sky ---
+      skyCol.copy(baseSky).lerp(target, storminess * darkness);
+      if (flash > 0) skyCol.lerp(new THREE.Color(0xdfe8ff), Math.min(0.85, flash));
+      if (scene) {
+        if (scene.fog) {
+          scene.fog.color.copy(skyCol);
+          scene.fog.near = lerp(40, 8, storminess);
+          scene.fog.far = lerp(160, 55, storminess);
+        }
+      }
+      if (sun) sun.intensity = lerp(original.sun, original.sun * 0.12, storminess * darkness) + flash * 2.2;
+      if (hemi) hemi.intensity = lerp(original.hemi, original.hemi * 0.3, storminess * darkness) + flash * 1.2;
+
+      dome.position.copy(camPos);
+      dome.material.opacity = storminess * 0.85;
+      domeTex.offset.x = (domeTex.offset.x + scroll * dt * (0.4 + speed * 0.05)) % 1;
+      domeTex.offset.y = (domeTex.offset.y + scroll * dt * 0.12) % 1;
+
+      // --- rain ---
+      rain.step(dt, camPos, w, intensity);
+
+      // --- audio ---
+      audio.setLevels(speed, intensity);
+      const tg = wind.gustTelegraph(t);
+      if (tg && tg !== lastTelegraph) {
+        // fires once per gust, right as the telegraph opens
+        if (!lastTelegraph || Math.abs(tg.eta - (lastTelegraph.eta - dt)) > 0.05) {
+          audio.whoosh(tg.power, tg.eta);
+        }
+      }
+      lastTelegraph = tg;
+
+      const sail = world.sail;
+      if (sail && sail.corners) {
+        let worst = 0, broken = false;
+        for (const c of sail.corners) {
+          if (c.broken) { broken = true; continue; }
+          const rating = c.hw && c.hw.rating ? c.hw.rating : 1;
+          worst = Math.max(worst, c.load / rating);
+        }
+        audio.creak(dt, worst);
+        if (broken) audio.flog(dt, speed);
+      }
+    },
+
+    /** Hand Lane A's scene back exactly as we found it. */
+    dispose() {
+      if (scene) {
+        scene.remove(rain.mesh);
+        scene.remove(dome);
+        scene.background = original.background;
+        scene.fog = original.fog;
+      }
+      if (sun) sun.intensity = original.sun;
+      if (hemi) hemi.intensity = original.hemi;
+      rain.dispose();
+      dome.geometry.dispose();
+      dome.material.dispose();
+      domeTex.dispose();
+      audio.dispose();
+    },
+  };
+
+  return fx;
+}

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

@@ -1,25 +1,81 @@
 /**
  * Lane C selftests — wind field, storm timelines, rain, debris.
  *
- * Lane C owns this file. Lane A pre-created it so adding your suite never means
- * editing selftest.html.
+ * The asserts live in weather.selftest.js as a plain case list, because they
+ * import nothing but weather.core.js (no THREE, no DOM) and so also run under
+ * `node web/world/js/tests/run-node.mjs` — a one-second loop for tuning a storm
+ * curve, instead of a browser round trip. This file is the browser half: it
+ * feeds them the fetched storms and adds the checks that need the real
+ * weather.js adapter (contract shape, THREE.Vector3 out).
  *
- * The asserts PLAN3D §5-C asks for, once weather.js lands:
- *   1. gust telegraph lead ≥ 1.2 s — the promise the storm rests on. Lane A's
- *      suite already asserts this against the stub wind (see a.test.js,
- *      'gust telegraph always gives at least 1.2 s of warning'); lift that test
- *      onto the real wind.sample and delete the stub version's claim to it.
- *   2. wind.sample continuity — no frame-to-frame jump beyond a sane bound, or
- *      the cloth explodes and it looks like Lane B's bug.
- *   3. storm JSON schema validation for everything in data/storms/.
- *
- * Useful imports:
- *   import { FIXED_DT, STORM_LEN } from '../contracts.js';
- *   import { assert, assertLess, fixedLoop } from '../testkit.js';
- * wind.sample(pos, t) must be pure in (pos, t): selftest samples out of order.
+ * Lane A: a.test.js's 'gust telegraph always gives at least 1.2 s of warning'
+ * is lifted onto the real wind below, per your note — the stub's claim to it is
+ * now redundant and yours to drop whenever suits. Logged in THREADS.
  */
 
+import * as THREE from '../../vendor/three.module.js';
+import { assert, fixedLoop } from '../testkit.js';
+import { FIXED_DT, checkContract } from '../contracts.js';
+import { loadStorm, createWind } from '../weather.js';
+import { weatherCases } from './weather.selftest.js';
+
+const STORMS = ['storm_01_gentle', 'storm_02_wildnight'];
+
 /** @param {import('../testkit.js').Suite} t */
-export default function run(t) {
-  t.skip('weather.js not landed yet — Lane C');
+export default async function run(t) {
+  const storms = {};
+  for (const name of STORMS) storms[name] = await loadStorm(name);
+
+  // --- the shared case list (also runs headless in node) ---
+  const { cases } = weatherCases(storms);
+  for (const c of cases) t.test(c.name, c.fn);
+
+  // --- the bits that need the THREE adapter, not just the core ---
+
+  t.test('weather.js satisfies the wind contract', () => {
+    const wind = createWind(storms.storm_02_wildnight);
+    const problems = checkContract('wind', wind);
+    assert(problems.length === 0, problems.join('; '));
+  });
+
+  t.test('sample() returns a Vector3 and honours an out param', () => {
+    const wind = createWind(storms.storm_02_wildnight);
+    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}`);
+    // 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');
+  });
+
+  // Lifted from a.test.js onto the real wind (Lane A's note in this file's
+  // header). This is the promise the whole storm rests on: the player can
+  // always react. Deliberately walks the public surface, not the core.
+  t.test('gust telegraph always gives at least 1.2 s of warning', () => {
+    const wind = createWind(storms.storm_02_wildnight);
+    let had = false, edges = 0;
+    fixedLoop(wind.duration, FIXED_DT, (dt, time) => {
+      const tel = wind.gustTelegraph(time);
+      if (tel && !had) {
+        edges++;
+        assert(tel.eta >= 1.2, `telegraph appeared with only ${tel.eta.toFixed(2)}s of warning`);
+        assert(Number.isFinite(tel.power) && tel.power > 0, 'telegraph carried no power');
+        assert(Number.isFinite(tel.dir), 'telegraph carried no direction');
+      }
+      had = !!tel;
+    });
+    assert(edges >= 5, `only ${edges} gusts telegraphed in a ${wind.duration}s storm — too quiet to test`);
+  });
+
+  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');
+    for (const [name, def] of Object.entries(storms)) {
+      assert(def.duration > 0, `${name} has no duration`);
+      assert(Array.isArray(def.baseCurve), `${name} has no baseCurve`);
+    }
+  });
 }

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/run-node.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+'use strict';
+// SHADES — Lane C — headless runner for the weather suite.
+//
+//   node web/world/js/tests/run-node.mjs
+//
+// The same suite Lane A's selftest.html runs, but with no browser and no server,
+// so tuning a storm curve is a one-second loop. Exits non-zero on failure.
+
+import { readFileSync, readdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { runWeatherSuite } from './weather.selftest.js';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const stormDir = join(here, '..', '..', 'data', 'storms');
+
+const storms = {};
+for (const f of readdirSync(stormDir).filter((f) => f.endsWith('.json')).sort()) {
+  storms[f.replace(/\.json$/, '')] = JSON.parse(readFileSync(join(stormDir, f), 'utf8'));
+}
+
+const r = runWeatherSuite(storms);
+
+for (const res of r.results) {
+  console.log(res.ok ? `  ok   ${res.name}` : `  FAIL ${res.name}\n         ${res.err}`);
+}
+console.log('\n  metrics (Lane B: tune cloth rho against these):');
+for (const [k, v] of Object.entries(r.metrics)) console.log(`    ${k.padEnd(32)} ${v}`);
+console.log(`\n  ${r.pass} passed, ${r.fail} failed\n`);
+
+process.exit(r.fail ? 1 : 0);

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

@@ -0,0 +1,299 @@
+'use strict';
+// SHADES — Lane C — weather selftest.
+//
+// Imports the pure core only (no THREE, no DOM), so this runs in node OR from
+// Lane A's selftest.html. Fixed-dt loops, never rAF (rAF pauses in hidden tabs
+// — PLAN3D §0).
+//
+//   node web/world/js/tests/run-node.mjs
+//
+// Lane A: `import { runWeatherSuite } from './js/tests/weather.selftest.js'` and
+// call it with the fetched storm defs.
+
+import {
+  createWindField, validateStorm, gustEnvelope, GUST,
+} from '../weather.core.js';
+
+const DT = 1 / 60;
+
+// yard is ~30×20 m, origin at centre — probe the corners and the middle
+const PROBES = [
+  { x: 0, z: 0 }, { x: -14, z: -9 }, { x: 14, z: -9 },
+  { x: -14, z: 9 }, { x: 14, z: 9 }, { x: 5, z: -3 },
+];
+
+// t1 and t2 from Lane A's landed yard (THREADS: "yard layout is now FACT")
+const TREE_SHELTERS = [
+  { x: -9, z: 2, radius: 3, strength: 0.45, length: 14 },
+  { x: 8, z: -2, radius: 2.5, strength: 0.4, length: 12 },
+];
+
+/**
+ * The case list, defined once and run by two harnesses: run-node.mjs for a
+ * one-second tuning loop, and js/tests/c.test.js for Lane A's selftest.html at
+ * merge time. Cases are sync, matching testkit's Suite.test(label, fn).
+ *
+ * @param {Object<string, object>} storms  parsed storm defs, keyed by name
+ * @returns {{cases: {name:string, fn:() => void}[], metrics: object}}
+ *   `metrics` fills in as the cases run — read it after, not before.
+ */
+export function weatherCases(storms) {
+  const cases = [];
+  const metrics = {};
+  const test = (name, fn) => cases.push({ name, fn });
+  const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
+
+  const defs = Object.entries(storms);
+
+  // ---- 1. gust telegraph lead (PLAN3D §5-C.5: always >= 1.2 s before ramp) ----
+  // The whole gust read is "you SEE it coming, then it hits". If the lead ever
+  // collapses, the storm stops being fair and starts being a dice roll.
+  for (const [name, def] of defs) {
+    test(`${name}: gust telegraph lead >= 1.2s`, () => {
+      const field = createWindField(def);
+      assert(field.gusts.length > 0, 'storm scheduled no gusts at all');
+      const step = 1 / 240;
+      let worst = Infinity;
+      for (const g of field.gusts) {
+        // when does THIS gust first actually push?
+        let rise = null;
+        for (let t = g.t0; t < g.endAt; t += step) {
+          if (gustEnvelope(t - g.t0, g.pow) > 1e-6) { rise = t; break; }
+        }
+        assert(rise !== null, `gust at t=${g.t0.toFixed(2)} never rises`);
+
+        // when did the HUD first get told about it?
+        let announced = null;
+        for (let t = Math.max(0, g.t0 - 2); t < rise; t += step) {
+          const tg = field.telegraph(t);
+          if (tg && Math.abs(tg.eta - (g.rampAt - t)) < 1e-6) { announced = t; break; }
+        }
+        assert(announced !== null, `gust at t=${g.t0.toFixed(2)} was never telegraphed`);
+
+        const lead = rise - announced;
+        worst = Math.min(worst, lead);
+        assert(lead >= 1.2,
+          `gust at t=${g.t0.toFixed(2)}: telegraph lead ${lead.toFixed(3)}s < 1.2s`);
+
+        // and the telegraph window must be silent — no force before the ramp
+        for (let t = g.t0; t < g.rampAt; t += step) {
+          assert(gustEnvelope(t - g.t0, g.pow) === 0,
+            `gust at t=${g.t0.toFixed(2)} pushes during its telegraph window`);
+        }
+      }
+      metrics[`${name}.worstTelegraphLead`] = +worst.toFixed(3);
+    });
+  }
+
+  // ---- 2. wind.sample continuity ----
+  // Sail load goes with wind², so a discontinuity here is an impulse that can
+  // snap a corner out of nowhere. Both axes matter: time (a standing player)
+  // and space (a running one).
+  const MAX_JUMP = 1.5;        // m/s per 1/60 frame
+  for (const [name, def] of defs) {
+    test(`${name}: wind continuity in time (< ${MAX_JUMP} m/s per frame)`, () => {
+      const field = createWindField(def).setShelters(TREE_SHELTERS);
+      const a = { x: 0, y: 0, z: 0 }, b = { x: 0, y: 0, z: 0 };
+      let worst = 0, worstT = 0, worstP = null;
+      for (const p of PROBES) {
+        field.vecAt(p.x, p.z, 0, a);
+        for (let t = DT; t <= field.duration; t += DT) {
+          field.vecAt(p.x, p.z, t, b);
+          const d = Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+          if (d > worst) { worst = d; worstT = t; worstP = p; }
+          a.x = b.x; a.y = b.y; a.z = b.z;
+        }
+      }
+      metrics[`${name}.maxTemporalJump`] = +worst.toFixed(4);
+      assert(worst < MAX_JUMP,
+        `jump ${worst.toFixed(3)} m/s at t=${worstT.toFixed(2)} probe=(${worstP.x},${worstP.z})`);
+    });
+
+    test(`${name}: wind continuity in space (< ${MAX_JUMP} m/s per 0.1 m)`, () => {
+      const field = createWindField(def).setShelters(TREE_SHELTERS);
+      const a = { x: 0, y: 0, z: 0 }, b = { x: 0, y: 0, z: 0 };
+      let worst = 0, worstAt = null;
+      // sweep the yard at the storm's angriest moments, straight through both trees
+      for (const t of [10, 30, 57, 64, 80]) {
+        for (let z = -10; z <= 10; z += 1) {
+          field.vecAt(-15, z, t, a);
+          for (let x = -15 + 0.1; x <= 15; x += 0.1) {
+            field.vecAt(x, z, t, b);
+            const d = Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+            if (d > worst) { worst = d; worstAt = { x: +x.toFixed(1), z, t }; }
+            a.x = b.x; a.y = b.y; a.z = b.z;
+          }
+        }
+      }
+      metrics[`${name}.maxSpatialJump`] = +worst.toFixed(4);
+      assert(worst < MAX_JUMP,
+        `jump ${worst.toFixed(3)} m/s at ${JSON.stringify(worstAt)}`);
+    });
+  }
+
+  // ---- 3. storm JSON validator ----
+  for (const [name, def] of defs) {
+    test(`${name}: validates`, () => {
+      const { ok, errors } = validateStorm(def, name);
+      assert(ok, errors.join('; '));
+    });
+  }
+
+  // A validator that only ever says yes isn't a validator.
+  test('validator rejects broken storms', () => {
+    const base = () => JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    const cases = [
+      ['duration missing', (d) => { delete d.duration; }],
+      ['duration negative', (d) => { d.duration = -5; }],
+      ['baseCurve absent', (d) => { delete d.baseCurve; }],
+      ['baseCurve non-monotonic t', (d) => { d.baseCurve = [[0, 5], [50, 9], [20, 7], [90, 6]]; }],
+      ['baseCurve negative speed', (d) => { d.baseCurve = [[0, 5], [90, -2]]; }],
+      ['baseCurve ends before duration', (d) => { d.baseCurve = [[0, 5], [40, 9]]; }],
+      ['dirCurve absent', (d) => { delete d.dirCurve; }],
+      ['gusts absent', (d) => { delete d.gusts; }],
+      ['gusts.minGap zero', (d) => { d.gusts.minGap = 0; }],
+      ['gusts.maxGap < minGap', (d) => { d.gusts.minGap = 9; d.gusts.maxGap = 4; }],
+      ['gusts overlap (minGap < gust length)', (d) => { d.gusts.minGap = 2; }],
+      ['debris event with no model', (d) => { d.events = [{ t: 10, type: 'debris' }]; }],
+      ['event with no type', (d) => { d.events = [{ t: 10 }]; }],
+      ['windchange that dirCurve never delivers', (d) => {
+        d.dirCurve = [[0, 0.9], [90, 1.0]];
+        d.events = [{ t: 55, type: 'windchange', telegraph: 6 }];
+      }],
+    ];
+    for (const [label, mutate] of cases) {
+      const d = base();
+      mutate(d);
+      const { ok } = validateStorm(d, 'broken');
+      assert(!ok, `validator ACCEPTED a storm with: ${label}`);
+    }
+  });
+
+  // ---- 4. determinism ----
+  // Everything downstream (selftest fast-forward, Lane B's byte-equal load
+  // traces) rests on this. Two builds of the same storm must be indiscernible.
+  test('same def + same seed => identical trace', () => {
+    const def = storms.storm_02_wildnight;
+    const a = createWindField(def).setShelters(TREE_SHELTERS);
+    const b = createWindField(def).setShelters(TREE_SHELTERS);
+    const va = { x: 0, y: 0, z: 0 }, vb = { x: 0, y: 0, z: 0 };
+    for (let t = 0; t <= def.duration; t += DT) {
+      for (const p of PROBES) {
+        a.vecAt(p.x, p.z, t, va);
+        b.vecAt(p.x, p.z, t, vb);
+        assert(va.x === vb.x && va.z === vb.z,
+          `diverged at t=${t.toFixed(3)} probe=(${p.x},${p.z})`);
+      }
+    }
+    assert(a.gusts.length === b.gusts.length, 'gust timelines differ in length');
+    a.gusts.forEach((g, i) => {
+      assert(g.t0 === b.gusts[i].t0 && g.pow === b.gusts[i].pow, `gust ${i} differs`);
+    });
+  });
+
+  test('different seed => different storm', () => {
+    const def = storms.storm_02_wildnight;
+    const a = createWindField(def, { seed: 1 });
+    const b = createWindField(def, { seed: 2 });
+    const same = a.gusts.length === b.gusts.length
+      && a.gusts.every((g, i) => g.t0 === b.gusts[i].t0 && g.pow === b.gusts[i].pow);
+    assert(!same, 'seed is being ignored — every storm would be identical');
+  });
+
+  // ---- 5. sampling order must not matter ----
+  // sample() is called by sail/player/debris/rain in whatever order the frame
+  // happens to run. If it ever depends on call order, storms stop replaying.
+  test('sample order independent', () => {
+    const def = storms.storm_02_wildnight;
+    // same fixed t values, walked in two different orders, on two fields
+    const times = [0, 3.5, 17.3, 4.1, 55.0, 88.9, 63.2, 21.7, 39.9, 70.4];
+    const sorted = [...times].sort((a, b) => a - b);
+    const inOrder = createWindField(def).setShelters(TREE_SHELTERS);
+    const shuffled = createWindField(def).setShelters(TREE_SHELTERS);
+    const va = { x: 0, y: 0, z: 0 }, vb = { x: 0, y: 0, z: 0 };
+
+    const seen = new Map();
+    for (const t of sorted) {
+      inOrder.vecAt(3, -2, t, va);
+      seen.set(t, { x: va.x, z: va.z });
+    }
+    for (const t of times) {                 // deliberately out of order, and jumping backwards
+      shuffled.vecAt(3, -2, t, vb);
+      const want = seen.get(t);
+      assert(vb.x === want.x && vb.z === want.z,
+        `sampling order changed the wind at t=${t}: ${vb.x},${vb.z} vs ${want.x},${want.z}`);
+    }
+  });
+
+  // ---- 6. the storms are what the design says they are (PLAN3D §7) ----
+  // storm_02 has to be able to destroy a flat cheap rig; storm_01 must not.
+  test('storm_02 is genuinely violent, storm_01 is not', () => {
+    const wild = createWindField(storms.storm_02_wildnight);
+    const gentle = createWindField(storms.storm_01_gentle);
+    const peak = (f) => {
+      let mx = 0, mxBase = 0;
+      for (let t = 0; t <= f.duration; t += DT) {
+        mx = Math.max(mx, f.uniformSpeed(t));
+        mxBase = Math.max(mxBase, f.uniformSpeed(t) - f.gustOnly(t));
+      }
+      return { mx, mxBase };
+    };
+    const w = peak(wild), g = peak(gentle);
+    metrics['storm_02.peakGustSpeed'] = +w.mx.toFixed(2);
+    metrics['storm_02.peakSustained'] = +w.mxBase.toFixed(2);
+    metrics['storm_01.peakGustSpeed'] = +g.mx.toFixed(2);
+    metrics['storm_01.peakSustained'] = +g.mxBase.toFixed(2);
+    assert(w.mx >= 30, `storm_02 peaks at only ${w.mx.toFixed(1)} m/s — won't break a cheap rig`);
+    assert(w.mxBase >= 18, `storm_02 sustained peaks at only ${w.mxBase.toFixed(1)} m/s`);
+    assert(g.mx <= 15, `storm_01 peaks at ${g.mx.toFixed(1)} m/s — too wild for the gentle storm`);
+    assert(w.mx > g.mx * 2, 'storm_02 should be far worse than storm_01');
+  });
+
+  // ---- 7. wind change actually swings the wind ----
+  test('storm_02 southerly change swings the wind', () => {
+    const f = createWindField(storms.storm_02_wildnight);
+    const ev = (storms.storm_02_wildnight.events || []).find((e) => e.type === 'windchange');
+    assert(ev, 'storm_02 has no windchange event');
+    const before = f.dirAt(ev.t - 5);
+    const after = f.dirAt(ev.t + 8);
+    const swing = Math.abs(after - before);
+    metrics['storm_02.changeSwingRad'] = +swing.toFixed(3);
+    assert(swing > 0.9, `change only swings ${swing.toFixed(2)} rad — should be a real slew`);
+    // and the player must be warned before it lands
+    assert((ev.telegraph ?? 0) >= 4, 'windchange telegraph is too short to react to');
+  });
+
+  // ---- 8. shelters ----
+  test('tree wind shadow bites downwind and nowhere else', () => {
+    const def = storms.storm_02_wildnight;
+    const bare = createWindField(def);
+    const shad = createWindField(def).setShelters([{ x: 0, z: 0, radius: 3, strength: 0.5, length: 14 }]);
+    const t = 30;
+    const d = bare.dirAt(t);
+    const dx = Math.cos(d), dz = Math.sin(d);
+    const lee = { x: dx * 5, z: dz * 5 };          // 5 m downwind of the tree
+    const luv = { x: -dx * 5, z: -dz * 5 };        // 5 m upwind
+    const leeS = shad.speedAt(lee.x, lee.z, t), leeB = bare.speedAt(lee.x, lee.z, t);
+    const luvS = shad.speedAt(luv.x, luv.z, t), luvB = bare.speedAt(luv.x, luv.z, t);
+    metrics['shelter.leeDrop'] = +(1 - leeS / leeB).toFixed(3);
+    assert(leeS < leeB * 0.85, `lee side only dropped to ${(leeS / leeB).toFixed(2)}× — shadow too weak`);
+    assert(Math.abs(luvS - luvB) < 1e-9, 'upwind side is being sheltered — shadow is pointing the wrong way');
+  });
+
+  return { cases, metrics };
+}
+
+/** Run every case and collect results. Used by run-node.mjs. */
+export function runWeatherSuite(storms) {
+  const { cases, metrics } = weatherCases(storms);
+  const results = cases.map((c) => {
+    try {
+      c.fn();
+      return { name: c.name, ok: true };
+    } catch (e) {
+      return { name: c.name, ok: false, err: e.message };
+    }
+  });
+  const pass = results.filter((r) => r.ok).length;
+  return { suite: 'weather', pass, fail: results.length - pass, results, metrics };
+}

web/world/js/weather.core.js

@@ -0,0 +1,399 @@
+'use strict';
+// SHADES — Lane C — wind field core.
+//
+// Pure math. Zero imports: no THREE, no DOM, no Date.now, no rAF. Everything is
+// a closed-form function of (pos, t) given a storm def + seed, which buys us:
+//   - selftest can fast-forward a 90 s storm and get identical numbers every run
+//   - consumers can sample any t, in any order, as often as they like
+//   - the determinism rule (PLAN3D §4) is structural, not a promise
+//
+// weather.js wraps this to expose the contracts.js surface (Vector3 in/out).
+// The prototype scheduled gusts by INTEGRATING (wind.gustT += dt). We can't —
+// sample(pos,t) is called by everyone at arbitrary t. So gusts are precomputed
+// into a timeline from a seeded PRNG at storm load; the envelope shape below is
+// a faithful port of prototype/game.js, just read from t instead of accumulated.
+
+// ---------- gust envelope (ported from prototype/game.js windVec) ----------
+// telegraph: wind hasn't risen yet, but you can SEE it coming (grass, band, audio)
+export const GUST = Object.freeze({
+  TELEGRAPH: 1.5,   // gt < 1.5        → 0        "it's coming"
+  RAMP: 0.8,        // 1.5 .. 2.3      → 0 → pow
+  HOLD: 1.7,        // 2.3 .. 4.0      → pow
+  FADE: 1.0,        // 4.0 .. 5.0      → pow → 0
+  TOTAL: 5.0,
+});
+const RAMP_AT = GUST.TELEGRAPH;                 // 1.5
+const HOLD_AT = RAMP_AT + GUST.RAMP;            // 2.3
+const FADE_AT = HOLD_AT + GUST.HOLD;            // 4.0
+const END_AT = FADE_AT + GUST.FADE;             // 5.0
+
+/** Gust strength at local gust time gt (seconds since telegraph began). */
+export function gustEnvelope(gt, pow) {
+  if (gt <= 0 || gt >= END_AT) return 0;
+  if (gt < RAMP_AT) return 0;                              // telegraph window
+  if (gt < HOLD_AT) return pow * (gt - RAMP_AT) / GUST.RAMP;
+  if (gt < FADE_AT) return pow;
+  return pow * (END_AT - gt) / GUST.FADE;
+}
+
+// ---------- deterministic noise ----------
+// mulberry32 — small, fast, good enough, and identical in every JS engine.
+export function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function () {
+    a = (a + 0x6D2B79F5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// int32 hash — Math.imul keeps it exact (plain * would drift past 2^31 as a double)
+function hash2(ix, iz, seed) {
+  let h = (Math.imul(ix, 374761393) + Math.imul(iz, 668265263) + Math.imul(seed, 1274126177)) | 0;
+  h = Math.imul(h ^ (h >>> 13), 1274126177);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+
+const smooth = (f) => f * f * (3 - 2 * f);
+
+/**
+ * Value noise, 0..1, C1-continuous (smoothstep interp) so wind never steps.
+ *
+ * @param {number} [period] Wrap the lattice at this many cells, making the noise
+ *   tile seamlessly over [0, period). The wind doesn't want this (the yard would
+ *   repeat); a scrolling cloud texture does, or every wrap boundary is a visible
+ *   straight edge in the sky. Pass an integer that matches your frequency.
+ */
+export function valueNoise2(x, z, seed, period = 0) {
+  const ix = Math.floor(x), iz = Math.floor(z);
+  const ux = smooth(x - ix), uz = smooth(z - iz);
+  // branch, not a closure: this is the wind's hot path (the cloth alone samples
+  // it thousands of times a second) and a per-call allocation would show up.
+  let x0 = ix, x1 = ix + 1, z0 = iz, z1 = iz + 1;
+  if (period > 0) {
+    x0 = ((x0 % period) + period) % period;
+    x1 = ((x1 % period) + period) % period;
+    z0 = ((z0 % period) + period) % period;
+    z1 = ((z1 % period) + period) % period;
+  }
+  const a = hash2(x0, z0, seed), b = hash2(x1, z0, seed);
+  const c = hash2(x0, z1, seed), d = hash2(x1, z1, seed);
+  return (a + (b - a) * ux) * (1 - uz) + (c + (d - c) * ux) * uz;
+}
+
+export function smoothstep(e0, e1, x) {
+  if (e0 === e1) return x < e0 ? 0 : 1;
+  const f = Math.min(1, Math.max(0, (x - e0) / (e1 - e0)));
+  return smooth(f);
+}
+
+// ---------- curves ----------
+/** Piecewise-linear [[t,v],...] lookup, clamped at both ends. */
+export function sampleCurve(curve, t) {
+  if (!curve || curve.length === 0) return 0;
+  if (t <= curve[0][0]) return curve[0][1];
+  const last = curve[curve.length - 1];
+  if (t >= last[0]) return last[1];
+  for (let i = 1; i < curve.length; i++) {
+    if (t <= curve[i][0]) {
+      const [ta, va] = curve[i - 1], [tb, vb] = curve[i];
+      const span = tb - ta;
+      return span <= 0 ? vb : va + (vb - va) * ((t - ta) / span);
+    }
+  }
+  return last[1];
+}
+
+/** Shortest-arc angle lerp — so a curve crossing ±π doesn't spin the long way. */
+export function lerpAngle(a, b, k) {
+  const TAU = Math.PI * 2;
+  let d = ((b - a + Math.PI) % TAU + TAU) % TAU - Math.PI;
+  return a + d * k;
+}
+
+function sampleAngleCurve(curve, t) {
+  if (!curve || curve.length === 0) return 0;
+  if (t <= curve[0][0]) return curve[0][1];
+  const last = curve[curve.length - 1];
+  if (t >= last[0]) return last[1];
+  for (let i = 1; i < curve.length; i++) {
+    if (t <= curve[i][0]) {
+      const [ta, va] = curve[i - 1], [tb, vb] = curve[i];
+      const span = tb - ta;
+      return span <= 0 ? vb : lerpAngle(va, vb, (t - ta) / span);
+    }
+  }
+  return last[1];
+}
+
+// ---------- gust timeline ----------
+// Prototype: pow = 12 + rand*16 + 10*p, next = t + 5 + rand*7. Same shape, from JSON.
+export function buildGustTimeline(def, seed) {
+  const g = def.gusts || {};
+  const rng = mulberry32(seed >>> 0);
+  const minGap = g.minGap ?? 5, maxGap = g.maxGap ?? 12;
+  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 });
+    t += minGap + rng() * Math.max(0, maxGap - minGap);
+  }
+  return out;
+}
+
+// ---------- the field ----------
+/**
+ * @param {object} def   parsed storm JSON (see data/storms/*.json)
+ * @param {object} [opts] {seed}
+ */
+export function createWindField(def, opts = {}) {
+  const seed = (opts.seed ?? def.seed ?? 1) >>> 0;
+  const duration = def.duration ?? 90;
+  const gusts = buildGustTimeline(def, seed);
+  const sp = def.spatial || {};
+  const amp = sp.amp ?? 0.18;          // ±18% speed across the yard
+  const scale = sp.scale ?? 12;        // metres per noise cell — yard is 30×20
+  const advect = sp.advect ?? 0.5;     // noise drifts downwind (frozen turbulence)
+  const wander = def.dirWander || {};
+  const wAmp = wander.amp ?? 0.25, wRate = wander.rate ?? 0.13;
+  const nSeed = (seed ^ 0x9e3779b9) | 0;
+
+  let shelters = [];
+
+  /** Spatially-uniform part: base curve + every gust envelope live at t. */
+  function uniformSpeed(t) {
+    let s = sampleCurve(def.baseCurve, t);
+    for (let i = 0; i < gusts.length; i++) {
+      const g = gusts[i];
+      if (t <= g.t0) break;            // sorted — nothing later can be live
+      if (t < g.endAt) s += gustEnvelope(t - g.t0, g.pow);
+    }
+    return s;
+  }
+
+  function gustOnly(t) {
+    let s = 0;
+    for (let i = 0; i < gusts.length; i++) {
+      const g = gusts[i];
+      if (t <= g.t0) break;
+      if (t < g.endAt) s += gustEnvelope(t - g.t0, g.pow);
+    }
+    return s;
+  }
+
+  function dirAt(t) {
+    return sampleAngleCurve(def.dirCurve, t) + wAmp * Math.sin(t * wRate);
+  }
+
+  // ---- 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
+  // everywhere at once. That displacement is an integral, D(t) = ∫ advect·U·dir dτ,
+  // and it has to be integrated as one: the obvious closed form `U(t)·advect·t`
+  // is not the integral, and it whips the whole accumulated field sideways the
+  // instant U or dir moves — a 6.8 m/s single-frame jump at the southerly change,
+  // which the continuity assert caught. So integrate once at build time into an
+  // immutable table; sampling stays a pure function of t.
+  // Mean flow only (base curve, no gusts): eddies are carried by the wind, they
+  // don't surf their own gust, and it keeps the drift rate smooth.
+  const DRIFT_DT = 0.25;
+  const driftX = [], driftZ = [];
+  {
+    let dx = 0, dz = 0;
+    const n = Math.ceil((duration + 2) / DRIFT_DT) + 2;
+    for (let i = 0; i < n; i++) {
+      driftX.push(dx); driftZ.push(dz);
+      const tt = i * DRIFT_DT;
+      const u = sampleCurve(def.baseCurve, tt) * advect;
+      const d = dirAt(tt);
+      dx += Math.cos(d) * u * DRIFT_DT;
+      dz += Math.sin(d) * u * DRIFT_DT;
+    }
+  }
+  const drift = { x: 0, z: 0 };
+  function driftAt(t) {
+    if (t <= 0) { drift.x = 0; drift.z = 0; return drift; }
+    const f = t / DRIFT_DT;
+    let i = Math.floor(f);
+    if (i > driftX.length - 2) i = driftX.length - 2;   // past the end: extrapolate
+    const k = f - i;
+    drift.x = driftX[i] + (driftX[i + 1] - driftX[i]) * k;
+    drift.z = driftZ[i] + (driftZ[i + 1] - driftZ[i]) * k;
+    return drift;
+  }
+
+  /** Speed multiplier: smooth noise, carried downwind. */
+  function spatialFactor(x, z, t) {
+    if (amp <= 0) return 1;
+    const d = driftAt(t);
+    const nx = (x - d.x) / scale;
+    const nz = (z - d.z) / scale;
+    const n = 0.65 * valueNoise2(nx, nz, nSeed)
+            + 0.35 * valueNoise2(nx * 2.2 + 31.7, nz * 2.2 + 11.3, nSeed ^ 0x51ed270b);
+    return 1 + (n - 0.5) * 2 * amp;
+  }
+
+  /** Trees knock a hole downwind of themselves. Cheap, and very juicy. */
+  function shelterFactor(x, z, dirX, dirZ) {
+    let f = 1;
+    for (let i = 0; i < shelters.length; i++) {
+      const s = shelters[i];
+      const rx = x - s.x, rz = z - s.z;
+      const along = rx * dirX + rz * dirZ;          // >0 = downwind of the tree
+      if (along <= 0 || along >= s.length) continue;
+      const perp = Math.abs(rx * dirZ - rz * dirX);
+      if (perp >= s.radius) continue;
+      // ramp in over the first half-radius so the shadow can't snap on at along=0
+      const fAlong = smoothstep(0, s.radius * 0.5, along) * (1 - smoothstep(0, s.length, along));
+      const fPerp = 1 - smoothstep(0, s.radius, perp);
+      f *= 1 - s.strength * fAlong * fPerp;
+    }
+    return f;
+  }
+
+  const field = {
+    def,
+    seed,
+    gusts,
+    duration,
+
+    /**
+     * Trees/house register wind shadows. Lane A calls this after building the
+     * yard; unset = no shadows, so nothing breaks before world.js lands.
+     * @param {Array<{x,z,radius,strength,length}>} list
+     */
+    setShelters(list) {
+      shelters = (list || []).map((s) => ({
+        x: s.x, z: s.z,
+        radius: s.radius ?? 2.5,
+        strength: Math.min(1, Math.max(0, s.strength ?? 0.45)),
+        length: s.length ?? (s.radius ?? 2.5) * 4,
+      }));
+      return field;
+    },
+    get shelters() { return shelters; },
+
+    /** Scalar wind speed (m/s) at a point. The cheap path — no allocation. */
+    speedAt(x, z, t) {
+      const uni = uniformSpeed(t);
+      const d = dirAt(t);
+      const s = uni * spatialFactor(x, z, t) * shelterFactor(x, z, Math.cos(d), Math.sin(d));
+      return s > 0 ? s : 0;
+    },
+
+    dirAt,
+    uniformSpeed,
+    gustOnly,
+
+    /** 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);
+      if (s < 0) s = 0;
+      out.x = dirX * s;
+      out.y = 0;                       // wind is horizontal; lift is the sail's job (Lane B)
+      out.z = dirZ * s;
+      return out;
+    },
+
+    /**
+     * The next gust that has been telegraphed but hasn't started ramping.
+     * eta = seconds until the wind actually rises. Null when nothing's inbound.
+     */
+    telegraph(t) {
+      for (let i = 0; i < gusts.length; i++) {
+        const g = gusts[i];
+        if (t < g.t0) return null;     // sorted — next one hasn't telegraphed yet
+        if (t < g.rampAt) {
+          return { eta: g.rampAt - t, dir: dirAt(g.rampAt), power: g.pow };
+        }
+      }
+      return null;
+    },
+
+    /** Storm events (windchange/debris) fired in (a, b]. Pure — replayable. */
+    eventsBetween(a, b) {
+      const evs = def.events || [];
+      const out = [];
+      for (let i = 0; i < evs.length; i++) {
+        if (evs[i].t > a && evs[i].t <= b) out.push(evs[i]);
+      }
+      return out;
+    },
+
+    /** 0..1 rain intensity for skyfx. */
+    rainAt(t) {
+      const r = def.rain;
+      if (!r) return 0;
+      if (r.curve) return Math.min(1, Math.max(0, sampleCurve(r.curve, t)));
+      return Math.min(1, Math.max(0, r.intensity ?? 0));
+    },
+  };
+
+  return field;
+}
+
+// ---------- storm JSON validator ----------
+// Storms are data so design can tune without code (PLAN3D §4) — which means a
+// typo is a data bug, and data bugs should fail loud, not silently blow calm.
+export function validateStorm(def, name = 'storm') {
+  const errors = [];
+  const bad = (m) => errors.push(`${name}: ${m}`);
+  const isCurve = (c) => Array.isArray(c) && c.length > 0
+    && c.every((p) => Array.isArray(p) && p.length === 2 && p.every(Number.isFinite));
+  const monotonic = (c) => c.every((p, i) => i === 0 || p[0] >= c[i - 1][0]);
+
+  if (!def || typeof def !== 'object') { bad('not an object'); return { ok: false, errors }; }
+  if (!Number.isFinite(def.duration) || def.duration <= 0) bad('duration must be a positive number');
+
+  if (!isCurve(def.baseCurve)) bad('baseCurve must be [[t,speed],...] of finite numbers');
+  else {
+    if (!monotonic(def.baseCurve)) bad('baseCurve t must be non-decreasing');
+    if (def.baseCurve.some((p) => p[1] < 0)) bad('baseCurve speed must be >= 0');
+    const end = def.baseCurve[def.baseCurve.length - 1][0];
+    if (Number.isFinite(def.duration) && end < def.duration) {
+      bad(`baseCurve ends at t=${end} but storm runs to ${def.duration} — tail would flatline`);
+    }
+  }
+
+  if (!isCurve(def.dirCurve)) bad('dirCurve must be [[t,radians],...] of finite numbers');
+  else if (!monotonic(def.dirCurve)) bad('dirCurve t must be non-decreasing');
+
+  const g = def.gusts;
+  if (!g || typeof g !== 'object') bad('gusts block missing');
+  else {
+    const minGap = g.minGap ?? 5, maxGap = g.maxGap ?? 12;
+    if (!(minGap > 0)) bad('gusts.minGap must be > 0 (else the timeline never advances)');
+    if (maxGap < minGap) bad('gusts.maxGap must be >= minGap');
+    // 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');
+  }
+
+  for (const e of def.events || []) {
+    if (!Number.isFinite(e.t)) bad(`event ${JSON.stringify(e)} has no finite t`);
+    if (!e.type) bad(`event at t=${e.t} has no type`);
+    if (e.type === 'debris' && !e.model) bad(`debris event at t=${e.t} has no model`);
+    // A windchange event is HUD metadata; dirCurve is the physics. If they drift
+    // apart the player gets warned about a swing that never comes.
+    if (e.type === 'windchange' && isCurve(def.dirCurve)) {
+      const before = sampleAngleCurve(def.dirCurve, e.t - 0.5);
+      const after = sampleAngleCurve(def.dirCurve, e.t + (e.over ?? 6));
+      const swing = Math.abs(lerpAngle(before, after, 1) - before);
+      if (swing < 0.5) {
+        bad(`windchange at t=${e.t} promises a swing but dirCurve only turns ${swing.toFixed(2)} rad by t=${e.t + (e.over ?? 6)}`);
+      }
+    }
+  }
+
+  if (def.rain && def.rain.curve && !isCurve(def.rain.curve)) bad('rain.curve must be [[t,intensity],...]');
+
+  return { ok: errors.length === 0, errors };
+}

web/world/js/weather.js

@@ -0,0 +1,101 @@
+'use strict';
+// SHADES — Lane C — weather: the wind field everyone samples.
+//
+// Implements the contracts.js wind surface (PLAN3D §4):
+//   wind.sample(pos, t) -> Vector3        m/s, includes gusts & local effects
+//   wind.gustTelegraph(t) -> {eta, dir, power} | null
+//
+// All the maths lives in weather.core.js (pure, no imports). This file is just
+// the THREE adapter + storm loading, so the sim stays node-testable and the
+// determinism rule can't be broken by accident.
+
+import * as THREE from '../vendor/three.module.js';
+import { createWindField, validateStorm, GUST } from './weather.core.js';
+
+export { GUST, validateStorm };
+
+// Resolved against this module, not the server root: server.py serves the repo
+// root (so the 2D prototype stays reachable), but the demo bench serves web/.
+// import.meta.url is right under both, and under whatever Lane A does next.
+const STORM_DIR = new URL('../data/storms', import.meta.url).href;
+
+/** Fetch + validate a storm def. Throws loud on bad data — storms are content. */
+export async function loadStorm(name, dir = STORM_DIR) {
+  const url = `${dir}/${name}.json`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`weather: cannot load ${url} (${res.status})`);
+  const def = await res.json();
+  const { ok, errors } = validateStorm(def, name);
+  if (!ok) throw new Error(`weather: ${url} is invalid:\n  ${errors.join('\n  ')}`);
+  return def;
+}
+
+/**
+ * @param {object} def   parsed storm JSON
+ * @param {object} [opts] {seed} — same seed + same def = same storm, every run
+ * @returns the `wind` object from contracts.js
+ */
+export function createWind(def, opts = {}) {
+  const field = createWindField(def, opts);
+  const scratch = { x: 0, y: 0, z: 0 };
+
+  const wind = {
+    /**
+     * Wind velocity at a world position, m/s.
+     * @param {THREE.Vector3} pos
+     * @param {number} t              storm time, seconds
+     * @param {THREE.Vector3} [out]   pass one to avoid allocating — sail.js
+     *                                samples per-face per-frame, so this matters
+     */
+    sample(pos, t, out) {
+      const v = out || new THREE.Vector3();
+      field.vecAt(pos.x, pos.z, t, scratch);
+      return v.set(scratch.x, scratch.y, scratch.z);
+    },
+
+    /** Scalar speed — for HUD, rain, grass. Cheaper than sample(); no allocation. */
+    speedAt(pos, t) {
+      return field.speedAt(pos.x, pos.z, t);
+    },
+
+    /** {eta, dir, power} while a gust is inbound but hasn't risen yet, else null. */
+    gustTelegraph(t) {
+      return field.telegraph(t);
+    },
+
+    /**
+     * Register wind shadows (trees, house). Lane A: call after the yard is built.
+     * Until then there are simply no shadows — nothing breaks.
+     * @param {Array<{x,z,radius,strength,length}>} list
+     */
+    setShelters(list) { field.setShelters(list); return wind; },
+
+    /** Convenience: take shadows straight off world.anchors' tree entries. */
+    setSheltersFromTrees(trees, o = {}) {
+      return wind.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,
+      })));
+    },
+
+    /** Storm events fired in (a,b] — poll with (t-dt, t). Deterministic. */
+    eventsBetween(a, b) { return field.eventsBetween(a, b); },
+
+    /** 0..1 rain intensity. */
+    rainAt(t) { return field.rainAt(t); },
+
+    /** Direction (radians, XZ plane from +X toward +Z) ignoring local effects. */
+    dirAt(t) { return field.dirAt(t); },
+
+    get duration() { return field.duration; },
+    get gusts() { return field.gusts; },
+    get def() { return field.def; },
+    get seed() { return field.seed; },
+    core: field,
+  };
+
+  return wind;
+}

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';
 

web/world/weather_demo.html

@@ -0,0 +1,263 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>SHADES — Lane C — weather bench</title>
+<style>
+:root { --ink:#d8d8e0; --gold:#ffd23d; --neon:#3dff8b; }
+* { box-sizing:border-box; }
+body { margin:0; overflow:hidden; background:#000;
+  font:13px/1.45 "Courier New", ui-monospace, monospace; color:var(--ink); }
+canvas { display:block; }
+#hud { position:fixed; top:10px; left:10px; background:rgba(6,6,12,.75); padding:8px 12px;
+  border:1px solid #26263a; z-index:3; min-width:250px; }
+#hud b { color:var(--gold); }
+#hud .warn { color:#ff6; font-weight:bold; }
+#hud .bad { color:#f66; font-weight:bold; }
+#ctl { position:fixed; bottom:10px; left:10px; background:rgba(6,6,12,.8); padding:8px 12px;
+  border:1px solid #26263a; z-index:3; }
+#ctl button { background:#1d1d2b; color:var(--ink); border:1px solid #666; font:inherit;
+  padding:4px 9px; cursor:pointer; }
+#ctl button:hover { border-color:var(--neon); color:var(--neon); }
+#ctl input[type=range] { width:220px; vertical-align:middle; }
+#note { position:fixed; top:10px; right:10px; background:rgba(6,6,12,.75); padding:8px 12px;
+  border:1px solid #26263a; z-index:3; max-width:280px; color:#8a8a99; }
+.bar { display:inline-block; width:90px; height:7px; border:1px solid #555; vertical-align:middle; }
+.bar i { display:block; height:100%; background:var(--neon); }
+</style>
+</head>
+<body>
+<canvas id="c"></canvas>
+<div id="hud"></div>
+<div id="note">
+  <b>Lane C bench.</b> Graybox stand-in for Lane A's yard — this exists to drive
+  weather.js / skyfx.js / debris.js before M0 lands. The sail here is a MOCK
+  (Lane B owns the real one); it's a bare node grid so debris impulse is visible.
+  <br><br>drag = orbit · click = start audio
+</div>
+<div id="ctl"></div>
+
+<script type="module">
+import * as THREE from './vendor/three.module.js';
+import { loadStorm, createWind } from './js/weather.js';
+import { createSkyFx } from './js/skyfx.js';
+import { createDebris } from './js/debris.js';
+
+const canvas = document.getElementById('c');
+const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+renderer.setPixelRatio(Math.min(2, devicePixelRatio));
+renderer.shadowMap.enabled = true;
+const scene = new THREE.Scene();
+scene.background = new THREE.Color(0x9fc4e8);
+const camera = new THREE.PerspectiveCamera(55, 1, 0.1, 500);
+
+// --- graybox yard: 30×20 m, origin centre (stands in for Lane A's world.js) ---
+const ground = new THREE.Mesh(
+  new THREE.PlaneGeometry(30, 20),
+  new THREE.MeshStandardMaterial({ color: 0x4a7c3f, roughness: 1 }),
+);
+ground.rotation.x = -Math.PI / 2;
+ground.receiveShadow = true;
+scene.add(ground);
+
+// Lane A's landed yard (THREADS): t1 (-9,2), t2 (8,-2), house edge at z=-9.9
+const TREES = [{ x: -9, z: 2 }, { x: 8, z: -2 }];
+for (const tr of TREES) {
+  const trunk = new THREE.Mesh(
+    new THREE.CylinderGeometry(0.2, 0.28, 4, 8),
+    new THREE.MeshStandardMaterial({ color: 0x5a3d24 }),
+  );
+  trunk.position.set(tr.x, 2, tr.z);
+  trunk.castShadow = true;
+  scene.add(trunk);
+  const canopy = new THREE.Mesh(
+    new THREE.SphereGeometry(3, 12, 8),
+    new THREE.MeshStandardMaterial({ color: 0x285f23 }),
+  );
+  canopy.position.set(tr.x, 5, tr.z);
+  canopy.castShadow = true;
+  scene.add(canopy);
+}
+// house edge along north (-Z), for scale
+const house = new THREE.Mesh(
+  new THREE.BoxGeometry(30, 3.2, 1),
+  new THREE.MeshStandardMaterial({ color: 0x8a8f96 }),
+);
+house.position.set(0, 1.6, -10.4);
+scene.add(house);
+// the thing you're protecting — Lane A's gardenBed rect
+const bed = new THREE.Mesh(
+  new THREE.BoxGeometry(6, 0.25, 4),
+  new THREE.MeshStandardMaterial({ color: 0x6b4a2f }),
+);
+bed.position.set(1, 0.12, 2);
+scene.add(bed);
+// 1.7 m reference person
+const ref = new THREE.Mesh(
+  new THREE.CapsuleGeometry(0.25, 1.2, 4, 8),
+  new THREE.MeshStandardMaterial({ color: 0xffd27a }),
+);
+ref.position.set(2, 0.85, 2);
+ref.castShadow = true;
+scene.add(ref);
+const player = { pos: ref.position, carrying: null, busy: false };
+
+const sun = new THREE.DirectionalLight(0xfff4e0, 2.2);
+sun.position.set(-12, 18, 6);
+sun.castShadow = true;
+sun.shadow.mapSize.set(1024, 1024);
+scene.add(sun);
+const hemi = new THREE.HemisphereLight(0xbfd8ff, 0x3a4a2a, 0.9);
+scene.add(hemi);
+
+// --- MOCK sail (Lane B owns the real cloth) — a bare node grid so we can see
+// debris shove it and drive the creak/flog audio off corner loads.
+const N = 9;
+const nodes = [];
+for (let v = 0; v < N; v++) {
+  for (let u = 0; u < N; u++) {
+    nodes.push({ x: -4 + (u / (N - 1)) * 8, y: 3.2, z: -3 + (v / (N - 1)) * 6 });
+  }
+}
+const sailGeo = new THREE.BufferGeometry();
+sailGeo.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(nodes.length * 3), 3));
+const sailPts = new THREE.Points(sailGeo, new THREE.PointsMaterial({ color: 0xe8c46a, size: 0.14 }));
+scene.add(sailPts);
+const mockSail = {
+  nodes,
+  corners: [
+    { anchorId: 'h1', hw: { name: 'carabiner', rating: 9 }, load: 0, broken: false },
+    { anchorId: 'h3', hw: { name: 'shackle', rating: 19 }, load: 0, broken: false },
+    { anchorId: 'p1', hw: { name: 'shackle', rating: 19 }, load: 0, broken: false },
+    { anchorId: 'p2', hw: { name: 'carabiner', rating: 9 }, load: 0, broken: false },
+  ],
+};
+
+// --- weather ---
+const params = new URLSearchParams(location.search);
+const stormName = params.get('storm') || 'storm_02_wildnight';
+const def = await loadStorm(stormName);
+const wind = createWind(def);
+wind.setShelters(TREES.map((t) => ({ x: t.x, z: t.z, radius: 3, strength: 0.45, length: 14 })));
+
+const ticker = [];
+const sky = createSkyFx({ scene, camera, wind, sun, hemi, onEvent: (s) => ticker.unshift(s) });
+const debris = createDebris({
+  wind, scene, player,
+  onEvent: (s) => ticker.unshift(s),
+  onHitPlayer: (p, impact) => ticker.unshift(`KNOCKED DOWN by ${p.model} (${impact.toFixed(0)})`),
+});
+addEventListener('pointerdown', () => sky.unlockAudio(), { once: true });
+
+// --- controls ---
+let t = 0, playing = true, rate = 1;
+const ctl = document.getElementById('ctl');
+ctl.innerHTML = `
+  <button id="play">pause</button>
+  <button id="r1">1×</button><button id="r4">4×</button><button id="r0">0.25×</button>
+  <button id="reset">reset</button>
+  <button id="break">break a corner</button>
+  <button id="crate">throw a crate</button>
+  <input id="scrub" type="range" min="0" max="${def.duration}" step="0.1" value="0">
+`;
+const $ = (id) => document.getElementById(id);
+$('play').onclick = () => { playing = !playing; $('play').textContent = playing ? 'pause' : 'play'; };
+$('r1').onclick = () => { rate = 1; };
+$('r4').onclick = () => { rate = 4; };
+$('r0').onclick = () => { rate = 0.25; };
+$('reset').onclick = () => { t = 0; debris.clear(); ticker.length = 0; mockSail.corners.forEach((c) => { c.broken = false; }); };
+$('break').onclick = () => { const c = mockSail.corners.find((x) => !x.broken); if (c) { c.broken = true; ticker.unshift(`${c.hw.name} BLOWS at ${c.anchorId.toUpperCase()}!`); } };
+$('crate').onclick = () => debris.spawn({ model: 'BlueCrate_v2', lateral: (Math.random() * 6 - 3), text: 'crate!' }, t);
+$('scrub').oninput = (e) => { t = parseFloat(e.target.value); debris.clear(); };
+
+let yaw = 0.7, pitch = 0.28, dist = 26, dragging = false, lx = 0, ly = 0;
+addEventListener('pointerdown', (e) => { dragging = true; lx = e.clientX; ly = e.clientY; });
+addEventListener('pointerup', () => { dragging = false; });
+addEventListener('pointermove', (e) => {
+  if (!dragging) return;
+  yaw -= (e.clientX - lx) * 0.005; pitch = Math.min(1.3, Math.max(0.05, pitch + (e.clientY - ly) * 0.004));
+  lx = e.clientX; ly = e.clientY;
+});
+addEventListener('wheel', (e) => { dist = Math.min(60, Math.max(8, dist + e.deltaY * 0.02)); });
+
+function resize() {
+  const w = innerWidth, h = innerHeight;
+  renderer.setSize(w, h);
+  camera.aspect = w / h;
+  camera.updateProjectionMatrix();
+}
+addEventListener('resize', resize); resize();
+
+// --- loop: fixed-dt sim, rAF only drives the clock (PLAN3D §0) ---
+const DT = 1 / 60;
+let acc = 0, last = performance.now();
+const hud = document.getElementById('hud');
+const probe = new THREE.Vector3();
+const w = new THREE.Vector3();
+const posAttr = sailGeo.getAttribute('position');
+
+function frame(now) {
+  const real = Math.min(0.1, (now - last) / 1000);
+  last = now;
+  if (playing) acc += real * rate;
+
+  while (acc >= DT) {
+    acc -= DT;
+    t += DT;
+    if (t > def.duration) t = 0;
+
+    // mock cloth: nodes just bob with local wind so debris has something to hit
+    for (const n of nodes) {
+      probe.set(n.x, n.y, n.z);
+      wind.sample(probe, t, w);
+      const sp = Math.hypot(w.x, w.z);
+      n.y += ((3.2 + Math.sin(t * 3 + n.x) * sp * 0.02) - n.y) * 0.08;
+    }
+    // mock loads so the creak layer has something to track
+    probe.set(0, 3.2, 0);
+    const sp = wind.speedAt(probe, t);
+    mockSail.corners.forEach((c, i) => {
+      c.load = c.broken ? 0 : sp * sp * 0.021 * (0.7 + i * 0.16);
+    });
+
+    debris.step(DT, t, { player, sail: mockSail });
+    sky.step(DT, t, { sail: mockSail });
+  }
+
+  for (let i = 0; i < nodes.length; i++) posAttr.setXYZ(i, nodes[i].x, nodes[i].y, nodes[i].z);
+  posAttr.needsUpdate = true;
+
+  camera.position.set(
+    Math.sin(yaw) * Math.cos(pitch) * dist,
+    Math.sin(pitch) * dist + 1.5,
+    Math.cos(yaw) * Math.cos(pitch) * dist,
+  );
+  camera.lookAt(0, 2, 0);
+
+  $('scrub').value = t.toFixed(1);
+  probe.set(0, 1.7, 0);
+  wind.sample(probe, t, w);
+  const speed = Math.hypot(w.x, w.z);
+  const tg = wind.gustTelegraph(t);
+  const worst = Math.max(...mockSail.corners.map((c) => (c.broken ? 0 : c.load / c.hw.rating)));
+  hud.innerHTML = `
+    <div><b>${def.name}</b> — ${stormName}</div>
+    <div>t        <b>${t.toFixed(1)}</b> / ${def.duration}s  (${rate}×)</div>
+    <div>wind     <b>${speed.toFixed(1)}</b> m/s (${(speed * 3.6).toFixed(0)} km/h)</div>
+    <div>dir      ${(wind.dirAt(t)).toFixed(2)} rad</div>
+    <div>rain     <span class="bar"><i style="width:${wind.rainAt(t) * 100}%"></i></span></div>
+    <div>worst    <span class="bar"><i style="width:${Math.min(100, worst * 100)}%;background:${worst > 0.8 ? '#f66' : '#3dff8b'}"></i></span></div>
+    <div>debris   ${debris.pieces.length}   audio ${sky.audio.ready ? sky.audio.state : '(click)'}</div>
+    <div>flash    ${sky.flash.toFixed(2)}</div>
+    ${tg ? `<div class="warn">GUST INBOUND ${tg.eta.toFixed(1)}s  pow ${tg.power.toFixed(0)}</div>` : '<div>&nbsp;</div>'}
+    ${ticker.slice(0, 3).map((s) => `<div class="bad">${s}</div>`).join('')}
+  `;
+
+  renderer.render(scene, camera);
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);
+window.__bench = { wind, sky, debris, mockSail, def, get t() { return t; } };
+</script>
+</body>
+</html>