@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/PROBE_CLIPMAP_PROPOSAL_2026_10_27.md

@@ -424,7 +424,7 @@ the SDF [49:08].
 | moving-average estimator, 5 u32 per texel | exponential blend over a response time in seconds (§8.8) | DDGI's form; one history; a physical knob |
 | SDF shadow ray per hit for the sun | same (§8.6) | shadow maps answer "lit" off screen (§1) |
 | light cache for point lights | the world light clusters, keyed by this clipmap (§8.7) | reuse |
-| world-cache probes at hits | not in v1 (§17) | a second probe kind; added only if off-screen bounce measures short |
+| world-cache probes at hits | hits want the probes they read, one step from the screen, the one probe kind (§8.3) | the off-screen bounce measured short at S5a (D31) |
 | stochastic 1-of-8 + reservoirs + denoise | 2 of 8 by Brick4's WRS, resolved by TAA (§9.1, §9.4) | the review; two probe reads, no denoiser |
 | prefiltered radiance levels for specular | the radiance tap blended with GGX-convolved SH2 by roughness (§9.3) | the review: WebGPU's mips; LPV's blend |
 | ambient probes and froxel GI | the existing irradiance clipmap samples this mode's probes (§9.5) | fog has no GI in any mode today |
@@ -1535,6 +1535,263 @@ no cache. The provider, per taken key:
 Triangle work here happens per requested cell (scroll-ins and changes), never per frame. It is bounded
 by the cut error: at error ½·h_c, a cell's triangles number on the order of its surface in voxels.
 
+**What the vgeo runtime gave, read before building (2026-10-29)**. The plan and its choices are the shared
+note `s7-vgeo-provider-plan-2026-10-29.md`; Alex took them with "make sure we don't introduce more
+coupling. If you need to refactor how wants work - please do so. Keep performance in mind. [...] DRY and
+KISS".
+- vgeo rows are ordinary `meshes` rows in the scene's TLAS with an empty BLAS;
+  `geometries[row.geometry].vg_row` names the geometry's root page and page lookup.
+- The cut's rule was fused into the camera's traverse kernel with its drawing, claims and subgroup
+  scheduling, so no other kernel could call it.
+- Wants reach the residency only through the frame's feedback slots, whose reading wrote a view's fields.
+- No event says a page arrived: counters and lookups only.
+- A cut of its own a lane a pair would be a per-thread loop of hundreds of steps. The camera cut's wavefront
+  is the engine's answer to that (one item a lane a step, a uniform step bound, spills between dispatches),
+  so the box cut runs it rather than a walk of its own.
+
+**As built (S7a, 2026-10-29)**: the vgeo runtime, refactored so that a box cut runs the camera cut's rule and
+descent, the camera's cut unchanged.
+- `chunk_vgeo_cut_rule`: the cut's items and expansions, and the rule as two verdicts, `vg_cut_node` and
+  `vg_cut_cluster` (`VGEO_CUT_VERDICT`). The importing kernel defines the two culls,
+  `vg_cut_sphere_outside` and `vg_cut_box_outside`.
+- `chunk_vgeo_cut_descent`: what the descent does with a verdict (counts, wants, claims, the walk up) and the
+  wavefront's scheduling, with one more hook, `vg_cut_take`, for what taking a cluster means. The camera's
+  traverse is that chunk with its frustum culls and `vg_draw`.
+- `graph_vgeo_cut_descent`: the seam's seed, wavefront and tail, for any cut's instance records and traverse
+  kernel. The seam keeps its collect.
+- `vg_want` and `vg_stat` are chunks of their own, so a kernel that only counts binds no claim buffer.
+- A feedback slot is any `VGeoFeedbackConsumer`'s: the loop hands each consumer its slot's counters through
+  `read_feedback`, and whether it shared the slot. `VGeoViewCut` implements it. The runtime fills a slot's
+  own params (`fill_slot_params`) for any cut.
+- Measured on Zorah (the textured UE rebuild: 1,012 containers, 12,597 instances) from its manifest's camera
+  at 1280×720. Blocks of frames alternated the refactored traverse with the one before S7a, for every cut of
+  the frame, once after the rule moved and again after the descent did.
+  - The frame view's counters are the same between the arms on both GPUs: 32,618 clusters drawn, 163,353
+    items, 10,822 pages, 144,079 clusters tested once settled. The 4090's second run held 118 clamped
+    clusters in both arms.
+  - The traverse's 80 dispatches a frame cost the same: p50 0.96 and 1.00 of before on the RTX 4090
+    (1.93 against 1.92 ms the second time), 0.99 and 0.98 on the AMD iGPU (4.19 against 4.27 ms).
+- Tier 2: the cut agreement spec runs the traverse on the emulator unchanged. `VGeoFeedbackLoop.spec.js`
+  adds a consumer that is not a view (handed its counters, told when it shared its slot) and a slot's params
+  against the feedback's wire layout, which no spec held before. `graph_vgeo_expand.spec.js` counts the
+  wavefronts a cut records and encodes a cut's graph on the software device, which no spec did either.
+  20 of 20 mutants were killed.
+
+**As built (S7b, 2026-10-29)**: the gather and the box cut, which leave each taken cell a list of the clusters in
+its cut. Not registered yet: S7c's distance pass is the lists' reader.
+- `VGeoBrickProvider`, a `BrickProvider` with a `VGeoViewCut` of its own. In a frame the scene's vgeo runtime has
+  open, it records the gather, the claim widths scanned by `graph_prefix_scan_csdldf`, and `graph_vgeo_cut_descent`
+  with `shader_vgeo_brick_traverse`, then publishes the cut's feedback: its wants reach the residency through its
+  own slot, ranked with the camera's, and its counters come back to its cut. With no runtime, or none open, it
+  records nothing.
+- `shader_vgeo_brick_gather`: a 64-lane workgroup a taken cell, dispatched by take, running the mesh provider's
+  cooperative TLAS query over the cell ⊕ R.
+  - `vgeo_brick_accept` takes a row in the SDF world whose geometry is virtual and whose box is at least ½ voxel
+    across.
+  - `vgeo_brick_pair` writes a cut's instance record for each. k is σ_max/(½·h_c), the distance weight is 0 and
+    there is no eye, so `vg_project` is the world error over ½·h_c against τ = 1. The cell ⊕ R box, taken into the
+    instance's object space as the bounds of its eight corners, goes in the record's frustum words, and the
+    taken cell in word 30.
+  - A flattened instance makes no pair. Pairs past `budget × 8` records are dropped and counted, as is what the
+    query drops.
+- `shader_vgeo_brick_traverse`: `chunk_vgeo_cut_descent`, culled by the box's six faces, a sphere as its cube.
+  The take puts a cluster onto its cell's list as its pair and its meshlet row, up to 64. A list counts past what
+  it holds, and the clusters past it are counted dropped (`MESHLETS_DROPPED`).
+- Shared rather than copied: `chunk_vgeo_cut_instance` (what any collect writes of an instance record, now under
+  the camera's collect too) and `chunk_brick_provider` (a taken cell's key, window, voxel and band, and the
+  resolution test, now under the mesh provider too).
+- Tier 2, on the emulator:
+  - `vgeo_brick_traverse.spec.js` runs the seed, prepare, the box traverse and the remainder over a built torus
+    of 26 pages. Each list is the CPU oracle's cut at the pair's error with the pair's box as its planes
+    (`VGeoCutView.plane_count`, new: a camera tests five).
+    - Six fine cells around the ring and over and under the tube take 8 to 10 clusters each, and the whole ring
+      at a coarse error 7 over 3 pages.
+    - With a page withheld, the cell takes the oracle's stand-in, counts the clamp, and wants the page through
+      the cut's slot.
+    - Ten instances in one cell take 70 clusters: the list holds 64, counts 70, and 6 are counted dropped.
+  - `vgeo_brick_pair.spec.js` covers the accept and the record under a skew turn and a non-uniform scale:
+    k, w, the eye in a buffer of stale NaNs, the box, the cell, and the cut's own fields. It also covers the
+    drops.
+- Tier 3: `VGeoBrickProvider.spec.js` on the software device.
+  - Nothing is recorded without an open runtime.
+  - The gather runs through take, then the cut's wavefronts, between clear and free.
+  - τ is 1 with the camera's at 3; the cut has a slot of its own; its tail publishes the frame's feedback;
+    destroy gives back what it made.
+- 37 of 38 mutants were killed. The survivor never culls by a sphere, which changes nothing on the torus: its
+  pages hold a node each. A page's sphere lies outside the box only if the cluster refining into it does, so
+  the sphere decides at a page's inner nodes alone.
+- The gather is a barrier kernel the emulator cannot run, as the mesh provider's is. Its glue is checked on the
+  device in S7c, once the lists have a reader.
+
+**As built (S7c, 2026-10-29)**: the distances, and the provider registered: the GI runs it after the mesh
+provider, before the plugins.
+- `shader_vgeo_brick_distance` runs a 256-lane workgroup for each taken cell that the box cut put a cluster in.
+  The traverse lists a cell at its first take (`vgeo_brick_filled`), and `graph_build_indirect_dispatch_command`
+  turns the count into the dispatch. The plan's two passes are kept as the cut and this one: the triangles are
+  culled at the start of this pass, so the frame carries each cell's 516-byte cluster list rather than a triangle
+  list (about 42 MB at 4,096 cells).
+  - Triangles: a lane a triangle, two of the list's clusters at a time. A triangle whose box misses its pair's
+    (the cell ⊕ R, in the instance's space) lies past the band from every texel and is skipped. The rest go into
+    workgroup memory, up to 256 (§7.8's choice), past it dropped and counted. They are held in the cell's own
+    space, the translation taken less the cell's origin first, and wound out of the surface their instance
+    draws: `triangle_winding_is_reversed` swaps b and c.
+  - Texels, two a lane, `vgeo_brick_texel`: the nearest triangle within the band, signed by its side. Of
+    triangles as near, the one whose normal lies most along the texel's offset decides; "as near" is a tolerance
+    derived from the closest points' rounding in the cell's space, 2.0·10⁻³ of the squared distance. A material
+    drawn on both sides signs positive, as UE's two-sided fields do. Past the band a texel is unsigned, so
+    positive.
+  - The merge: the bytes meet in workgroup memory. A lane a staged word takes each byte's least (contracts 1 and
+    2). A lane an object cell writes the vgeo row where its nearest texel is nearer than the staged minimum from
+    before the merge (contract 3).
+- Shared rather than copied:
+  - `chunk_brick_object`: the encoding and the object bids, out of the mesh provider, renamed `brick_*`;
+  - `chunk_read_meshlet_triangle_positions`, which `read_meshlet_triangle_bounds` is now built on;
+  - `chunk_brick_provider_cell`, split out of `chunk_brick_provider`;
+  - `chunk_vgeo_brick_box`, the traverse's too.
+
+  A cell's list carries its key. `graph_vgeo_cut_descent` returns the records at the seed's version, their claim
+  bases in them.
+- Tier 2, `vgeo_brick_distance.spec.js`:
+  - the cull, past each of the six faces;
+  - the placement: a turn, a scale, an offset origin, reversed, the reach, sided;
+  - the texel over an octahedron against a brute force of the closest points: the distance to 5 places, the
+    sign, the row's triangle as near as the nearest, and none past the band;
+  - two faces meeting at 15°, whose planes disagree in front of their edge: the face the texel stands over
+    decides, in either order;
+  - a two-sided surface, positive on both sides.
+
+  `vgeo_brick_traverse.spec.js` holds the filled list: each cell that took a cluster, once. Tier 3: the
+  distance pass between the cut and free; the GI's order with the scene's vgeo open. 30 of 30 mutants were
+  killed.
+- Device, on both GPUs: two tori built in the page (128×48, 40 pages), one of them mirrored. The mode was entered
+  again until no fill clamped, which was the second fill (S7d is the re-queue), and every brick texel was held to
+  the analytic distance.
+  - The mean error is 1.9–2.4 bytes and p99 is at most 8 bytes (a quarter voxel), against the half-voxel bound
+    of 17. No cell the surface crosses is without a brick.
+  - 65 texels at cascade 0 (of 180,751 within the band) have the wrong sign. The vgeo builder's simplification
+    flipped 2 of the torus's triangles, at its inner top (cos −0.99 and −0.66 against the analytic normal), and
+    the nearest triangle's side follows them.
+  - The 256-triangle cap: 538 triangles were dropped, in cascade-1 cells whose 3.75 m box takes in a quarter of a
+    torus. 159 texels there are over the bound on the 4090, 178 on the iGPU, since atomic order picks the
+    triangles dropped. On a coarser torus (64×24) 275 are dropped and cascade 1 is clean, while three 15 m
+    cascade-3 cells over both tori drop instead.
+  - Inside the tube past the band (1.05 m against cascade 0's 0.5 m band), 24,314 texels are unsigned, so
+    positive, as §7.8 writes them.
+  - A fill frame, p50 / p90 / max:
+
+    | | gather | cut | distances |
+    |---|---|---|---|
+    | 4090 | 10 / 12 / 12 µs | 39 / 138 / 881 µs | 58 / 91 / 399 µs |
+    | iGPU | 605 / 619 / 728 µs | 20 / 63 / 248 µs | 1.3 µs / 1.04 / 6.49 ms |
+
+    The gather is a workgroup a taken cell, whose launch is the iGPU's 605 µs; the mesh provider's 1.07 ms here
+    is the same floor. With no vgeo in any cell, the cut's empty wavefronts cost 22 µs (4090) and 20 µs (iGPU).
+  - Dispatching the distances by the taken cells instead cost 1.73 ms on the iGPU with no vgeo in any cell, all
+    of it launch. By the filled count it costs 1.3 µs.
+- Sponza's census is the same on the tree before S7b and after, so both refactors left the mesh provider as it
+  was: 7,171 bricks in every census (progressive, again, fresh), every cascade's counts, and the instances
+  dropped past 64 (402, 460, 58).
+
+**As built (S7d, 2026-10-29)**: a cell built with a stand-in waits, and is built again once what it waited on
+arrives (contract 6).
+- The box traverse records a cell's first stand-in in its list header (`VGEO_BRICK_CELL_OFFSET`): the page it
+  stood in for, as its lookup word, and the group in that page. The first claimant writes them, decided by an add
+  on the header's count of stand-ins, so no compare-and-swap is needed. A clamp (the page not resident) and a held
+  group (resident, not selectable) wait alike, until the page is resident and the group selectable.
+- The distance pass puts each cell with a stand-in on a waiting list. The list holds budget × 4 cells; those past
+  it are dropped and counted.
+- `shader_vgeo_brick_wait` heads the provider's passes each frame, a thread a cell the last frame left waiting.
+  A cell whose page is resident and whose group is selectable is queued with `brick_clipmap_enqueue`, so exactly
+  the cells that stood something in are built again, once what they waited on is there. The rest wait on, onto
+  the list this frame's distances add to; the two lists trade places each frame.
+- Contract 6's seam on the device: the provider context hands a provider the clipmap's queue, as `state`, `ring`
+  and the new `pending` bits. A pass that queues cells writes `state` and hands its version on.
+- `vg_group_row` and `vg_group_selectable` move into `chunk_vgeo_cut_arena`, so a pass that asks whether a group
+  is drawable binds only the arena.
+- Tier 2, `vgeo_brick_wait.spec.js`, over the runtime's tables with a page withheld:
+  - a cell is queued, while one waits on the missing page and one on a group that page holds back;
+  - installing the page queues those two and no other;
+  - a key already pending is not queued twice;
+  - a list whose count runs past its capacity is read only as far as it holds.
+
+  `vgeo_brick_traverse.spec.js` checks that a clamp records its page and group, and that nothing is recorded when
+  all is resident; the torus's lookup now starts past word 0. Tier 3: the wait runs before the gather, indirect;
+  the distances bind the list the wait keeps onto; the lists trade places; destroy gives them back. 16 of 17
+  mutants were killed. The survivor drops the gather's reset of a cell's stand-ins, inside a barrier kernel that
+  only the device runs.
+- Device, on both GPUs: the tori of S7c in one fill, never left.
+  - The 4090 had 187 cells waiting at frame 10 and none at frame 20, by when all 15 pages were resident; nothing
+    clamped after frame 20. On the iGPU none waited at frame 10, and nothing clamped after it.
+  - The bricks are those S7c built by entering the mode again until no fill clamped. At cascade 0 the mean error
+    is 1.865 bytes on the 4090 and 1.862 on the iGPU, p99 6, with the same 66 and 64 texels of the wrong sign.
+    Cascades 2 to 5 have the same counts and errors; cascade 1 differs only in the texels the 256-triangle cap
+    leaves over the bound, by atomic order. No cell the surface crosses is without a brick.
+  - The wait costs 4.1 µs a frame at p50 on the 4090 (11 µs at worst) and 1.8 µs on the iGPU (6.2 µs).
+  - The iGPU's distances reached 13.1 ms in one frame, against a p90 of 1.4 µs. Zorah (S7e) is where that is
+    measured on a real scene.
+
+**As built (S7e, 2026-10-29)**: Zorah lit by its own geometry, measured; and the wait keeps its cells' wants.
+- Zorah, the textured UE rebuild (1,012 containers, 12,597 instances, 332,613 pages), one grey material, the
+  manifest's sun, 1280×720. Zorah has no other geometry, so all the probes see of it is the vgeo provider's bricks.
+  - At ground level, in an arcade, IBL leaves the frame black (mean luma 6.3 of 255; Zorah's IBL sky is black).
+    ProbeClipmap lights it from the sunlit floor: 19 to 37 over five runs, the probes 240 frames after the fill.
+  - Of the probes' rays, 70% hit Zorah's bricks at the manifest camera, 76% at ground level and 48% from the air.
+- Timings, p50 of a settled frame.
+  - The AMD iGPU: IBL 39.5 ms, ProbeClipmap 62.8 ms (+23.3 ms). That is the trace's 11.0 ms (8 ms on Sponza: Zorah's
+    bricks are denser), the fused indirect pass's 9.3 ms (as S6c2 measured it), light 2.1 ms, and every other pass
+    under 0.6 ms. The provider at rest costs ~20 µs: wait 3.5, gather 1.6, cut 11.1, distances 1.4.
+  - The 4090, sharing its GPU with another process (its medians stand, its maxima do not): 6.9 → 8.3 ms. The trace is
+    1.2 ms and the fused pass 81 µs.
+  - The fill on the iGPU (196,608 cells at 4,096 a frame, and the cells queued again): 62 ms a frame at p50, 69 ms
+    at p99 and 132 ms at worst. The distances take 56.6 ms in their worst frame, the cut 6.6 ms and the gather 3.6 ms.
+- **§7.8's bound does not hold on Zorah: its caps bind as budgets.** Over one fill on the iGPU (the 4090 is within
+  10%):
+  - 46% of the clusters the box cut took are past a cell's 64 (1.44M of 3.13M): 39% in cascade 0, rising to 79% in
+    cascade 5;
+  - 18–19.5M triangles are past a cell's 256: 9.8M in cascade 0, 6.4M in 1, 2.0M in 2;
+  - 80–150k pairs are past the records (103k in cascade 1), and the TLAS query drops 182–224k candidates and 48k
+    nodes.
+
+  A cell ⊕ R box in kitbashed content holds many overlapping instances and layered surfaces. The cut's error bounds
+  how big a triangle is, not how many surfaces cross a box.
+- What the image measures, and what it does not come from.
+  - Holes: from the air the ground plane's bricks are missing beside the greenhouse, and cells of the ground, the
+    greenhouse and the tower read inside out.
+  - Of the probes, 17–48% are dead and 8–16% of rays meet back faces. Sponza on the mesh caches has 1.6–4% dead and
+    2% back-face rays.
+  - With the provider's cut 4× and 16× coarser, the drops fall about threefold (triangles 19.3M → 6.2M → 5.6M,
+    clusters past a list 46% → 26% → 29%). The back faces, the dead probes and the holes stay. **The caps are not
+    what the image suffers from.**
+  - Each texel the least over its instances of that instance's own signed distance, in place of the nearest
+    triangle of all of them, is no better: back faces 8–18% and dead probes 18–54%. The nearest triangle's side is
+    the open question on content made of single-sided, interpenetrating pieces.
+  - The two tori of S7c, as vgeo and as plain meshes: of the probes deep inside a tube, vgeo leaves 4 alive and 36
+    dead, while the meshes' signed fields relocate 26 out alive and leave 14 dead. Past the band a vgeo interior is
+    unsigned (§7.8), so its probes die where a mesh's move out.
+- **The wait keeps its cells' wants.** On Zorah, 826 cells (iGPU) and 888 (4090) waited for ever, every one on a
+  page not resident.
+  - A want lasts the reading it is in: past its 64 fetches a reading, `VGeoResidency.apply` drops what it defers.
+    The camera's cut wants its pages again every frame; the box cut wants only while it cuts.
+  - Now the traverse records what a cell's first stand-in's want is made of, in the cell's header
+    (`VGEO_BRICK_WAIT_OFFSET`): the page, the group, the row the stand-in was found in and that page's own index, the
+    child-table entry, and the error. The distances copy it onto the waiting list whole.
+  - Each frame, the wait wants an absent page again through the provider's slot, while that row still holds that page
+    (`vg_lookup[lookup + source_page] == source`). Once the row holds another page, the cell is queued again instead.
+    The wait writes the frame's feedback ahead of the gather and hands its version on.
+  - A group held back carries no want, as in the cut.
+  - On Zorah no cell is left waiting on an absent page (827 → 0). 7 to 47 wait at rest, every one on a resident page
+    whose group the activation rule holds back. That is the runtime's own gap, which the 4090's camera cut shows
+    too: 1,539 clusters held for good, where S7a saw 118.
+- Tier 2 (`vgeo_brick_wait.spec.js`, over the runtime's tables with a page withheld): a cell waiting on an absent page
+  wants it again each frame, through its source, at its error; one whose source row holds another page is queued
+  again and wants nothing; a held group wants nothing; the cells kept go onto the list whole. The traverse spec holds a
+  clamp's want words to what the residency needs: the source row holds the page named, whose child table names the
+  page withheld at the entry recorded, and the error is above τ. Tier 3: the wait binds the frame's feedback and the
+  want stamps. 17 of 18 mutants were killed. The survivor shortens the distances' copy onto the list, inside a barrier
+  kernel that only the device runs.
+- Open, measured, cause not established: on both GPUs, the lit frame at the manifest camera has dark blotches on a
+  lattice over a column whose bricks are clean.
+
 ### 7.9 Tracing
 
 `brick_clipmap_trace(origin, direction, t_min, t_max)` is a pure chunk over seam readers, so the
@@ -1758,10 +2015,20 @@ Per frame, in this order:
    - At a cascade's outer edge a probe cell projects to `H / (N_p·tan(fov/2))` pixels: 58 px at
      1080p and 60°, 19 px at 120°. A tile size of 8 therefore samples every cell several times a
      frame.
-3. **admit** (thread per wanted cell).
+3. **want hits** (thread per ray of the last frame's updates; S5a, D31 reversed).
+   - A front-face hit that bounces anything wants the cages its pick reads, as a pixel does, since the
+     next bounce reads those probes (§8.7). So a probe a hit needs is admitted where nothing on screen
+     wanted one, and kept while hits read it.
+   - Only a probe a pixel wanted has hits that want: the chain stops after one step, as Enshrouded's
+     world-cache probes do. Unstopped, every surface the windows hold would come to want a probe, the
+     dense lattice D31 turned down.
+   - It reads the last frame's rays before this frame's trace writes over them.
+4. **admit** (thread per wanted cell).
    - An EMPTY entry pops a slot (a failure is counted), writes a NEW state, a record and the
      indirection entry, and appends to the active list.
    - An existing probe refreshes its wanted frame.
+   - Either way the record is marked the screen's when a pixel wanted the point, and the hits'
+     otherwise: what the next frame's hits read to stop the chain.
 
 Consumers weight a NEW probe at zero until its first update.
 
@@ -1820,6 +2087,31 @@ records the frame's lifetime as one graph pass: retire, want, admit's command, a
 - Tier 3, `GPUProbeClipmap.spec.js`: the first frame's fills and the passes' order, sizes and commands;
   the cage windows; the clock; the capacity; growth; destroy.
 
+**As built (S5a, 2026-10-28), the hits' wants**: `probe/shader_probe_clipmap_want_hits.js`, between want
+and admit's command, through the launch the last frame's rays had, `PROBE_DISPATCH_RAYS`.
+- **Want's cages are one chunk**, `probe/chunk_probe_clipmap_want.js`: the pick's cages, the claims and
+  the appends. Want and the hits' wants both call it, so a hit wants what its pick reads.
+- **A wanted list entry's top bit says a pixel wanted the point**, `PROBE_WANTED_SCREEN`. Want runs
+  first, so a point both want is listed once, as the screen's. Admit copies the bit into the record's
+  `screen` word, which sits in the padding the record had: still 64 B.
+- **The row says which rays want**: shade leaves a front-face hit's albedo there and zero in every other
+  ray's, so a ray that takes no bounce wants nothing.
+- **The trace list is cleared after the hits' wants**, which read the last frame's list, origins and
+  rays, told that frame's U and R by the host.
+- Tier 2, `probe_clipmap_lifetime.spec.js`:
+  - a pixel's points are listed as the screen's, and so are their probes;
+  - a front-face hit of a screen probe wants its pick's cage where its ray ends, and admit gives the
+    points NEW probes, the hits';
+  - a probe only hits wanted has hits that want nothing;
+  - misses, unresolved rays, back faces, black hits, and updates past the list's count or bound want
+    nothing;
+  - a point a pixel and a hit both want is listed once, as the screen's;
+  - a probe the screen wanted and then only hits did becomes the hits', and the screen's again; a slot a
+    screen probe gave back is the hits' when a hit's point takes it;
+  - the cage viewed back along the ray, and the next cascade's in the skirt.
+- Tier 3, `GPUProbeClipmap.spec.js`: the pass's place, its command, and the last frame's U and R.
+- Mutants: 24 of 24 killed.
+
 ### 8.4 Relocation and classification
 
 **Relocation**, at the start of every update:
@@ -1992,6 +2284,7 @@ The three irradiance terms of a HIT:
   - Its pick takes the ray's own STBN sample as noise; the probe blend averages it.
   - Where no probe exists, the bounce is **zero**, not the environment. A hit behind the camera in a
     cave must not bring daylight in.
+  - The hit wants its cage (§8.3), so its probes stand there a frame or two later.
   - LPV's 0.97 factor is dropped: albedo below 1 already bounds the series.
 
 **Hits are diffuse only**, as Lumen's surface cache lights diffusely (D7).
@@ -2041,6 +2334,97 @@ through the same command:
   cannot see on the texture build's own encoder; the device check reads the means back against the
   atlas.
 
+**As built (S5a, 2026-10-28)**, E_ind: `probe/shader_probe_clipmap_light.js`, a pass of its own after
+shade, through shade's own launch.
+- **Why its own pass.** Shade binds nine of a stage's ten storage buffers, and the pick takes two more.
+  The light pass binds five.
+- **The albedo.** Shade leaves a front-face hit's diffuse albedo in the ray's `row`, `pack4x8unorm`, and
+  zero in every other ray's. Nothing after shade reads `row`.
+- **The pick** is made at the hit, along its normal, with the view back along the ray.
+  - Its noise is the ray's own jitter, `probe_clipmap_ray_jitter`, extracted from the trace into
+    `chunk_probe_clipmap.js`; the trace aims its ray with it.
+  - It reads last frame's SH, since the projection writes the records later in the frame.
+  - Where nothing is found the bounce is zero, as above.
+- **Tier 2.**
+  - `probe_clipmap_light.spec.js` checks:
+    - a hit takes its albedo by its probes' SH;
+    - misses, unresolved rays, back faces and black hits keep their light, and nothing is found nowhere;
+    - the pick is made at the hit, viewed back along the ray, with the ray's own jitter, across two
+      probes, against the chunks themselves;
+    - the half-float hold;
+    - a fresh jitter each update and round.
+  - Shade's stash is checked in `probe_clipmap_shade.spec.js`.
+  - Mutants: 18 of 18 killed, six by tests added for them.
+- **Measured, the multi-bounce furnace**: a closed room of ρ = 0.5 glowing L_e, no light, the clock held
+  at 1/60 s, 900 frames. On the RTX 4090:
+  - With the rule above, E reaches **0.836 of πL_e/(1 − ρ)** at p50, p01 0.718.
+  - 12% of the front-face hits find no probe. Every one lies on a wall the camera does not see, behind it
+    or beside it, since probes stand only where pixels want them, and the rule makes their bounce zero.
+  - A twin that falls back to the tracing probe's own SH where nothing is found reaches 0.994 (p01
+    0.988), but only because a uniform room makes every probe's irradiance the right one.
+- **Alex, 2026-10-28: the hits want their probes (D31 reversed in part), and nothing stands in.** "If we
+  get no indirect bounce, it is better to lose energy than to invent energy." A hit whose cage has no
+  probe wants it (§8.3), and its bounce is zero until that probe's first update, a frame or two later.
+- **Measured with the hits' wants**, same room and clock:
+  - E reaches **0.994** at p50 (p01 0.988) on the RTX 4090 and on the AMD iGPU, against 0.836 without.
+    No front-face hit finds nothing, against 12%. At ρ = 0.8 it reaches 0.992 after 1,800 frames.
+  - The room holds 418 probes, against 228: the walls the camera does not see.
+- **On Sponza in the sun**, the camera still at 1280×720, the defaults (512 probes a frame), with the
+  hits' wants and without:
+
+  | | nave view | toward a side wall |
+  |---|---|---|
+  | irradiance before AO, mean of the frame, 4090 | 0.108 vs 0.110 | **0.054 vs 0.050** |
+  | the same, iGPU | 0.112 vs 0.110 | **0.055 vs 0.050** |
+  | points wanted a frame | 2,600–3,200 vs 640 | 2,000–2,100 vs 160 |
+  | live probes | 4,600 vs 770 | 3,500 vs 180 |
+  | period T | 6–7 vs 2 frames | 4–5 vs 1 |
+  | the hits' wants pass | 25 µs 4090, 0.44 ms iGPU | 17 µs, 0.42 ms |
+  | trace, iGPU | 6.6 vs 4.9 ms | 7.6 vs 2.2 ms |
+
+  - Toward the wall, where most of the building is off screen, the hits bring 7–9% more light. In the
+    nave view the frame's mean moves less than its own frame-to-frame swing.
+  - **Stability is unchanged** by the longer period: S4g's measure, the change of the diffuse from frame
+    to frame at reprojected points, p50 on the 4090, still 16.3% against 16.3%, orbiting 22.3% against
+    25.1%. A probe the hits keep around the camera is there when the orbit brings its surface on screen.
+  - **The cost is the budget**: with the hits' probes wanted, each frame's updates reach U where the
+    screen alone left them under it, so the trace costs what the ray budget allows (§8.5). On the iGPU
+    that is most of the GI's growth.
+
+**As built (S5b, 2026-10-28)**, E_loc, in the light pass beside E_ind:
+- **The world light clusters take any clipmap's windows.** `graph_build_world_light_clusters` binds a
+  uniform that starts with a `CLIPMAP_LEVEL_ARRAY`, and is told the cascade count and a border of the
+  clipmap's own cells. The irradiance clipmap passes its uniform and its tiles' skirt, as it always had
+  them; the probe clipmap the bricks' levels and no border, so every hit has a cell.
+- **A cell by position**, `chunk_world_light_cluster_lookup_at`: the cell of a cascade holding a world
+  point, the nearest past the cells.
+- **At a front-face hit**: the cell of the hit's brick cascade, at most `IRRADIANCE_CLIPMAP_LIGHT_BUDGET`
+  point lights and as many spots, each the irradiance clipmap's at the footprint of a voxel of that
+  cascade, its cosine at the normal, its map's nearest texel from a voxel off the surface. The light pass
+  binds 8 storage buffers. The renderer hands the GI the frame's shadow map atlas.
+- **Measured on the device**, a closed room of albedo 0.5, nothing glowing, one point light inside: one
+  frame through a twin that adds E_loc alone, every front-face hit facing the light against I·cosθ/d²
+  under the range window.
+  - 0.9958 at p50 on both GPUs, and 1.0039 above p99: the albedo the hits read, 127/255 from the cards
+    and 128/255 from the material mean, against the 0.5 the check assumed. E_loc is exact.
+  - 0.27% of those hits read shadowed, all within a few centimetres of the floor's far corner 7.6 m from
+    the light, at a grazing angle, their points 0.12 m into the slab: acne a voxel's lift does not clear
+    there. None do without the light's shadow.
+- **Its cost**, paired on Sponza (the light pass with E_loc and a twin without it, alternating frames),
+  p50:
+
+  | | 4090 | iGPU |
+  |---|---:|---:|
+  | no local light | 28.7 against 27.6 µs | 1.70 against 1.64 ms |
+  | 8 shadowed point lights along the nave | 34.8 against 27.6 µs | 2.32 against 1.58 ms |
+
+- Tier 2: `probe_clipmap_light.spec.js`, against the light chunks themselves; `world_light_clusters.spec.js`
+  for assign with one light, which the emulator's lane-serial run serves exactly, since lane 0 loads the
+  batch before any lane reads it, and for the lookup.
+- Mutants: 27 of 29 killed. The two left: the cascade bound in assign, which the launch sized by the
+  cascade count makes redundant; the cull box's far corner, which the host spec has no light to cull
+  against, and which the device check shows holding its light.
+
 ### 8.8 Update
 
 **accumulate**: one workgroup per traced probe.
@@ -2117,6 +2501,30 @@ a per-invocation function instead. Each is tier 2 whole, and no thread's loop ru
   texel's solid angle against one integrated from the decode, and the three launches the update's
   command adds.
 
+**Measured (S4g, 2026-10-28): the stores round toward zero, so accumulate rounds them itself.**
+- Both GPUs gave the half toward zero for all 131,072 values tried, on each of three paths:
+  `pack2x16float`, `textureStore` into `rgba16float`, and a render target's write. The stall above is
+  therefore a whole ULP/α, and one-sided: below the target.
+- α follows the frame rate, since the GI's clock is the caller's (`performance.now()` in `Renderer`).
+- On §12's closed room glowing L, after 900 frames to settle, E/πL was:
+
+  | | 60 Hz | 240 Hz |
+  |---|---:|---:|
+  | rounded by the store, toward zero | 0.985 | 0.941 |
+  | rounded to nearest before the store | 0.992 | 0.970 |
+  | rounded stochastically (built) | 0.999 | 0.999 |
+
+  The first row is the 1.5% and 5.9% that ULP/α predicts.
+- **Accumulate now rounds every stored component stochastically onto a half itself**, for radiance and
+  for depth: `shader/chunk/math/chunk_f16_round_stochastic.js`, with noise from `pcg3d(slot, texel,
+  updates)`.
+  - The value it hands the store is a half already, so the device's own rounding never applies.
+  - The blend moves in expectation however small its step.
+  - UE 5.4's TSR stores its history through `QuantizeForFloatRenderTarget` for the same reason.
+- The emulator's `pack2x16float` rounds to nearest even, so tier 2 sees half the devices' stall, and on
+  both sides. `probe_clipmap_accumulate.spec.js` pins convergence from either side at α = 1/64; it was
+  red before the change.
+
 ## 9. Sampling
 
 ### 9.1 The pick: `probe_clipmap_pick(position, normal, view_direction, ξ) -> pick`
@@ -2152,6 +2560,45 @@ Per pixel and cascade the visibility pass makes 8 indirection loads, 8 state wor
 depth taps. Then the pick reads two probes: two SH records and, for specular, two radiance taps. (a)
 read eight 64 B records and resolved eight SH.
 
+**As built (S4f, 2026-10-28)**, `probe/chunk_probe_clipmap_pick.js`:
+- **The cage is want's.** `probe_clipmap_cage` and `probe_clipmap_biased` live in
+  `probe/chunk_probe_clipmap_cage.js`, and want calls them too, so a pixel reads the cage it wanted.
+- **A corner's weight**, `probe_clipmap_corner_weight`:
+  - No slot, or a state that is not ALIVE, weighs 0.
+  - The probe sits at its lattice point plus the relocation offset in its state's second word.
+  - The tap is toward the biased point, at its distance in the cascade's spacings, which is how
+    publish writes depth (§8.8). The wrap back-face term is taken from the point itself.
+- **The weight is LPV's, extracted**: `probe_visibility_weight` and `probe_visibility_chebyshev` in
+  `shader/chunk/light/probe/chunk_probe_visibility_weight.js`. `chunk_lpv_mask_weights_by_visibility`
+  and `chunk_lpv_get_visibility_mask` call it, unchanged.
+- **The pick is Brick4's, extracted**: `pick2_wrs_mat2x4` in
+  `shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js`, which `chunk_brick4_probe_meta_pick2`
+  now calls.
+  - It reads and clears the drawn weights through masks, because indexing the matrix by a value puts
+    it in local memory. That cost 3% of the diffuse on the iGPU: 7.29 → 7.06 ms, A/B in one frame
+    with the order alternating.
+  - Extracting it found a defect in the draw it is built on: `sample_discrete_wrs_mat2x4` and
+    `_vec4` drew NaN after leading zero weights, 0/0 in the first step. It is fixed and pinned in
+    `5a3c8e968`.
+- **Reads** per cascade: 8 indirection loads, 8 state words and 8 depth taps. The pair's two slots
+  are loaded again by index rather than kept, so no array is indexed by a value.
+- **A depth tile's place takes no integer division** since S4g: `index_to_grid2d_reciprocal`, through
+  the reciprocal the sampling uniform carries. RDNA2 emulates integer division. The iGPU's diffuse went
+  from 7.08 to 6.65 ms, paired, with the image the same to the bit on both GPUs.
+- **The clipmap's shape is a uniform**, `PROBE_SAMPLING_STRUCT`: C_p, N_p, n_d, the depth atlas's
+  tiles a row and its texel size. `GPUProbeClipmap.write_sampling_bindings` puts it and the six
+  resources into a reader's bindings.
+- **Tier 2**, `probe_clipmap_pick.spec.js`:
+  - picks as often as the weights, and dead, new and missing corners passed over;
+  - the depth read toward the point, at its direction's own texel, in the cascade's spacings;
+  - a relocated probe weighed from where it moved;
+  - the fallback cascade, the skirt's share, nothing found;
+  - two weighing corners blended in every draw;
+  - the SH mixed by the weights.
+
+  `chunk_probe_visibility_weight.spec.js` and `chunk_pick2_wrs_mat2x4.spec.js` cover the extracted
+  pieces, and LPV's and Brick4's specs pass unchanged.
+
 ### 9.2 Diffuse: `probe_clipmap_sample_irradiance(position, normal, view_direction, ξ) -> E`
 
 - The two picked records' Metro L1 structs are mixed by t, then resolved once with
@@ -2159,6 +2606,12 @@ read eight 64 B records and resolved eight SH.
 - The resolve returns E/π by its convention. The pass multiplies by π, because the resolve pass takes
   irradiance E.
 
+**As built (S4f)**: there is no `probe_clipmap_sample_irradiance`. `probe_clipmap_sample_sh` returns the
+mixed Metro L1 struct and whether anything was found, and the caller resolves at the normal it
+chooses. The deferred pass uses two normals where this section has one n:
+- it picks with the surface's own normal, as want chose its cage;
+- it resolves at the bent normal, as IBL's pass does.
+
 ### 9.3 Specular: `probe_clipmap_sample_radiance(position, normal, view_direction, roughness, ξ) -> L`
 
 The two probes of the same pick are used. Per Brick4's fused pass, the pair's blend is re-weighted for
@@ -2186,6 +2639,34 @@ per probe would be manual strips, with their own skirts and their own downsample
 per storage binding. Two SH bands hold the rough end of the lobe well, and a single tap holds the
 smooth end.
 
+**As built (S6a, S6b, 2026-10-28)**:
+- **The GGX resolve**, `resolve_irradiance_sh_to_specular` in `shader/chunk/spherical_harmonics/l1i/`
+  (S6a). Its spec holds both invariants above. 7 of 7 mutants were killed.
+- **The sample**, `probe_clipmap_sample_radiance` in `probe/chunk_probe_clipmap_sample_radiance.js` (S6b).
+  It returns the radiance and whether anything was found, as the SH sample does.
+  - *The pick* is the diffuse's, `probe_clipmap_pick`.
+  - *The re-weight* takes each picked probe's whole weight again with the lobe in place of the normal,
+    at the visibility it was picked at. That visibility is recomputed, one depth tap toward the biased
+    point. The crush below 0.2 keeps a ratio of the wrap terms alone from standing in for it.
+  - *The parallax* takes the far root of the reflected ray against the sphere, so a point inside the
+    sphere always meets it. Where the ray misses the sphere, the tap is along the lobe itself.
+  - *The radiance tap* reads the radiance atlas through the depth's sampler, bilinear and clamped. Its
+    tiles are placed as the depth's are, and the sampling uniform now carries the radiance atlas's shape
+    as well (`radiance_resolution`, its tiles a row, its texel and the row's reciprocal).
+  - *The blend* is `roughness_to_mip_ratio`, between the renormalised taps and the SH. The SH is mixed
+    by the same shares and resolved for the lobe.
+  - *Reads a picked probe*: its record, its state word, two depth taps (visibility and parallax) and one
+    radiance tap.
+  - *The probes' sampling group* takes the radiance atlas, so every reader binds it in every mode. The
+    GI's placeholders gained a texel of radiance.
+  - *The deferred diffuse pass* listed seven of those declarations by hand. A frame graph pass must declare every
+    input it is given, so it threw under SSR on once the mode had probes. It declares the group whole since the
+    fix that followed S6c1, pinned by its spec running it in a frame graph on the GI's bindings.
+  - *Tier 2*: `probe/probe_clipmap_sample_radiance.spec.js` uses tiles whose interior texels hold their
+    own uv, so a tap shows what it read. It covers the parallax tap at a depth that varies with
+    direction, the GGX-resolved SH at the rough end, the mip ratio's blend between, the re-weighted
+    shares with a relocated probe, and nothing found. 16 of 16 mutants were killed.
+
 ### 9.4 Noise and its resolve
 
 - Image passes take ξ from STBN at (pixel, frame), `chunk_stbn_sample_vec2`, as Brick4 does.
@@ -2203,7 +2684,7 @@ smooth end.
 | `forward_sample_indirect(p, v, n, roughness, &radiance, &irradiance)` | one pick (hash noise); irradiance from §9.2, radiance from §9.3 (environment until S6) |
 | `water_gi_irradiance(p, n)` / `water_gi_specular(p, n, v, roughness)` | §9.2 with v = n, since the irradiance call has no view direction / §9.3 (environment until S6); hash noise |
 | `ssr_sample_radiance(p, n, v, roughness, coord)` | §9.3 with STBN at coord (environment until S6) |
-| `ssr_add_hit_irradiance(&result, confidence, p, hit_vs, hit_n, coord)` | LPV's body with §9.2: albedo·E/π at the hit when confidence > 0.05 |
+| `ssr_add_hit_irradiance(&result, confidence, p, hit_vs, hit_n, coord)` | albedo·E/π at the hit when confidence > 0.05, E the deferred pass's own at the hit's texel (as built; LPV's body with §9.2 measured 41% of the resolve) |
 | `irradiance_clipmap_gi_sample(p) -> array<vec3f,4>` | `probe_clipmap_sample_sh(p)` × `INDIRECT_LIGHT_INTENSITY`: the pick without the back-face term (there is no normal), returned as RGB SH2 |
 
 Each alternative declares `PROBE_CLIPMAP_RESOURCES` with `requireResource`:
@@ -2216,6 +2697,152 @@ Each alternative declares `PROBE_CLIPMAP_RESOURCES` with `requireResource`:
 
 Union bindings were measured free in stage 2 of the switch proposal (p50 1.000).
 
+**As built (S5c, 2026-10-28)**:
+- **The probes are bound in every mode.** A reader binds every mode's resources, and the GI is released
+  out of its mode. So `GPUProbeClipmapGI.write_sampling_bindings` hands out its probes' bindings once it
+  has probes. Before that, or out of the mode, it hands out a clipmap of no cascade: the sampling
+  uniform counts none, so the pick selects no cascade and reads nothing past the levels. These are six
+  objects of a few bytes, made on the first ask and destroyed with the GI. The seven declarations are
+  `PROBE_CLIPMAP_SAMPLING_GROUP`, in `probe/chunk_probe_clipmap_pick.js`; the sampler comes from its
+  declaration's descriptor.
+- **SSR's hit**, `chunk_ssr_add_hit_irradiance_probe_clipmap`: albedo × the deferred pass's indirect
+  diffuse at the hit's texel / π, where the hit's confidence passes 0.05. That output is E with AO in,
+  so a reflection shows the indirect diffuse of the surface it hits, with its AO, its pick and its IBL
+  fallback.
+  - The renderer records the diffuse pass before SSR, which it reads nothing of, and hands it to SSR as
+    `input_indirect_diffuse` under this mode. The resolve's `tIndirectDiffuse` is black for the others.
+  - Tier 2: `chunk_ssr_add_hit_irradiance.spec.js` reads the hit's texel of both inputs, and nothing at
+    confidence 0.05. `SSR.spec.js` binds the diffuse under this mode alone. 7 of 7 mutants were killed.
+- **Why not the pick at the hit** (§9.5's first form, LPV's body; built in `9208dd7cf`, replaced by Alex's
+  call the same day). Measured on Sponza at 1280×720, sun only, SSR on, the probes settled. The arms
+  alternated frame by frame over one set of probes, and each frame's resolve was also drawn by every
+  arm on the same inputs.
+  - 0.81% of the pixels have a confident hit.
+  - The pick's cost is its work at scattered hits, where a wave pays the whole pick for a few lanes. Its
+    code present but never run is about a sixth of it.
+
+  | SSR resolve, p50 | RTX 4090 | AMD iGPU |
+  |---|---:|---:|
+  | no bounce (IBL's variant) | 39.9 µs | 2.06 ms |
+  | the pick's code present, never run | 42.0 µs | 2.19 ms |
+  | the pick at the hit | 54.3 µs | 2.91 ms |
+  | **as built**: the deferred pass's texel, against no bounce in the same run | × 1.019 | × 1.034 (2.03 → 2.10 ms) |
+
+  The SSR trace, which no arm touches, reads 1.00 between arms on both GPUs.
+  - The pick lit 0.64% of the pixels and added 2.4% of the reflections' light.
+  - The texel lights 0.70%: where no probe weighs anything, the diffuse pass's IBL fallback lights the
+    hit too. It adds 1.9% of the reflections' light, with the hit's AO now applied.
+  - Neither darkens a pixel, and both leave the metadata the same to the bit.
+- **Forward**, `rasterize/forward/chunk_forward_sample_indirect_probe_clipmap.js`: one pick by the
+  shading normal and the view, jittered by `jitter_from_vectors(p, n)`. That hash is extracted from
+  Brick4's forward sampling into `shader/chunk/random/`.
+  - E = π × the SH resolved at the normal, or the environment's where nothing is found.
+  - The specular is the environment's until S6.
+  - The AVBOIT draw and MBOIT's resolve add the probe declarations to their group 2, which both stages
+    see, and set those entries to the fragment stage alone. The probes' two storage buffers would
+    otherwise take the vertex stage to 10, the floor.
+- **Water**, `chunk_water_gi_probe_clipmap` in `water/chunk_water_gi.js`: the forward pick with v = n,
+  since the irradiance call has no view, and the environment's specular until S6. The optics'
+  brick4/view group takes the probes, and `water_pipeline` keeps them fragment-only.
+- **Bindings**: the owners write `write_sampling_bindings` into their hand-built bindings. The renderer
+  hands the GI to the transparency orchestrators, and AVBOIT's hands it on to the water's side channel
+  (`avboit_prepare`'s `probes`).
+  - Tier 2 is `chunk_forward_sample_indirect_probe_clipmap.spec.js` and `water/chunk_water_gi.spec.js`
+    against the pick and the environment map, the fragment-only test in
+    `indirect_lighting_consumers.spec.js`, and the AVBOIT orchestrator's water optics in every mode.
+  - 18 of 19 mutants were killed. MBOIT's resolve without the probes survives because no spec draws
+    MBOIT; the device check below draws it.
+- **Measured** on Sponza at 1280×720, sun only, with five half-transparent boxes down the nave. Each
+  pass alternated frame by frame with IBL's variant over one set of probes.
+
+  | p50, IBL → the probes | RTX 4090 | AMD iGPU |
+  |---|---:|---:|
+  | AVBOIT draw | 13.3 → 28.7 µs | 132 → 312 µs |
+  | MBOIT's resolve | 11.3 → 26.6 µs | 129 → 317 µs |
+
+  - Per transparent fragment, that is about what the deferred pick costs a pixel.
+  - Averaged over 24 frames, 2.8% of the pixels, the boxes, move by 14 of 255 between the arms. The noise
+    floor, an arm against itself, is 0.1–0.25%. The boxes are lit brighter by the probes than by the
+    sky (luma 97 against 88), the same on both GPUs and in both techniques.
+  - The water optics compile under every mode on both GPUs.
+- **The irradiance clipmap**, `chunk_irradiance_clipmap_gi_sample_probe_clipmap`: the pick at the voxel,
+  with no normal and no view, jittered by `jitter_from_vectors(p, 0)` and the view's frame. Where nothing
+  is found, the environment SH.
+  - The probes' Metro L1 is handed over as the radiance SH2 that `volumetrics_irradiance_sh_add_radiance`
+    turns back into it: [DC, y, z, x] = [YCoCg→RGB(2π·(Y.w, 0.28209·CoCg)), 2π·Y.y, 2π·Y.z, 2π·Y.x], the
+    band-1 terms grey.
+  - The build binds the probes as a group of its own, which brings it to 9 of the floor's 10 storage
+    buffers, and binds the view.
+  - The cascades are a cache, so a voxel's pick holds until its cascade is rebuilt: cascade 0 and the
+    ruler's each frame, the others as their windows move.
+  - Tier 2: `chunk_irradiance_clipmap_gi_sample.spec.js` accumulates the handed-over SH2 as the build
+    does and gets the pick back, with the frame's noise and the environment where nothing is found.
+    `graph_build_froxel_gi.spec.js` finds the GI's probes and the view bound to the build. 11 of 11
+    mutants were killed.
+  - **Measured** on Sponza at 1280×720, sun only. A sink kept the volume, which only lit particles read.
+    The build's p50 went from 7.2 to 15.4 µs on the 4090 and from 127 to 430 µs on the iGPU, for two
+    cascades of 34³ voxels a frame.
+  - The volume's band 0 moves by 0.0016 between the arms, 6× the probe arm's own change from one run to
+    the next (0.00026). The IBL arm is steady to the bit. The sun is most of the volume here, so its mean
+    moves by 0.5%.
+
+**As built (S6c2, 2026-10-28)**: SSR's fallback, `chunk_ssr_sample_radiance_probe_clipmap`, is §9.3 at the pixel:
+the probes' specular picked by its normal and view, with STBN at the pixel and the resolve's frame index, as
+Brick4's is. Where no probe weighs anything, it is the environment's.
+- The resolve binds the probes' sampling group again, through SSR's `probes`, in every mode.
+- The radiance chunk now declares what it reads itself. `switched_shaders_declare_bindings.spec.js` audits it
+  since SSR's resolve links it.
+- Tier 2: `chunk_ssr_sample_radiance.spec.js` runs the fallback against `probe_clipmap_sample_radiance` with the
+  STBN texel at the pixel and frame, and against the environment where nothing is found. `SSR.spec.js` binds the
+  probes in every mode; `indirect_lighting_consumers.spec.js` finds the probes' specular in this mode's variant
+  alone. 7 of 7 mutants were killed.
+- **Measured** on Sponza at 1280×720, sun only, SSR on, the probes settled. One of three arms a frame, in turn,
+  over one set of probes; 131 frames an arm, p50:
+
+  | arm | deferred pass | SSR resolve | together, RTX 4090 | together, AMD iGPU |
+  |---|---|---|---:|---:|
+  | **as built**: the fallback picks again | 87 µs / 6.64 ms | 140 µs / 10.39 ms | 227 µs | 17.03 ms |
+  | S5c: IBL's fallback | 87 µs / 6.64 ms | 61 µs / 2.09 ms | 148 µs | 8.74 ms |
+  | the deferred pass's one pick writes the specular too, and the fallback reads its texel | 114 µs / 9.02 ms | 61 µs / 1.93 ms | 175 µs | 10.95 ms |
+
+  - The SSR trace, which no arm touches, reads 0.98–1.01 between arms.
+  - The fallback runs at every foreground pixel, so its pick is the whole pick again: 4.96× the resolve on the
+    iGPU. The texel arm's light is the as-built arm's in the mean; 1% of the pixels differ, by the pick's noise.
+  - The probes' fallback lifts the reflections' mean luma 28× over the harness's dim sky. No pixel goes darker.
+- **Alex kept the pick** (2026-10-28), as this section designs it, with these measurements before him.
+
+**As built (S6d, 2026-10-28)**: the forward passes' and the water's specular from the probes, §9.3.
+- **Forward**, `chunk_forward_sample_indirect_probe_clipmap`: one pick for both lobes, as the fused deferred pass
+  takes it (S6c1). The irradiance is the pick's SH resolved at the normal, as before. The specular is
+  `probe_clipmap_radiance_of` the same pick, at the fragment's roughness. Where no probe weighs anything, both are
+  the environment's.
+- **Water**, `water_gi_specular`: `probe_clipmap_sample_radiance` by the surface's normal and view, its noise the
+  irradiance's hash, or the environment's where nothing is found. The optics ask for the irradiance at other points
+  and by other normals (the in-scatter's column, a receiver's downwelling light), so each call picks for itself.
+- **Bindings** are unchanged. Each of the three passes has declared the probes' group whole since S6b, the radiance
+  atlas with it, fragment-only.
+- **Tier 2**: `chunk_forward_sample_indirect_probe_clipmap.spec.js` and `water/chunk_water_gi.spec.js` give each
+  probe a colour of its own over its radiance tile. They check the specular against `probe_clipmap_sample_radiance`
+  with the call's own noise, view and roughness, and against the environment where nothing is found.
+  `indirect_lighting_consumers.spec.js` finds the probes' radiance in this mode's forward and water variants alone.
+  16 of 16 mutants were killed.
+- **Measured** on Sponza at 1280×720, sun only, with S5c's five half-transparent boxes down the nave and S5c's
+  harness. Each pass alternated frame by frame with IBL's variant over one set of probes. IBL's arm reads within
+  1 µs between S5c's run and this one.
+
+  | p50, IBL → the probes | S5c: the irradiance | S6d: both lobes |
+  |---|---:|---:|
+  | AVBOIT draw, RTX 4090 | 13.3 → 28.7 µs | 12.3 → 31.7 µs |
+  | MBOIT's resolve, RTX 4090 | 11.3 → 26.6 µs | 11.3 → 30.7 µs |
+  | AVBOIT draw, AMD iGPU | 132 → 312 µs | 131 → 379 µs |
+  | MBOIT's resolve, AMD iGPU | 129 → 317 µs | 130 → 383 µs |
+
+  - The specular adds 26–27% (4090) and 35–38% (iGPU) to what the probes' light costs each pass over IBL's.
+  - Averaged over 24 frames, 3.6–3.8% of the pixels move by more than 4 of 255 between the arms, against 2.8–3.0% in
+    S5c: the boxes' reflections now take the probes' light too. An arm against itself moves 0.2–0.7% of them
+    (S5c 0.1–0.25%), since the specular carries the pick's noise; TAA is off in this harness.
+  - The water optics compile under every mode on both GPUs.
+
 ### 9.6 Deferred
 
 A new case in `#graph_indirect_lighting`, shaped like Brick4's:
@@ -2227,6 +2854,72 @@ A new case in `#graph_indirect_lighting`, shaped like Brick4's:
 
 Until S6, specular is `shader_specular_IBL`, as LPV mode does today.
 
+**As built (S4f, 2026-10-28)**: `probe/shader_probe_clipmap_diffuse.js` serves SSR on and off alike.
+The fused `shader_probe_clipmap_indirect_lighting` waits for S6, since until then there is no probe
+specular to fuse with.
+- `Renderer` swaps the pass in for `shader_diffuse_IBL` once `GPUProbeClipmapGI.has_probes`, that
+  is, once the mode has run a frame.
+- A pixel with no probe found takes `get_ibl_irradiance(bent normal)` inside the pass.
+- AO multiplies the result, as in the IBL pass.
+- **Tier 2**: `shader_probe_clipmap_diffuse.spec.js` runs the pass whole on the emulator:
+  - π × the SH resolved at the bent normal × occlusion;
+  - IBL's output where nothing is found;
+  - the pick by the surface normal and the view, against `probe_clipmap_sample_sh` itself.
+- **Mutants**: 32 of 32 killed (the pick 16, the visibility weight 3, the pick of two 2, the cage 1,
+  the host's uniform 2, the pass 8). Four were killed by tests added for them:
+  - a relocated probe weighed from where it moved;
+  - the pair's second slot and the blend's direction, both by two corners blended in every draw;
+  - the depth read at its direction's own texel.
+- **Measured** on Sponza at 1280×720, a still camera, the caches baked. The frame's mean luma goes
+  from 2.6 under IBL to 66 under the probes (8-bit), the same on both GPUs.
+
+  | p50 | AMD iGPU | RTX 4090 |
+  |---|---:|---:|
+  | the diffuse | 7.06 ms | 58 µs |
+
+  The iGPU's time, split by twins drawn in the same frame:
+
+  | part | iGPU |
+  |---|---:|
+  | depth taps and Chebyshev | 2.37 ms |
+  | the draw of two | 1.30 ms |
+  | SH reads and the resolve | 0.18 ms |
+  | the skirt | 0.04 ms |
+  | the pass without a pick | 0.42 ms |
+  | the rest of the corner weights: indirection loads, state words, the trilinear and back-face terms | ~3.0 ms |
+
+**As built (S6c1, 2026-10-28)**: `probe/shader_probe_clipmap_indirect_lighting.js`, the fused pass, with SSR off.
+- `Renderer` draws it in place of the diffuse, specular and resolve passes once `has_probes`, as Brick4's fused
+  pass replaces its three. With SSR on, the diffuse pass and SSR stay.
+- **One pick a pixel**, by its own normal and the view, with the frame's STBN, for both lobes.
+  `probe_clipmap_sh_of(pick)` and `probe_clipmap_radiance_of(pick, …)` take a pick already made;
+  `probe_clipmap_sample_sh` and `probe_clipmap_sample_radiance` make one and call them.
+- **The diffuse** is the diffuse pass's: the pick's SH resolved at the bent normal, times π, times AO. Its
+  shares are not re-weighted for the bent normal, as Brick4's are. The diffuse pass takes them as picked (S4f),
+  so the fused pass lights the diffuse as SSR on does.
+- **The specular** is `probe_clipmap_radiance_of` at the surface's roughness, as the IBL pass samples its own.
+- A pixel no probe weighs anything for takes the environment's pair, as the IBL passes give it. The pair is
+  resolved as `shader_resolve_indirect_lighting` resolves it and added to the scene's colour.
+- **Tier 2**: `shader_probe_clipmap_indirect_lighting.spec.js` runs the pass on the emulator against the
+  diffuse pass, `probe_clipmap_sample_radiance` and the resolve pass on the same pixel. Where nothing is found,
+  it runs against the IBL pair. The pixel's bent normal is placed so that its visibility cone ends across the
+  specular lobe, and the specular occlusion shows. 14 of 14 mutants were killed.
+- **Measured** on Sponza at 1280×720, sun only, SSR off, the probes settled. The fused pass's node drew one of
+  three arms a frame, in turn, over one set of probes. 138 frames an arm; p50 of the indirect light's passes:
+
+  | arm | RTX 4090 | AMD iGPU |
+  |---|---:|---:|
+  | **as built**: the fused pass | 265 µs | 9.66 ms |
+  | before: the probes' diffuse, IBL's specular, the resolve | 270 µs (208 + 31 + 33) | 8.17 ms (6.65 + 0.62 + 0.91) |
+  | the same light unfused: the probes' diffuse, a pass of their specular, the resolve | 480 µs (208 + 237 + 36) | 16.18 ms (6.65 + 8.62 + 0.92) |
+
+  - The probe trace, which no arm touches, reads 0.97–1.00 between arms.
+  - One pick for both lobes costs 0.55× (4090) and 0.60× (iGPU) of the two picks unfused. Against the passes it
+    replaces, the probes' specular costs nothing measurable on the 4090 and 1.5 ms on the iGPU.
+  - The fused pass's light matches the unfused passes' to 0.6% of a pixel's luma, their f16 intermediates. The
+    probes' specular lifts the indirect light's mean luma 36% over the sky's, which is dim in this harness. Both
+    GPUs agree.
+
 ### 9.7 Every file the change touches
 
 The new mode value:
@@ -2430,6 +3123,138 @@ specs. A real compile on a device catches what the validator misses.
   allocation failures, period T.
 - **The storage-write rounding question of §8.8.**
 
+**As built, S4's done-when (S4g, 2026-10-28)**: one bounce, on both GPUs. The harness is the session's
+scratchpad `device/s4g.js`.
+- **How the runs were held.** The GI's clock is the caller's `performance.now()`, so α followed each run's
+  frame pacing, and a furnace read differently from run to run. Every run below holds the GI's clock at
+  1/60 s a frame by wrapping `GPUProbeClipmapGI.graph_update`. The furnaces then let it settle 900
+  frames, 30 τ.
+- **White furnace, one bounce.**
+  - *A closed room* of 8 × 4 × 8 m, every face glowing L, no light. Before AO, E/πL is 0.9991 at p50 and
+    0.994 at p01, on both GPUs and at 60 or 240 Hz. Every ray hits, every texel holds L, and the
+    records' E/π is 0.4998 against 0.5. The 1.5% and 5.9% short before were the store's rounding (§8.8).
+  - GTAO's occlusion multiplies the probes' diffuse, as it does IBL's. The room's corners then read p10
+    0.886 and p01 0.557: the probes see those walls glowing, and AO calls them dark. A furnace therefore
+    reads E before AO.
+  - *An open sky* of radiance L over a dark floor of 200 m, no light. L1 holds a lit hemisphere's
+    irradiance exactly at its pole, so πL is the floor's exact answer. E/πL is 0.997 on the iGPU and
+    0.980 on the RTX 4090. **Open, not root-caused**: the shortfall is in the 4090's probes, not the
+    resolve, since the surface normal gives 0.983 against the bent normal's 0.981.
+    - Texel by texel, every probe holds L from 10° above the horizon up on both GPUs. At 2–10° the
+      4090's texels hold 0.98 and 0.96 of L, against the iGPU's 0.996 and 0.993, on rays that resolve
+      alike.
+    - **D4's reversal condition is met here.** 64 steps leave 63% of the rays within 2° above the
+      horizon unresolved, 41% at 2–5°, 28% at 5–10° and 10% at 10–20°. Over Sponza it is 0.24–0.34% of
+      all rays.
+- **Stability**, on Sponza with the sun: each pixel against the same surface point a frame before,
+  reprojected through the previous frame's view-projection. The two GPUs agree to the per-mille.
+  - Raw, the indirect diffuse before TAA:
+
+    | p50 | still | orbit | dolly |
+    |---|---:|---:|---:|
+    | the eight corners blended (a twin) | 5.0% | 10.1% | 9.2% |
+    | the pick of two (shipped) | 16.9% | 26.4% | 17.6% |
+    | pixels matched | 99.6% | 95.8% | 98.3% |
+
+  - With TAA, the final image:
+    - Still: the pick 0.95% against the eight's 0.65%.
+    - Orbiting, the medians are alike, 14.3% against 13.1%, which is texture detail resampled.
+      **The tails are not: p90 50% against 21%, mean 22.9% against 13.5%.** TAA does not resolve the
+      pick's noise under motion in a tenth of the frames, which §9.4 expected it to.
+  - The eight corners' cost, paired in one frame with the order alternating: iGPU 5.93 ms against the
+    pick's 6.64 ms, **0.72 ms less**; RTX 4090 65.5 µs against 58.4 µs.
+  - **Alex kept the pick of two** for the diffuse (2026-10-28), with these measurements before him.
+- **Counters**, on Sponza:
+  - live probes: 769 still, 1,341 orbiting; dead: 13 and 54;
+  - the period 2, and nothing starved;
+  - rays: 3–5% miss, 0.24–0.34% unresolved, 2% back faces;
+  - all 103 geometries' fields coarsened; the bake starved 16 frames and skipped 90.
+- **Timings**, Sponza at 1280 × 720, p50:
+
+  | | AMD iGPU (orbit) | RTX 4090 (still) |
+  |---|---:|---:|
+  | want | 116 µs | 7 µs |
+  | relocate | 20 µs | 25 µs |
+  | trace, with the sun's shadow | 5.16 ms | 310 µs |
+  | shade | 1.04 ms | 26 µs |
+  | accumulate, the projection's rows and probes, publish | 0.75 ms | 33 µs |
+  | the diffuse | 6.65 ms (7.06 before S4g's tile address) | 58 µs |
+  | the rest, each | under 8 µs | under 8 µs |
+
+**As built, S5's done-when (S5d, 2026-10-28)**. The harness is the session's scratchpad `device/s5d2.js`.
+- **The multi-bounce furnace** reads 0.994 once a hit wants its probes (S5a, §8.7).
+- **Cornell box against the path tracer.**
+  - *The scene*: a box 4 m inside, open toward the camera, under a black sky, lit by a point light 0.4 m
+    below the ceiling. The walls have the classic reflectances (white 0.73, red (0.63, 0.065, 0.05),
+    green (0.14, 0.45, 0.091)), with a short and a tall white box inside.
+  - *The images*: 480×360, tone mapping NONE at a fixed exposure, the sRGB transfer undone on the CPU.
+    Each image's mean is taken per surface, the surface found by casting each pixel's ray on the CPU.
+    The probes' image is the mean of 64 frames after 900 frames of settling.
+  - *The reference is the accumulating path tracer through twins of its shader.* The engine's tracer
+    stops at three bounces (`BOUNCE_LIMIT = 3u`). In this box that leaves its total at 84–94% of the
+    converged one, and its indirect at 72–77%. So the reference traces 24 bounces at 512 samples a
+    pixel, and a twin at one bounce gives the tracer's own direct light.
+
+  | surface | total, probes / traced | indirect, probes / traced | direct, raster / traced |
+  |---|---:|---:|---:|
+  | floor | 0.88 | 0.89 | 0.88 |
+  | ceiling | 0.90 | 0.94 | 0.89 |
+  | back | 1.03 | 1.07 | 0.98 |
+  | red wall | 1.03 | 1.15 (r 1.41, g 0.78, b 0.73) | 0.87 |
+  | green wall | 0.99 | 1.04 (r 0.82, g 1.09, b 0.76) | 0.92 |
+  | the boxes | 1.14 | 1.55 | 0.64 |
+
+  The iGPU's probe image agrees with the 4090's within 0.5% on every surface.
+  - **The direct light differs before the GI does.** The rasterizer's point light is 2–13% under the
+    tracer's on the walls and 36% under on the boxes. That is the direct path's, not the probes'; it was
+    measured here and not looked into.
+  - **The indirect alone**, each image less its own direct, is within −11% to +7% on the floor, ceiling,
+    back and green wall, +15% on the red wall, and +55% on the boxes.
+  - **The colour bleed is too saturated** on the coloured walls: the red wall's indirect is redder than
+    traced, the green wall's greener. The probes keep chroma in the constant band alone (Metro L1), so a
+    probe beside a coloured wall lends its colour to every direction.
+  - **None of these gaps is a follow-up** (Alex, 2026-10-28). The tracer at three bounces is the engine's
+    reference, and a probe GI cannot match a path tracer: angular resolution, depth bias and the probes'
+    sampling offsets bound it. S5's done-when is the comparison, not parity with it.
+- **Timings**, the probe clipmap's passes summed at their p50, Cornell at 480×360: **0.22 ms** on the 4090
+  and **5.6 ms** on the iGPU. The iGPU's trace is 2.8 ms of it, the light 0.62 ms, the diffuse 0.80 ms,
+  shade 0.34 ms and the hit wants 0.32 ms.
+
+**As built, S6's done-when (S6e, 2026-10-28)**. The harness is the session's scratchpad `device/s6e.js`.
+- **The room** is S4g's, 8 × 4 × 8 m inside six slabs, with no light under a black sky. SSR is off, so the fused
+  pass draws, and the probes settle for 900 frames. Captures drawn beside the fused pass, on its bindings, write
+  the probes' specular at each pixel as the pass reads it: `probe_clipmap_sample_radiance` with the pixel's STBN
+  noise. A twin of the sample without the parallax, which taps along the lobe, is drawn beside it every frame.
+- **Reflections in a closed room, as a furnace.** Every face glows L with albedo 0, so every probe texel holds L.
+  The specular over L at roughness 0.05, 0.3, 0.6 and 1 is 0.9995 at p50 and at least 0.996 at p01, on both GPUs,
+  with the parallax and without.
+- **The parallax A/B.** The walls and the ceiling each glow a colour of their own with albedo 0; the floor is black
+  metal at roughness 0.05. Each floor pixel's specular, averaged over one cycle of the STBN (64 frames), is held
+  against the exact mirror: the face the pixel's mirror ray meets, cast on the CPU.
+  - *Right face* is the share of floor pixels whose nearest face colour is that face's.
+  - *The error* is |L − L_face|₁ / |L_face|₁.
+  - The table gives the range over two runs on each GPU; the two GPUs agree within half a percent.
+
+  | the mirror ray's face is | with the parallax (as built) | without |
+  |---|---:|---:|
+  | under 2 m away (17% of the floor) | 87.5–87.8% right, error 0.200–0.202 | 97.0%, 0.105–0.107 |
+  | 2–4 m away (32%) | 97.2–97.3%, 0.146–0.148 | 95.5–95.9%, 0.141–0.144 |
+  | 4–8 m away (51%) | 87.8–88.4%, 0.255–0.258 | 79.6–79.9%, 0.245–0.246 |
+  | the whole floor | 90.7–91.0%; error p50 0.159–0.162, p90 0.384–0.390 | 87.6–87.9%; 0.140–0.143, 0.384–0.388 |
+
+  - The parallax puts more of the reflections from 2 m out on their face, and fewer of those under 2 m. The
+    ceiling, 4 m and more above the floor, is the one face it does worse on as a whole: 85.7–87.0% right against
+    100%.
+  - *Two other forms were measured and not taken.*
+    - Leaving the parallax out where the depth reads its √3 limit gives 86.1–86.4% right and a p90 error of
+      0.44–0.45. Each probe decides alone, so a picked pair can tap along two inconsistent directions.
+    - Meeting the sphere where the ray enters, for a point outside it, is the same from 2 m out and worse under
+      it: 85.3% right, error 0.222.
+  - The parallax costs the capture 133 against 126–128 µs on the 4090 and 4.86 against 4.59 ms on the iGPU, at
+    960 × 540 with every pixel the room's.
+- **The parallax stays as built.** It places more of the floor's reflections, and the far ones most; the near ones
+  it misplaces about four times as often as a flat tap does.
+
 ## 13. Stages
 
 Each stage lands suite-green and is measured before the next.
@@ -2555,6 +3380,10 @@ Each says what would reverse it.
   - The cost of sparse: no probes where nothing visible needs them, so off-screen bounces see only the
     probes that exist.
   - *Reverse:* if the off-screen bounce measures short, Enshrouded's world-cache probes (§17).
+  - **Reversed in part at S5a (Alex, 2026-10-28)**: the multi-bounce furnace measured the off-screen
+    bounce short (§8.7), so hits want the probes they read as well, one step from the screen, as the one
+    probe kind (§8.3). "If we get no indirect bounce, it is better to lose energy than to invent energy":
+    where no probe has data yet the bounce stays zero, and no other probe stands in.
 - **D32. The mover pass moves from VSM to scene level, with a skinned bit** (Alex, as recommended).
   - The kernels and the list stay the same. The scene context owns them and produces the list once a
     frame for any reader.
@@ -2621,7 +3450,6 @@ Each item is added only if a measurement asks for it, or, where marked, when Ale
   emissive. The measured fix is the BRDF's hemispherical albedo captured in place of the diffuse
   one.
 - **Caches persisted across sessions**, an offline bake format.
-- World-cache probes at ray hits (Enshrouded's second kind), if the off-screen bounce measures short.
 - Importance-sampled ray directions, if noise at the defaults measures visible.
 - Ray and history reprojection between probes, if long-range propagation into enclosed spaces
   measures short.