@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -22,7 +22,8 @@ Alex reviewed revision (a). Items 1–8 are his; item 9 follows from them.
    performance (§6.1).
 4. **Brick providers.** A pass that writes requested bricks plugs in; outputs merge per brick, so the
    representation stays sparse and only bricks that scroll in or change are written. Virtual geometry
-   is served by one (§7.6, §7.8).
+   has caches of its own, baked from a proxy cut from each geometry and composed as a mesh's are (§7.8,
+   S8).
 5. **Skinned meshes** use their unskinned representation, with hooks for a dense animated patch later
    (§6.3, §7.7, §17).
 6. **Pixels pick 2 of the 8 cage probes** by Brick4's weighted reservoir sampling, after a
@@ -79,8 +80,9 @@ What was asked for:
 3. **The probe clipmap is what shading samples (§8)**, as in (a).
    - A sparse cache, wanted from the depth buffer. Octahedral radiance `rgba16float`, depth moments
      `rg16float`, SH2 in the engine's YCoCg L1 (`METRO_L1_IRRADIANCE_STRUCT`).
-   - A fixed ray budget. Hits are lit by emissive, the sun through an SDF soft shadow, local lights and
-     last frame's probes. Their diffuse albedo and emissive come from the cards.
+   - A fixed ray budget. Hits are lit by emissive, the sun and one picked local light through shadow
+     rays traced in the bricks, and last frame's probes. Their diffuse albedo and emissive come from the
+     cards.
 4. **Pixels pick two probes (§9).**
    - A visibility-only pass weighs the eight cage probes: trilinear × wrap back face × Chebyshev ×
      crush.
@@ -281,8 +283,11 @@ clipmap toolkit (§16).
   - it interpolates uv, vertex colour, normal and tangent from a triangle and barycentrics;
   - it samples the material: albedo × colour factor × vertex colour, ORM, emissive × factor, opacity.
 - It reads `GPUResidentMaterialContext` (on `GraphicsContext`): the material table
-  (`INDIRECT_MATERIAL_STRUCT`) and a 2-D array of 64² texture slots, one level each, sampled by
-  `indirect_sample_texture` with each sampler's wrap mode and a stochastic bilinear tap.
+  (`INDIRECT_MATERIAL_STRUCT`) and a 2-D array of 64² texture slots, each with its mip chain down to
+  one texel since 2026-10-30, sampled by `indirect_sample_texture` at an explicit level with each
+  sampler's wrap mode: one stochastic tap of the trilinear filter by default, which at level 0 is the
+  stochastic bilinear tap it always was, or the filter itself where the shader's
+  `INDIRECT_TEXTURE_FILTER` is `Exact`.
 - Its taps and dither draw on the path tracer's random state. Alpha is stochastic: a hit is opaque
   with probability equal to its opacity (`chunk_ray_shaded_query_occluded`, through
   `sample_material_alpha`).
@@ -296,7 +301,7 @@ clipmap toolkit (§16).
 
 **What rays could not see.** vgeo rows are in the TLAS with an empty BLAS, and DynamicMesh has no row.
 Under (b):
-- virtual geometry is written by its provider (§7.8);
+- virtual geometry is baked from a proxy cut from it, and composed as a mesh (§7.8, S8);
 - DynamicMesh stays out by construction: it changes every frame, and a cache of it would be a cache of
   nothing (§17).
 
@@ -420,11 +425,11 @@ the SDF [49:08].
 | octahedral radiance + border; distance with mean/mean² | same, `rgba16float` and `rg16float` with the engine's skirt chunks (§8.2) | hardware bilinear for every consumer tap |
 | irradiance as octahedral 12² (frustum) or SH (world cache) | SH2 YCoCg L1 for every probe | the request; 32 B a probe |
 | fixed ray budget; per-probe requests scaled to it | budget in rays a frame; period follows the live count (§8.5) | same intent, deterministic schedule |
-| importance-sampled directions + every-5th-frame uniform | one jittered ray per texel (stratified), always | no starvation, no second schedule; revisit only on a measured noise problem (§17) |
-| 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 |
+| importance-sampled directions + every-5th-frame uniform | the same: every 5th update uniform, the rest a CDF walk over the probe's history from a rotating corner, each texel held under 64 rays (§8.6, as built 2026-10-29) | Alex found the noise of one jittered ray a texel visible (D11) |
+| moving-average estimator, 5 u32 per texel | the same estimator, its short mean over a response time in seconds; 6 words a texel with the atlas's (§8.8) | built 2026-10-29, once Alex judged the noise visible (D11); the knob stays physical |
 | 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 |
@@ -692,7 +697,7 @@ Embark Studios' research renderer.
 | Mesh SDF | sparse bricks in size classes, with levels | `GPUGeometrySDFManager`'s dense tiles | the review; memory follows the surface |
 | Material | cards holding diffuse albedo and emissive captured per (geometry, material), recaptured when the material's version moves | the voxel lattice, (a); cards holding uvs with the material evaluated live | the review: no material work at a hit (§15) |
 | Probe residency | sparse cache from the screen | dense lattice | 10× less memory and work at the same lattice (§11) |
-| Rays | one jittered ray per texel | importance sampling | no starvation, no extra schedule, no CDF |
+| Rays | Enshrouded's: guided by the probe's radiance, every 5th update uniform (§8.6) | one jittered ray per texel, (b) as first built | its noise measured visible (D11) |
 | Temporal | exponential over a response time | moving-average estimator | one history, 8 B a texel |
 | Pixel sampling | 2 of 8 by WRS | all eight, (a); 1 of 8 + reservoirs + denoise (Enshrouded) | the review; two probe reads, no denoiser |
 | Specular | radiance tap ⊕ GGX-convolved SH2 | prefiltered levels | the review; LPV's blend |
@@ -795,10 +800,10 @@ Verdicts:
 | Pick 2 of 8 | `sample_discrete_wrs_mat2x4`; the selection inside `brick4_probe_meta_pick2` | **REUSE**; **EXTRACT** `pick2_wrs_mat2x4`, Brick4 keeps its address mapping |
 | Noise | `chunk_stbn_sample_vec2`; `jitter_from_vectors` (private to Brick4's forward chunk) | **REUSE**; **EXTRACT** the hash |
 | Directional lights | `directional_lights_iteration_mask`, the light database records | **REUSE** |
-| Local lights at a world point | `world_light_cluster_metadata_by_texel`, `irradiance_clipmap_get_point_light_info_by_index` / `_spot_…`, `volumetrics_point_light_shadow` / `_spot_…` | **GENERALISE** the cluster keying from `IRRADIANCE_CLIPMAP_STRUCT` to a `CLIPMAP_LEVEL_ARRAY`; the light and shadow chunks **REUSE** |
+| Local lights at a world point | `world_light_cluster_metadata_by_texel`, `irradiance_clipmap_get_point_light_info_by_index` / `_spot_…` | **GENERALISE** the cluster keying from `IRRADIANCE_CLIPMAP_STRUCT` to a `CLIPMAP_LEVEL_ARRAY`; the light chunks **REUSE**. Their shadows were `volumetrics_{point,spot}_light_shadow` until 2026-10-30, and are shadow rays in the bricks since (§8.7) |
 | Sky for misses; final fallback | `sample_environment_color`, `get_ibl_irradiance` | **REUSE** |
 | Specular split at a pixel | `compute_indirect_specular`, `tSplitSum`, inside the deferred resolve | **REUSE** |
-| SDF soft-shadow penumbra | inside `shader_scene_sdf_soft_shadows` | **EXTRACT** the estimator as a pure chunk; the dense-volume shader keeps calling it. Not done (S3e): its classic estimate cannot meet §12's oracle, and the brick clipmap's is Quílez's two-sided one (§7.9) |
+| SDF soft-shadow penumbra | inside `shader_scene_sdf_soft_shadows` | **EXTRACT** the estimator as a pure chunk; the dense-volume shader keeps calling it. Not done (S3e): its classic estimate cannot meet §12's oracle, and the brick clipmap's was Quílez's two-sided one (§7.9), itself replaced by shadow rays on 2026-10-30 (§8.7) |
 | Appends | `chunk_collection_u32_append` | **REUSE** |
 | Parallax toward a probe's hit | LPV's iterative correction in `lpv_sample_light` | **GENERALISE** to take a depth-moment reader (§9.3) |
 
@@ -843,7 +848,7 @@ brick:   scroll ─► movers ─► take ─► clear ─► providers (mesh, v
                                                    │ brick map, SDF atlas, object cells, occupancy
 probe:   retire ─► want (depth) ─► admit ─► schedule ─┐
                                                       ▼
-         trace (+ sun soft shadow) ─► shade ─► accumulate ─► publish
+         trace (+ sun shadow rays) ─► shade ─► light (+ local shadow ray) ─► accumulate ─► publish
          (rays = trace list × rays_per_probe ≤ ray_budget)
                                                    │ indirection, states, records (SH2),
                                                    │ radiance + depth atlases
@@ -877,8 +882,8 @@ How the bit travels:
 - A row outside the SDF world is drawn by the camera and invisible to every GI ray. It occludes
   nothing, emits nothing into GI and bounces nothing. That is the point of the bit: performance.
 
-**A geometry is cached** when at least one row in the SDF world draws it and it is not virtual.
-- Virtual geometry has its own provider (§7.8).
+**A geometry is cached** when at least one row in the SDF world draws it.
+- A virtual geometry's cache is baked from a proxy cut from it, and adopted into it (§7.8, S8).
 - DynamicMesh has no row, so it is absent by construction.
 
 **What is cached, and keyed by what**:
@@ -1129,11 +1134,38 @@ the row's pair.
      is empty.
 3. At the opaque hit, `sample_material_data` runs with the material's resident row and an identity
    instance transform (the card is in local space).
-   - Its random state is seeded from (pair, texel), which fixes its stochastic bilinear tap and its
-     dither.
+   - Since 2026-10-30 both reads take the material's textures at the texel's footprint, trilinearly
+     (`mesh_card_texture_level`; the capture is `INDIRECT_TEXTURE_FILTER` `Exact`): the card's texel
+     steps carried along δ onto the triangle and through its uv per position, the level
+     log2(texels × 64), the last level for a triangle edge-on.
+   - Its random state is seeded from (pair, texel), which fixes its alpha draws and its dither.
    - A recapture of an unchanged material therefore writes the same bytes.
 4. The texel stores √(albedo × (1 − metalness)), depth, and emissive / s_e.
 
+**Capture by raster** (`MeshCardCaptureMode.Raster`, the default since 2026-10-30), UE's way: the
+cards are drawn rather than traced, through the material's own template.
+- The trace above took one level-0 tap of the material's 64² resident copy a texel and kept it, a
+  point sample of a texture a card texel covers many texels of. On Sponza's outer wall the brick
+  texture's dark band repeats every 12.8 card texels; it landed on a row of sample points once and
+  between rows at its other repeats, a hard seam across the wall. It now reads the copy's mips at
+  the footprint (step 3), and over that wall its cards differ from the raster's by 0.77 codes on
+  average, against 10.5 before.
+- A pair is taken whole. Its cards are drawn by one indirect draw, an instance a meshlet of each card
+  the layout has (a compute pass writes the count), each card into a cell of the pair's region of a
+  scratch: orthographic along δ, the lattice point at the texel's centre, the slab the depth range,
+  so the hardware clips to it as the trace's t ≤ depth does. Culling is off: a card sees either side.
+- The fragment stage is the template's `material_surface` and `material_opacity`, with the material's
+  one bind group, the G-buffer pass's: its textures, their mips and hardware filtering, at the card
+  texel's footprint, unbiased as UE's card capture leaves `MaterialTextureMipBias` at 0. Coverage is
+  drawn as the trace draws it, from a seed fixed per (pair, card, texel); the depth test keeps the
+  nearest opaque draw. A template without a surface function is traced.
+- A scatter then moves each page's texels from the pair's cells into its atlas tiles, in the trace's
+  encoding.
+- Measured on Sponza: the cards' colours agree with the trace's to 3 codes on average over the wall,
+  floor, ceiling and banners, without the seam or the trace's speckle. Recapturing all 154,138 pages
+  at the largest budget, interleaved in one process, cost the trace 9.1–12.7 ms and the raster 0.6 ms
+  on the RTX 4090, and 335 ms against 33 ms on the AMD iGPU.
+
 **Recapture.**
 - `GPUResidentMaterialContext` signals when it repacks a material whose version moved (§4.1). The GI
   keeps the reverse map from a material to its pairs and queues each for recapture: O(changes), E5.
@@ -1435,12 +1467,23 @@ This is the plugin system.
    cannot name a row writes 0, and its hits take the material of no row: zero albedo, counted.
 6. **Invalidation.** When a provider's data for a region changes (streaming, an edit), it appends that
    world box to the invalidation list, and next frame's movers queue the cells.
+7. **Retry** (S9). A provider that could not finish a cell this frame sets the cell's retry word in the
+   staging (`BRICK_STAGING_RETRY_WORD`). Free decides the cell as any other, keeps its key pending and
+   puts it back on the ring, so the cell is built again from the start. What was merged meanwhile is
+   published for those frames, and can over-estimate where the unfinished work would have read lower;
+   the frame that finishes the cell keeps contract 4.
 
 A provider sees every taken key. One with nothing in a cell writes nothing and pays only its own
 early-out.
 
 ### 7.7 The mesh provider
 
+**Superseded in part by S9 (2026-10-29).** Alex, after S8's holes: "Go with (b): batches of 64 spread over
+workgroups by count, with an atomic min/max merge." The cap of 64 instances below bound from cascade 2 on Zorah, and
+the instances it kept were the lowest rows, in load order: the ground under the greenhouse's ring lost to the kitbash
+numbered before it. The accept, the per-instance level and the texel stand; the cap, and one workgroup doing all of a
+cell, are gone. What is built now is "As built (S9)", at the end of this section.
+
 `MeshSDFBrickProvider` runs one 64-lane workgroup per taken key.
 
 **Gather.** A TLAS cooperative query with box = cell ⊕ R_c. The leaf accept takes a row when all of
@@ -1510,11 +1553,83 @@ count (E3), and no triangle is read.
   - With EMPTY signed (§6.3) the building's air reads inside its open hull (geometry 102), so the
     courtyard is solid in the world bricks too; put to Alex.
 
+**As built (S9, 2026-10-29)**: every instance whose box comes within the band of a taken cell is sampled there,
+however many. Three passes, each sized by a count on the device, and a one-thread command
+(`shader_mesh_brick_command`) before each but the walks from the root:
+- **Walk** (`shader_mesh_brick_gather`), a workgroup a walk: the cooperative query's level-at-a-time expansion and
+  the S3 accept, nothing dropped.
+  - A level keeps 512 nodes (`MESH_BRICK_FRONTIER`); the children past them leave in task records of 64 nodes, each
+    walked by the next round of the same kernel. On Zorah's TLAS (12,608 leaves, 27 levels) the widest level of a
+    cell's walk is 758 nodes at cascade 2 and 2,410 at cascade 5, so every walk ends in its third round.
+  - Rounds start at two and grow by one, from a read-back count, when the last round could not finish a walk, up to
+    six: enough for any LBVH of 2^20 leaves.
+  - Accepted rows leave in batch records of 64, and the rows left when the walk ends in one more.
+  - An iteration of a level costs the workgroup a barrier and a `workgroupUniformLoad`: lane 0 hands every lane
+    where the next iteration's children start and, on the level's last, how many nodes the next level holds.
+- **Batch** (`shader_mesh_brick_batch`), a workgroup a record: its rows sorted, its 64 instances in workgroup memory,
+  512 texels × 64 as S3c samples them, merged into the cell's accumulators by atomic maxima of 255 less the byte and
+  of the object key.
+- **Resolve** (`shader_mesh_brick_resolve`), a workgroup a cell the walks listed: its accumulators into the staging
+  by contracts 2 and 3. A walk lists a cell the first time it flags it, for a batch made or a walk left unfinished;
+  most taken cells have no instance within their band and cost the walk from the root alone.
+- Contract 7: a record past its capacity, a level past the budget, or nodes past the last round's frontier leave the
+  cell unfinished. It is retried, and the capacity grows to the power of two at or past the most asked for, or the
+  rounds by one. Of the records a walk asks for at once, those below the capacity are kept, so a command never
+  dispatches a record that went unwritten.
+- The texel compares in the staged byte, the lowest row on a tie, so the object no longer depends on the order of
+  the instances; the batch sorts its rows, so a cell of one batch reads the same whatever order its walk found them.
+- **Device, Zorah** (S8's load, filled; from the aerial view, the GI released and all 196,608 cells of the windows
+  built again, 60 frames; S8's provider against this one in one process, old/new/new/old), with the frontier at 1,024
+  nodes as S9 landed it; the 512 it has now follows below:
+
+  | | iGPU, S8 → S9 | 4090, S8 → S9 |
+  |---|---|---|
+  | brick view's hole pixels | 10,323–10,379 → 41 | 10,071–10,078 → 36 |
+  | the provider over the rebuild | 76.9–78.0 → 132.6–132.7 ms | 7.2–7.6 → 16.0–18.1 ms |
+  | walk / batches / resolve | 71.4 / 56.4 / 4.7 ms | 5.5–7.6 / 8.5–9.7 / 0.5–1.1 ms |
+  | a frame of it, p50 / p90 / worst | 1.15 / 2.0 / 6.4 → 1.08 / 3.6–4.2 / 17.7 ms | 0.09–0.11 / 0.17 / 0.9–1.4 → 0.20 / 0.65–0.73 / 1.3–1.4 ms |
+  | at rest | 1.4–1.5 → 8.5–11.2 µs | 3.1 → 16.4 µs |
+  | rebuild against rebuild, bricks that differ | 276 → 0 | 254 → 363 |
+
+  - The 36–41 pixels left are the dome's lattice, thinner than cascade 2's voxel: S8's open item, not the cap. The
+    ground cells under the ring, S8's open item, were the cap.
+  - Nothing retried, no record past a capacity, and every walk ended in the second round: at most 1,431 batches and
+    220 tasks a frame (iGPU), within the initial capacities; at most 805 cells a frame listed for the resolve.
+  - Where the cost goes, from one-off arms in the same process with a part of the work deleted:
+    - The batches sample every instance: 257,216 rows a rebuild, where S8's provider dropped 37,780 instances past 64
+      a cell, 93,700 candidates past 128 and 43,500 frontier nodes, so sampled at most 125,736. The batch pass with
+      nothing sampled costs 0.3–0.5 ms, and its sort 1.7 ms on the iGPU (within the noise on the 4090).
+    - The walk's floor, a workgroup a taken cell with its memory cleared and its task read, is 25.8 ms on the iGPU and
+      0.67 ms on the 4090; S8's walk alone, 48.3 and 2.3–2.4 ms. On the 4090 this walk cut to what S8's walked (256 nodes
+      a level, the rest dropped) costs 3.3 ms against its 4.4 ms: 1.1 ms is walking every node, and the 0.9–1.0 ms
+      left over S8's walk is this walk's own bookkeeping, not split further.
+    - Alex asked for a hand-off once a window of four iterations instead of each, the spill and the ring sized for the
+      window (11.3 KiB of workgroup memory against 9.1). Measured paired against this walk, it was no faster on the 4090
+      (the walk's median 4.36 against 4.29 ms, six trials each) and 27% slower on the iGPU (90.3 against 71.3 ms, four
+      each); a window of two was 4% slower there. Not taken: on the iGPU the walk slows with its workgroup memory.
+    - So the frontier went the other way, halved to 512 nodes (Alex, on this measurement): the walk's workgroup memory
+      from 9.1 to 5.1 KiB. Paired against 1,024 (four trials each on the iGPU, six on the 4090, after a warm-up whose
+      rounds grew to three, retrying 8 and 2 cells; none after): on the iGPU the walk 71.1 → 43.0 ms, the provider
+      over the rebuild 132.0 → 104.1 ms, its median frame 1.08–1.27 → 0.65 ms; on the 4090 the rebuild even (17.9 ms
+      by the mean). At rest the third round's command and walk add 2.0 µs on the iGPU and 4.1 µs on the 4090 (9.8 and
+      20.5 µs); batches 7,077 → 7,331, the rows of a cell split over more walks; holes alike. Against 1,024, 30 of the
+      iGPU's 2,684 bricks differ, the texel's box test being order-dependent for a one-sided field, as before.
+    - At rest, seven dispatches (three one-thread commands, and four passes dispatched with no workgroup) against S8's
+      one.
+- Tier 2: free's retry (red on S8's free), the resolve's contracts, list and tail, the command, the walk's spill
+  partition, the texel's order-free row (red on S8's chunk). Tier 3: the provider's dispatches and their commands, its
+  buffers and their growth. The walk and the batches run on the device only. 25 of 25 mutants were killed.
+
 **TODO hook (skinned).** The leaf accept, where a clone resolves to its source's header, is where a
 dense animated patch takes over later.
 
 ### 7.8 The virtual geometry provider
 
+**Superseded by S8 (2026-10-29).** Alex, after S7e: "Move vgeo to per-geometry signed SDF caches (baked once from a
+cut, composed per instance) instead of fixing the per-cell sign in place." The per-cell provider below (S7b–S7e) is
+deleted; S7a's cut refactor and S7e's measurements stand. What is built now is "As built (S8)", at the end of this
+section.
+
 S7, its own stage. vgeo rows are mesh rows with a virtual geometry: their BLAS is empty and they have
 no cache. The provider, per taken key:
 1. **Gather**: the mesh provider's TLAS query, accepting vgeo rows in the SDF world only.
@@ -1535,6 +1650,343 @@ 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.
+
+**As built (S8, 2026-10-29)**: a virtual geometry's cache is baked from a proxy cut from it, adopted into it, and
+composed by the mesh provider; the per-cell provider is deleted. The plan and its one fork are the shared note
+`s8-vgeo-geometry-caches-plan-2026-10-29.md`; Alex took (a), a readback of the cut's triangles into the host's own
+geometry path.
+- **The caches** (`GPUGeometrySDFManager`).
+  - `onRequested` is sent with a record each time its cache is queued: at its first holder, at a new voxel size, and
+    when its holders' side changes. `is_requested` says a cache waits queued, held or not, as the bake bakes it until
+    a trim; `holds_two_sided` says the side a bake of it takes.
+  - **Sources** (`add_source`, a `MeshSDFSource`) run first in each `graph_bake`. A source makes the caches of
+    geometries with no tree of their own, which wait queued as a geometry whose tree is not resident yet does.
+  - `adopt(target, proxy)`: the resident cache baked for the proxy becomes the target's, nothing copied. The target's
+    header takes the proxy's layout, entries and side, and the proxy's reads None, as dropped; `onBaked` is sent with
+    the target. The cache has no cards, the target having no tree to capture them with, so a vgeo hit keeps the
+    material's mean (§17). Held for another side than the proxy was baked for, it is queued again at the next bake.
+  - A bake is recorded only for work there is: a queue of geometries no bake can admit yet, and placements dropped or
+    adopted away, record none.
+- **The source** (`VGeoSDFProxies`, made with the runtime by `GPUSceneContext.enable_virtual_geometry`).
+  - A job a geometry asked for, 32 at once. Each frame a job's geometry is cut whole by the camera cut's own descent:
+    `shader_vgeo_sdf_collect` writes its record (`chunk_vgeo_cut_instance`), the claim widths are scanned, and
+    `graph_vgeo_cut_descent` runs `shader_vgeo_sdf_traverse`, which culls nothing and puts every cluster in the cut onto
+    a list under its job, counting stand-ins and the clusters past the list. It cuts under a slot of its own at τ = 1,
+    k = 1/(½·v₀) in the geometry's own units, v₀ its cache's level-0 voxel. A clamp wants its page there; since a want
+    lasts one reading, the job is cut again each frame until its cut stands nothing in.
+  - `shader_vgeo_sdf_decode`, a workgroup a listed cluster, counts every job's vertices and triangles. For a job
+    whose last cut stood nothing in, it writes the clusters out in room those counts made: positions as stored,
+    triangles as indices into the job's own vertices.
+  - One readback a frame: the jobs' counters, the cut's own (a subtree left undescended voids the frame for every
+    job), and the meshes. A write-out whose counts disagree with its room's is cut again.
+  - The proxy: one a frame on the host, `meshlet_geometry_build_from_geometry` (2.2–4.1 µs a triangle, measured),
+    added to the geometry manager, its cache held with the side the geometry's holders draw. When it turns resident,
+    the next update adopts it into the geometry and removes the proxy. A proxy whose mesh another's has is that one's
+    record: only one adopts, and the other geometry is extracted again.
+  - A job whose geometry is no longer queued is let go; a new voxel size restarts every job.
+- **The holds** (`ProbeClipmapSceneHolds`): a vgeo row holds its cache as a mesh row does. Its pair's card set waits for
+  good, since an adopted cache has no card layout.
+- **Deleted**: `brick/vgeo/` (the gather, the box cut, the distances, the wait and their specs), its registration in
+  the GI, and the provider context's `budget` and `pending`, which only it used.
+- **Device, Zorah** (as S7e loads it: 1,012 geometries, 12,597 instances, one grey material, the manifest's sun,
+  1280×720), entered once with the default settings.
+  - The fill: every one of the 1,012 caches resident after 3,160 frames on the 4090 (31 s) and 3,200 on the AMD iGPU
+    (247 s). 1,013 proxies were built, one twice (a proxy came out alike to another's), from 423,584 triangles: step
+    0's "a few hundred thousand". 8 geometries were coarsened (step 0's 8). The bake evaluated 52,911 bricks, the
+    atlas grew to 65,536 slots, and the caches hold 35.3 MB. Their cuts took 34–42k clusters over ~1,180 readings and
+    stood one in 6–9k times while their pages came; no wavefront ran out, nothing was dropped, and the cluster list
+    never grew past 4,096.
+  - The fill's pace, 0.32 geometries a frame, is mostly the bake's budget of 23 bricks a frame, at 52 bricks a
+    geometry: it averaged 16.7 a frame, idle in 27% of the frames while proxies waited on their pages, their write-out
+    or their build. Zorah's proxies cost less a frame than Sponza's meshes: the evaluate is 652 µs at p50 and 9.0 ms at worst on
+    the 4090, 3.7 ms at p50, 17.7 ms at p90 and 48.9 ms at worst on the iGPU, inside what the budget costs on Sponza
+    (§6.4: 26 ms at the median and 79 ms at worst on the iGPU). The extraction's own passes, in the 1,734 frames that
+    cut: the cut 48 µs at p50 and 499 µs at worst on the 4090 (36 and 337 µs on the iGPU), the decode 4 µs at p50.
+  - The host: a frame that builds a proxy is 4.4 ms at p50 against 3.0 ms without on the 4090's host, 20.7 ms at p99,
+    and 190 ms once, for the largest geometry's proxy (the iGPU run's host: 4.8 / 3.2 / 20.4 / 150 ms).
+  - The frame while filling, p50 / p90: 3.82 / 5.56 ms on the 4090 and 66.0 / 80.5 ms on the iGPU (158.9 ms at worst).
+    At rest nothing of the extraction runs: 3.28 ms on the 4090 and 63.0 ms on the iGPU, S7e's 62.8 ms.
+  - The probes and their rays, after the fill, both GPUs alike:
+
+    | view | dead probes, S7e → S8 | back-face rays, S7e → S8 | lit luma, S7e → S8 |
+    |---|---|---|---|
+    | manifest | 23% → 3.2% | 12% → 4.7–5.0% | 89 → 91 |
+    | aerial | 18% → 2.0% | 9% → 4.5–5.1% | 74 → 76 |
+    | ground | 49% → 6.8–7.0% | 17% → 5.5–6.6% | 21 → 79–83 |
+
+    Sponza on the mesh caches has 1.6–4% dead and 2% back-face rays. The arcade at ground level, which S7e lit at 19 to
+    37, is lit at 79 to 83 from the sunlit floor. From the air the bricks read as Zorah, the greenhouse's dome and the
+    tower whole, where S7e's read inside out (`s8f_igpu_aerial_bricks.png` against `s7e2_aerial_bricks.png`).
+  - Sponza's census is unchanged (4090): 7,171 bricks, every cascade's counts, 104 geometries baked, resident at frame
+    355.
+  - Open, measured, cause not established: from the air, cells of the ground under the greenhouse's ring are still
+    black (the ray passed through); the column at the manifest camera still has its dark blotches on a lattice; its
+    flutes, narrower than a voxel, read as back faces in the brick view. A proxy's id is not given back
+    (`GPUGeometryManager` hands ids out once), so the fill takes Zorah's ids from 1,012 to 2,024.
+- Tier 2 (`vgeo_sdf_extract.spec.js`, over a built torus in the runtime's tables and in a meshlet pool): a job's list is
+  the CPU oracle's cut at its error with no cull, and its counts are the listed clusters'; written out, its mesh is
+  every triangle of those clusters as the meshlet pool's own reader reads them back; a room too small takes no cluster
+  past it; a missing page is a stand-in, wanted through the slot; past the list's capacity the count runs on. Tier 3:
+  the caches' adopt, sources, requests and waits (`GPUGeometrySDFManager.spec.js`, a bake done on the device standing
+  in its log); the proxies' host half end to end (`VGeoSDFProxies.spec.js`, the device's readbacks standing in); a vgeo
+  row's hold. 43 of 43 mutants were killed.
+
 ### 7.9 Tracing
 
 `brick_clipmap_trace(origin, direction, t_min, t_max)` is a pure chunk over seam readers, so the
@@ -1650,6 +2102,10 @@ left the estimator to the measurement. It is Quílez's two-sided estimate.
   - A linear map in place of `¼(1 + x)²(2 − x)` survives within the oracle's tolerance. On the CPU its
     mean error is 35% more, and its worst no more.
   - Never stopping in the umbra is equivalent: the least only falls.
+- **Replaced 2026-10-30** by a shadow ray toward a point of the sun's disk, and the chunk deleted (§8.7, as
+  built): the estimate reads the field's clearance about one ray, so two occluders from either side of
+  the cone read as one. Under a slit narrower than the disk it saw 0.675 of the sun where the disk is
+  0.327 open.
 
 **As built (S3f)**: `ProbeClipmapDebugView.BrickClipmap` traces each pixel's camera ray through the
 world's bricks (`debug/graph_probe_clipmap_debug_brick_clipmap.js`).
@@ -1718,7 +2174,7 @@ Measured on Sponza with its caches resident, at the defaults: 6 cascades of 32³
 | States | storage buffer, one `u32` a slot: NEW / ALIVE / DEAD and the update count. Its own array, so the pick reads 4 B and not a record (§9.1) |
 | Records | storage buffer, 64 B a slot: cascade and world cell (3 × 21-bit signed, two words), wanted frame, traced time (s), relocation offset (3 × f16), back-face fraction, SH2 as `METRO_L1_IRRADIANCE_STRUCT` (32 B) |
 | Radiance | 2-D `rgba16float` atlas; a slot's tile is `(n_r + 2)²`: the octahedral map plus a one-texel skirt. One level only (§9.3). Slots are placed by `index_to_grid2d`, as in `lpv_atlas_patch_texel_coord` |
-| Depth | 2-D `rg16float` atlas, tile `(n_d + 2)²`. Moments of `min(t, √3·s_c)/s_c`: normalised by spacing, so every cascade has the same precision, and clamped at the cage diagonal, past which a hit cannot occlude anything the cage shades |
+| Depth | 2-D `rg16float` atlas, tile `(n_d + 2)²`. Moments of `min(t, (1 + 0.45)·√3·s_c)/s_c`: normalised by spacing, so every cascade has the same precision, and clamped at the farthest a cage tests a relocated probe (D9), past which a hit cannot occlude anything the cage shades |
 | Wanted bits | `N_p³·C_p` bits, cleared each frame |
 | Lists | active (double-buffered), wanted, trace (≤ U, §8.5) |
 | Free list | the extracted slot stack (§4.1) |
@@ -1734,6 +2190,19 @@ hardware taps.
 The price: a texture cannot be read and written in one dispatch without `texture-formats-tier2`, so
 the update is two passes (§8.8). That is LPV's own answer for its depth atlas.
 
+**As built (2026-10-30), the record packed**, 48 B a slot, `PROBE_RECORD_STRUCT.pack()`:
+- the cell, `vec3<i32>`;
+- one flags word: the back-face share as unorm16 in the low half; ten bits of flags above it, the screen's
+  mark the first; the cascade in the top six bits;
+- the wanted and the traced frame, `u32`, of the frames the clipmap has recorded: exact where f32 seconds
+  lose their step as the clock runs on, and an update happens in a frame anyway. The blend's Δt is the
+  frames since the update and τ is `response_frames` (default 30, half a second at 60 fps), so the probes
+  take no clock from the caller. Eviction's age buckets count frames: 0, 1, 2–3, 4–7, … Retire evicts by the bucket a probe was
+  counted in, its age a frame before. With integer ages a probe one frame younger than an asked bucket
+  aged into it between schedule and retire, and was taken uncounted;
+- the SH, `vec3<u32>` of half floats: Y's xy, Y's zw, CoCg, held to ±65,504. Half the Metro L1 struct's
+  32 B.
+
 ### 8.3 Lifetime
 
 Per frame, in this order:
@@ -1741,7 +2210,9 @@ Per frame, in this order:
 1. **retire** (thread per active probe). A probe is freed when either holds:
    - its world cell is no longer in its cascade's window (`clipmap_contains` against the current
      corner);
-   - it was last wanted more than `retention_time` ago (default 1 s).
+   - it was last wanted more than `retention_time` ago (default 1 s). Since 2026-10-30 instead: the last
+     frame's schedule evicted it, by the pressure on the slots, least recently wanted first (as built,
+     below the measured churn).
 
    Freeing it means:
    - its slot is pushed;
@@ -1758,10 +2229,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 +2301,133 @@ 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.
+
+**Measured (2026-10-30), the churn in a still scene.** Sponza at 1280×720, the clock at 60 Hz, the camera
+and the light still, 3,600 frames settled. Then 600 frames, each read back: every slot's state and record,
+the wanted list, the trace list and the period. A slot's probe is followed by its point and its update
+count. Modelled as §8.5 has it, due agreed with the trace list on every probe past its first update, those
+a full list turned away aside: 2.7 million checks on each GPU, none apart.
+- **Hits' probes come and go, about four a frame.**
+  - The RTX 4090 admitted 3.9 a frame and retired 3.8–3.9 (three runs); the AMD iGPU 4.1 and 4.0.
+  - The screen admitted none.
+  - Every probe retired had gone unwanted for 1.017 s, the retention time and a frame.
+- **They are the probes up to three updates old**, §8.6's 11%. Of the 4090's 501 (11.4% of the alive),
+  487 were admitted within the 600 frames; of the iGPU's 532 (12.2%), 509. The few others are hits'
+  probes wanted on about one frame in twenty, whose want seldom falls on their turn.
+- **The same points come back.** Of the 896 points admitted in the 10 s, 650 were admitted again, three
+  times at the median.
+- **Each is wanted by one far ray.** A twin of the hits' wants kept, for each point, its shortest wanting
+  hit and the rays that wanted it.
+  - A point admitted was wanted by one ray (p50 and p90), 10.8 m from its probe at the median (p10
+    5.3 m). Of those rays 60% were a uniform update's.
+  - A point kept was wanted by 6 rays a frame at the median, at 3.2 m.
+- **Why far.** A radiance texel's ray stands for the texel's cone, t·√(4π)/n_r across where it lands:
+  0.22·t at n_r = 16, which past t = 4.5 m is wider than a cage of the finest cascade. That cascade holds
+  95% of the admissions. Such a cage is landed in by chance, once every few seconds (a probe both
+  admitted and retired within the 600 frames lived 1.3 s at the median), and the retention frees its
+  probes in between. The next landing finds no probe, so its ray takes no bounce from them.
+- **What it costs**: the admitted probes' first updates and their next three cast 2,560–2,870 of the
+  frame's 52,600–53,700 rays on both GPUs, 4.8–5.5%, and are 1.3% of the updates. On the AMD iGPU the
+  passes a ray (trace, shade, light, the hits' wants) take 5.4 ms at the median and those a probe 2.0 ms,
+  so by those shares about 0.3 ms a frame; not timed against a build without it.
+- **What moves it**, on the 4090, in admissions a frame against 3.9:
+  - a retention of 3 s: 0.7. Those up to three updates old fall to 5.9%, and 3.5% more probes are live;
+  - every request held at R, 256: 3.0. Those are the rays before the variable requests (§8.6), 2.3 times
+    as many, so the requests are not the cause;
+  - half the ray budget, T from 6 to 10: 5.1, and 15.9% up to three updates old. A hit renews a probe
+    at most once a hitter's period, while the retention is in seconds, so the churn grows with the live
+    count;
+  - the hits' wants and the light pass's pick at the finest cascade whose spacing covers the texel's
+    footprint, a twin of both: 2.4, with 11% fewer probes live and 4% fewer rays. At twice the footprint:
+    1.9, with 30% fewer probes and 9% fewer rays. Both gather their admissions where the cascade changes
+    (t of 4.4 m and 2.2 m at the median). The cascade then follows each ray's distance, not the point, so
+    a point's wants split between two cascades.
+  - The frame's mean luma: 72.3 as built (72.4 on the iGPU), 71.5 at 3 s, 71.9 and 71.8 by footprint.
+    As built read 71.0–72.0 between runs (§8.6).
+- **Hits' probes are retraced less often than every T frames.**
+  - The 3,077 hits' probes alive through the 600 frames were wanted on 67% of frames at the median, 11%
+    at p10.
+  - They were updated 6.8 times a second at the median and 0.8 at p10; the screen's, at least 6.6.
+  - At p90, 1.2 s had passed since their last update; at p99, 6 s.
+  - A hit wants a probe in the frame after its hitter's update, so its point's bit is set on fewer of
+    the probe's turns than a pixel's is.
+- The passes did what this section and §8.5 said. The churn was the retention's, on points that hits land
+  in once every few seconds; a fixed retention was the departure from Enshrouded, whose cache evicts by
+  pressure (Alex, 2026-10-30), built below.
+
+**As built (2026-10-30), eviction by pressure, not by a retention time.** Enshrouded's cache stays full and
+evicts every frame, more the fuller it is, so a probe keeps its history as long as there is room.
+- **Retire** frees a probe whose point left its window, or one the last frame's schedule asked for.
+  `retention_time` is gone, from the settings and the passes: a hard break.
+- **How many**: as many slots as the free ones fall short of the frame's wanted points and 5% of the
+  capacity (`PROBE_FREE_SLACK`, Alex's). The wanted points are the most a frame can admit, a camera cut's
+  included, and the slack is room for a burst of them the frame it comes.
+- **Which, the least recently wanted first**: retire counts each probe it keeps and could evict into one of
+  32 binades of the seconds since it was last wanted (`probe_clipmap_age_bucket`, the float's exponent, 1 s
+  beginning the middle one), `PROBE_COUNTER_AGES` on. Schedule walks them from the oldest, taking a bucket
+  whole while the shortfall takes it and the rest of the shortfall from the next, and writes that to
+  `probe_eviction`; retire's threads take that bucket's while a counter, `PROBE_COUNTER_EVICTED`, is under
+  it. Past the youngest bucket anything was counted in, schedule asks for nothing. No sort, no pass of its
+  own, nothing read back.
+- **In use, never evicted**: a probe a want waits on, NEW or wanted since its last update (§8.5), and one
+  wanted the last frame (retire takes that frame's time). Where those fill the slots, an admission starves
+  and the capacity grows, as before.
+- **Device, Sponza, the 4090**, the still view, 600 frames, against the base before §8.5's as-built note:
+  - admitted 0.007 probes a frame against 3.9, retired none against 3.8;
+  - the young probes' rays 19 a frame against 2,600; the frame's 54,800 against 53,800 (with §8.5's change
+    alone 58,500, the churn's probes taking their second updates);
+  - 5,400 probes live against 4,500;
+  - the probes up to three updates old still 11.3% of the alive: probes kept that hits want once in a few
+    seconds, updated when they are.
+- **A walk**, the courtyard's length and back over 1,200 frames, the 4090:
+  - at the default capacity, 16,384, at least 6,849 slots stayed free: nothing was evicted;
+  - at N = 16, 4,096 slots, 488 frames evicted, no admission starved and the capacity never grew. The
+    frame's wanted points were half the slots there, so a frame short of room freed every probe out of use
+    older than about two frames.
+- **The sun doubled**, frames to 50%, 90% and 95% of the change in the mean band 0 of the probes wanted:
+  37–42, 98–106 and 117–133, against the base's 38–41, 85–99 and 117–135, two runs each.
+- **The AMD iGPU**, the still view, separate processes and not paired, against the base:
+  - admitted 0.007 a frame against 4.0, the young probes' rays 24 against 2,840, the frame's 54,700
+    against 53,700;
+  - a want waited 6 frames for its update at the median, the screen's 13 and the hits' 20 at p99;
+  - the trace list held U, 512, nearly every frame against 477 a frame: the period counts every probe a
+    want waits on (§8.5), so the update fills its budget, where the hits' probes it skipped left it
+    short. The probe passes summed 7.91 ms at the median against 7.55, of which trace, shade and light
+    5.25 against 5.02;
+  - retire 26.6 µs against 21.3, admit 13.6 against 8.3, schedule 3.5 against 0.8, the due passes 9.4
+    against 15.4.
+- Tier 2, `probe_clipmap_lifetime.spec.js`: a probe nobody wants keeps its slot while there is room; past
+  the room the probes wanted longest ago go first, as many as the room lacks, a bucket in part where it
+  lacks part of one; one that leaves its window as its bucket is partly evicted takes none of it; a NEW
+  probe and one wanted the frame before are never evicted, and an admission the room still lacks starves;
+  a shortfall the evictable probes cannot cover asks for those counted, none younger. The first three
+  were red against the retention time; the rest guard the protections. Mutants: 13 of 13 killed.
+- Tier 3, `GPUProbeClipmap.spec.js`: retire's times, schedule's slack, the eviction zero as made.
+
 ### 8.4 Relocation and classification
 
 **Relocation**, at the start of every update:
@@ -1892,6 +2500,31 @@ assumes.
 - Mutants: 19 of 21 killed. The two survivors are equivalent on the fields the specs build: the early
   exit where the field is flat, and the gradient's flatness threshold on fields exactly flat.
 
+**As built (2026-10-30), due waits on a want, not on this frame's bit.** The hits' wants (§8.3) set a
+point's bit the frame after their probe's update, so a probe only hits keep had its bit on few of its
+turns: measured on Sponza (§8.3), the hits' probes were updated 0.8 times a second at p10 against the
+screen's 6.6 at the least, and 6 s had passed since the last update at p99, 21 s at most.
+- **Waiting**: a probe is NEW, or a pixel or a hit wanted it since its last update, its wanted time past
+  its traced time. The update comes after admit in its frame, so a want in the frame of an update is
+  served by it. Due lists the NEW in its first pass, and a waiting ALIVE or DEAD probe on its turn.
+- **The period counts the waiting**, `T = max(1, ⌈P_w / U⌉)` with P_w the probes waiting, not the
+  points wanted this frame. Retire counts the waiting probes it keeps and admit those the frame's wants
+  add, one atomic a subgroup each (`subgroup_atomic_add_u32`), into `PROBE_COUNTER_WAITING`, the
+  counters' fourth word; schedule takes the period from it and empties it.
+- **Device, Sponza, the 4090**, the same still view and 600 frames, against master:
+  - the hits' probes alive through them, 2,984: 4.7 updates a second at p10 and 8.2 at the median,
+    against 0.8 and 6.8; 0.42 s since the last update at p99 and 1 s at most, against 7.2 s and 21 s;
+  - the screen's: 8.3 a second at the median against 10.8, the period 7 frames against 5–6;
+  - the frame's rays 58,500 against 53,800, the young probes' 5,300 of them against 2,600: the churn's
+    probes now take their next updates when a hit wants them again (§8.3);
+  - the trace list held more than U on 454 of the 600 frames, 524 a frame on average: due lists every
+    NEW probe besides a period's share of the waiting, so its count sits at U, and the last ones past it
+    wait their next turn.
+- Tier 2: `probe_clipmap_schedule.spec.js` (the period over the waiting; a probe wanted between its turns
+  due on its turn; one whose wants its update served, the same frame's included, not due; a NEW one at
+  once), `probe_clipmap_lifetime.spec.js` (retire and admit counting each waiting probe once, through the
+  period). Each was red against the shaders before. Mutants: 8 of 8 killed.
+
 ### 8.6 Rays
 
 **trace**: one thread per ray, `trace_count × rays_per_probe` rays.
@@ -1911,13 +2544,28 @@ assumes.
   visibilities}.
 
 **As built (S4c, 2026-10-28)**, `probe/shader_probe_clipmap_trace.js`:
-- **The ray record** is 28 B (`PROBE_RAY_STRUCT`) since S4d: `t`; the direction and the hit's
-  normal,
+- **The ray record** is 24 B (`PROBE_RAY_STRUCT`; 28 B with the light in three half floats until
+  2026-10-30, now one RGB9E5 word): `t`; the direction and the hit's normal,
   each octahedral in two unorm16; the `meshes` row of the hit's surface, from `brick_clipmap_object`;
-  the flags (kind, back face, the hit's cascade); and the light, three half floats. Trace writes the
-  direct irradiance there and shade writes the radiance over it. The hit's position is the probe's
-  origin plus `t` along the direction, which shading recomputes. (S4c's record held the two suns'
+  the flags (kind, back face, the hit's cascade); and the light. Trace writes the
+  direct irradiance there and shade writes the radiance over it. The hit's position is the ray's
+  start plus `t` along the direction, which shading recomputes; the start was the probe's origin until
+  the ray origins below. (S4c's record held the two suns'
   visibility in place of the light; S4d moved E_dir into the trace, below.)
+  - **The light as RGB9E5 (2026-10-30, Alex: the half floats were a poor encoding).** The engine's
+    `rgbe9995` chunks: one word, the three channels sharing an exponent. The encoder clamps to its
+    largest value, 65,408, which replaced the half-float holds in shade and the light pass and still
+    keeps the half-float atlases finite. A channel far below the brightest loses precision: beside
+    65,408, 2 and 3 round to 0.
+  - Measured paired in one process. The five passes that read or write the record (trace, shade,
+    light, accumulate, the hits' wants) ran as twins built from master's WGSL, swapped in at
+    `setPipeline`, the two encodings each twice. There were 120 frames an arm, the clock at 60 Hz:
+    - 4090: Sponza +14 µs a frame across the five, all in the trace (+3%; its repeats differ by 3–10
+      µs); Emerald Square's avenue the same.
+    - iGPU: Sponza −124 µs (−2%; shade and light −4% each); Emerald the same.
+  - The image, settled 1,200 frames, master and the tree in separate processes: on Sponza they differ
+    by 1.6–1.7 codes a channel on average, and two runs of the tree by 1.8. The probes' noise is not
+    the same from process to process. On Emerald's avenue they differ by 0.01.
 - **The texel mapping** is `chunk_probe_clipmap_ray_texel`, both ways (a ray's texel, a texel's rays),
   so accumulation finds each texel's rays without a scatter. The bit-reversed subset repeats every
   n_r²/R updates, which keeps its product in range.
@@ -1935,7 +2583,7 @@ assumes.
   zero there. The light keeps its place among the shadowed, so which lights are shadowed does not turn
   on the surface's orientation.
 - **E_dir is the trace's** since S4d: Σ colour·max(0, n·l)·visibility over every directional light,
-  the first two that cast shadows by their soft shadow, at a front-face hit. The trace reads the lights
+  the first two that cast shadows by their soft shadow (a shadow ray since 2026-10-30), at a front-face hit. The trace reads the lights
   already, and shade would have needed the light table as an eleventh storage buffer (below).
 - **On the device**, Sponza at 1280×720 with the caches baked, 131,072 rays a frame (U = 512 × R = 256):
   96% hit, 3.4% miss, 0.2% unresolved, 2.5% back faces; the mean hit at 2.6 m; 13% of the sun seen at
@@ -1965,6 +2613,236 @@ assumes.
     starts at the relocated probe; the rays of a probe past U are not traced.
 - Mutants: 18 of 18 killed.
 
+**As built (ray guiding, 2026-10-29): Enshrouded's importance-sampled rays** (D11 reversed in its rays'
+half). Alex found the noise of one jittered ray a texel visible and asked for Enshrouded's scheme,
+rotating corner and all.
+- **Which updates are guided**: every `PROBE_UNIFORM_PERIOD`-th update (5, the talk's) is uniform, as
+  above. So are a probe's first n_r²/R updates, one when R ≥ n_r², which together reach every texel:
+  Enshrouded gives a new probe its most rays for the same reason, and the guide would weigh a texel no
+  ray has reached as dark. Every other update is guided, except a DEAD probe's, which are all uniform:
+  readers weigh it at nothing, and only uniform rays reclassify it. Guided, its rare updates kept it dead
+  for 40 periods, and Sponza's dead probes rose by a quarter.
+- **The guide** (`probe/shader_probe_clipmap_guide.js`), three passes a thread a row of each listed
+  probe's radiance map before the trace, per-invocation as projection is:
+  - rows: the luminance of the row's history texels;
+  - weights: each texel's share of the probe's luminance in fixed point (`PROBE_GUIDE_SCALE`), held to
+    `(PROBE_TEXEL_RAYS − 2 − R/n_r²)/R`;
+  - starts: the first ray of each walk position, `⌈R·Σ_{q<p}(w_q + e)/W − φ⌉`, with `e` the even share
+    of what the weights leave of the scale, and `φ` a hash of slot and update count. The walk is the
+    map's rows from the corner `updates mod 4` names.
+  - Integer weights make the walk's sums exact, so trace and accumulation read the same rays for each
+    texel. The hold leaves every texel under 64 rays, the gather budget, and what it takes off is spread
+    over every texel. A dark history spreads its rays evenly, which classification can trust.
+  - Kept: `probe_clipmap_guide_words` = 2·n_r² + 2·n_r + 2 words a listed probe (1.1 MiB at U = 512).
+- **The trace** bisects the first rays for its walk position, at most log2(n_r²) steps. A texel's later
+  rays rotate its STBN jitter by R2 (`probe_clipmap_guided_ray_jitter`). The light pass, shade and the
+  hits' wants are unchanged: any per-ray noise serves the light pass's pick.
+- **What it does to the rays**: on Sponza the back faces fall from 3–4% of the rays to 2.5–3%. The
+  hits shift toward lit surfaces, whose sun shadow rays are the trace's cost.
+- **Measured, Sponza 1280×720.** Every comparison is the tree at period 1 (every update uniform, the
+  tree without guiding) against period 5, in separate runs on each GPU; values are given as AMD iGPU /
+  RTX 4090.
+  - **Screen, S4g's stability method.** TAA and AO were off; SSR on, so that the deferred diffuse and its
+    twins draw. The runs took 240 frames after the bake and 240 to settle, with the probes' clock fixed
+    at 60 Hz. Each number is the mean relative luma change of a pixel against the previous frame at the
+    same surface point, and **none moves**:
+
+    | p50, period 1 → 5 | still | orbit |
+    |---|---|---|
+    | eight corners blended (the probes alone) | 0.55 → 0.56% / 0.54 → 0.55% | 3.83 → 4.01% / 3.95 → 4.09% |
+    | the shipped pick | 14.1 → 14.4% / 14.3 → 14.2% | 19.0 → 19.7% / 18.7 → 20.1% |
+    | the frame, SSR off (fused pass) | 10.7 → 10.3% / 10.3 → 10.2% | |
+
+    Per frame, the pick's draw of two of eight is most of the diffuse's change (14% against 0.55% with
+    all eight blended), as S6's estimator session also found.
+  - **Probes**, the estimator session's probe-level method (`msme.js`, `probe_reads`):
+
+    | period 1 → 5 | AMD iGPU | RTX 4090 |
+    |---|---|---|
+    | texels, an update apart, p50 | 1.05 → 1.37% | 0.92–1.03 → 1.27–1.29% |
+    | SH band 0, an update apart, p50 | 0.27 → 0.40% | 0.26–0.28 → 0.36–0.38% |
+    | atlas texels, 24 frames apart, Σ abs(ΔL) / Σ L | 8.7 → 7.5% | 8.7 → 7.2% |
+    | a doubled sun, 50% / 90% taken | | 44 / 160 → 34 / 117 frames |
+    | its halving, 50% / 90% | | 55 / 183 → 44 / 140 frames |
+
+    Guiding makes the probes follow a light change about a quarter sooner. Their noise between one
+    update and the next rises a third, while over four updates it falls by a sixth. The uniform update
+    every fifth, which gives a texel one ray where the guided ones gave it several, is the likely source
+    of the update-to-update jitter; this is not isolated.
+  - **Before the multi-scale mean** (master at d1ca833d6, the exponential blend) the probes' noise fell
+    without the rise: the atlas 24.9 → 18.0% / 24.6 → 17.9%, the eight corners' p90 1.30 → 0.92% /
+    1.24 → 0.87%. The screen did not move then either. The estimator took most of what guiding
+    took off.
+  - Dead probes fall by 9–17%. An alive probe is re-tested only on its uniform updates, a dead one on
+    every update, so a probe near the quarter spends more of its time alive. A probe inside a solid is
+    dead from its first update, which is uniform.
+- **Paired cost**: one page, periods 1 and 5 alternating in blocks of 16 frames (ABBA, the first 4 of
+  each dropped), the camera still, p50 in each arm, on master with the multi-scale mean:
+
+  | | AMD iGPU | RTX 4090 |
+  |---|---:|---:|
+  | trace | 6.79 → 7.58 ms | 335 → 470 µs |
+  | accumulate | 429 → 676 µs | 11 → 21 µs |
+  | the guide's three passes (both arms) | 496 µs | 28 µs |
+  | shade and light | +76 µs | ±1 µs |
+
+  In all, **+1.6 ms a frame on the iGPU and +0.17 ms on the 4090**. The trace's rise is the sun's soft
+  shadow at the lit hits that guided rays favour.
+- Tier 2: `probe_clipmap_guide.spec.js` (a dark history's even spread, shares by luminance, the hold,
+  the corner, U), `probe_clipmap_trace.spec.js` (each walk position's run in its texel, a texel's rays
+  apart, a uniform update and a DEAD probe ignoring the guide), `probe_clipmap_accumulate.spec.js`
+  (a texel's run averaged, the period by rarity on uniform updates for radiance and depth, a depth texel
+  as a mean of means), `probe_clipmap_project.spec.js` (a guided update keeps the kind; a dark guide's
+  update and a DEAD probe's classify).
+- Mutants: 16 of 16 killed, among them the trace, accumulation and projection as they were.
+
+**The adversarial review (2026-10-29) found two defects in the first cut, both fixed and pinned:**
+- **With R < n_r², a new probe took 5× the updates to see its sphere.** Its first update reached R texels
+  and cleared the rest, and the guide weighed the cleared ones dark. At n_r = 16 and R = 64, the whole
+  sphere was seen at update 15, not 3.
+  - Now a probe's first n_r²/R updates are uniform (above).
+  - Measured on the 4090, Sponza orbiting at R = 64, two runs each: the alive probes' mean irradiance
+    (E/π) was 0.0137 every update uniform, 0.0079 before the fix, and 0.0121 after it.
+  - The 12% that remains is not traced. The likely source is the guide itself at R < n_r²: a texel
+    whose sample read dark takes its next ray from the uniform updates, which reach it once in
+    5·n_r²/R updates. At the default R = n_r², still, the guided irradiance matches the uniform within
+    0.5%.
+- **A guided depth texel took only the radiance texels that took rays**, so where it mixes lit and dark
+  directions (a back face, a shadowed wall) its depth leaned to the lit ones'.
+  - Now a guided update takes a depth texel only when every radiance texel inside it took rays. Its
+    period counts the least reached of them.
+  - Measured on Sponza at the defaults, still: the median depth moment was 1.590 every update uniform,
+    1.599 before the fix, and 1.584 after it. The means agree within 0.3%, so on Sponza the bias was
+    small.
+
+**As built (ray origins, 2026-10-29): each ray starts at a point of its own**, uniform in a ball of
+`PROBE_RAY_ORIGIN_JITTER` = 1/16 of the spacing around the probe, as Brick4's bake jitters its probes
+(Alex's request).
+- The point is `chunk_probe_clipmap_ray_origin`'s, a hash of the probe's slot and the ray's packed
+  direction. Shade, light and want hits put the hit back together from the same start, so the record
+  carries nothing new. The trace's jitter moves the direction every update, and the start with it.
+- A sixteenth is half a brick voxel at the default sizes, well inside the relocation clearance (¼), so
+  wherever relocation reached the clearance every ray starts outside the solid.
+- Measured on Sponza, the camera still, two runs a radius on the 4090 and one on the iGPU (harness:
+  session 481e40f0's scratchpad, `device/oj.js`):
+
+  | radius, of the spacing | texel change an update apart, p50 | dead probes | depth σ, p50 |
+  |---|---:|---:|---:|
+  | 0 | 1.11–1.19% | 3.2% | 0.046 |
+  | 1/16 | 1.00–1.01% | 3.5% | 0.051 |
+  | 1/8 | 1.17–1.26% | 4.5% | 0.073 |
+  | 1/4 | 1.40–1.67% | 5.9% | 0.122 |
+
+  - Alex compared the converged eight-corner diffuse at ¼ against 0. The jittered image is markedly
+    smoother, and sharp-contrast artifacts are gone. The whole-image |Δ|/L read under its own noise floor,
+    so the change is local, and that metric misses it. He chose 1/16.
+  - Brick4's own radius, 5e-5 m, changes nothing here: an SDF march has no float ties for it to break.
+  - Rebuilding hits from the probe instead of the ray's start is measurably wrong from ⅛ up: E/π +3.5–4%
+    and 10–13% more probes, from hits wanting the wrong cells. Matching costs at most one timer step a
+    pass on either GPU.
+  - Cost, measured at ¼ (paired by blocks of frames in one page): the trace +3.5% on the 4090 (442 →
+    458 µs), nothing on the iGPU.
+- Tier 2: `probe_clipmap_trace.spec.js` (the starts within the ball and spread over it; a wall's `t`
+  from each ray's own start), `probe_clipmap_light.spec.js` (a probe of one ray placed by its start; the
+  pick's hits from it), `probe_clipmap_lifetime.spec.js` (a hit across a lattice plane from its probe
+  wants the cage its start puts it in).
+- Mutants: 5 of 6 killed. The survivor is shade rebuilding its hit from the probe: its spec has no card
+  resident, so no hit position reaches its output.
+
+**As built (a probe's own count of rays, 2026-10-30): the frame's rays are laid out by listed probe**, the
+first stage of `PROBE_RAYS_VARIABLE_AND_SORTED_SCOPE_2026_10_30.md`. Every probe still casts R; what
+changes is that nothing assumes it.
+- **The layout.** After the trace command, the ray counts pass writes each listed probe's count of rays
+  (`probe_ray_counts`), and `graph_prefix_scan_csdldf`'s shaders scan them into `probe_ray_sums`. The k-th
+  probe's rays are `[sums[k − 1], sums[k])`, and the last sum is the frame's count, which a one-thread pass
+  turns into the rays' command.
+- **Each pass finds its probe.** Trace bisects the sums (`lower_bound_branchless`, as the mesh expansion
+  does) and writes the probe's place in the list into the ray's flags, above the cascade, which is now
+  three bits. Shade and the hits' wants read it there. The light pass, accumulation and the guide also
+  read the probe's own count from the sums.
+- **Past the last ray.** The threads of the launch's last workgroup past the frame's last ray write a
+  record of no ray (kind 3, `PROBE_RAY_NONE`). Every pass after trace stops there, so none needs the
+  frame's count. The rays buffer is rounded up to whole workgroups for them.
+- **R still means the uniform update.** A probe's first n_r²/R updates are uniform, and the rate's
+  uniform term (§8.8) keeps the settings' R. A guided update's walk, its gather and its expected rays
+  take the probe's own count.
+- **Storage buffers:** shade stays at 9, the light pass and accumulation go to 9, and trace goes to 8.
+- **Device, Sponza, 4090,** clock at 60 Hz, 900 frames settled, two runs of each build alternating:
+  master and the layout agree within master's own run-to-run spread (frame luma 71.8/71.8 against
+  71.0/72.0, alive probes 4,393–4,463 against 4,400–4,403, SH E/π mean 0.0131–0.0134 against 0.0133).
+  The passes' times are unchanged. The ray counts cost 4 µs and the rays' command 2 µs.
+- Tier 2: `probe_clipmap_trace.spec.js` (a probe casting its own count after the probes before it, each
+  ray naming it; the records of no ray), `probe_clipmap_accumulate.spec.js` (two rays a texel averaged
+  where R says one), `probe_clipmap_guide.spec.js` (the walk sharing out the update's own count),
+  `probe_clipmap_schedule.spec.js` (the ray counts and the rays' command). Each was red against the
+  shaders before it.
+
+**As built (variable rays, 2026-10-30): each probe asks for its next update's rays**, the second stage of
+`PROBE_RAYS_VARIABLE_AND_SORTED_SCOPE_2026_10_30.md`: Enshrouded's requests, on the period kept (F1).
+- **Counts and requests.** The ray counts pass writes two parts for each listed probe. The first is what
+  the budget does not scale: a uniform update's R (a NEW probe's among them), and a DEAD probe's fewest,
+  n_r²/4 (`PROBE_RAYS_PER_TEXEL_MIN`). The second is what it does scale: a guided update's request, at
+  least the fewest. Both are scanned, and the ray layout pass gives the requests what the budget leaves
+  past the counts: all of it when they fit, in proportion when they do not (F2). The k-th probe's rays
+  end at its counts' sum plus its requests' sum so scaled, rounded down, so the frame never passes the
+  budget and needs no third scan.
+- **The request** is the slot's own record, `probe_requests` (16 bytes a slot, not packed into `screen`
+  as F6 had it: the statistics below need three words). Projection writes it after every update:
+  - after a probe's first update, the most, 4·n_r² (`PROBE_RAYS_PER_TEXEL_MAX`), Enshrouded's new probe;
+  - when its light has moved, the most again;
+  - otherwise half the last request, down to the fewest.
+- **Moved.** Accumulation leaves each blended texel's fall from its mean, luminance, in its own
+  deviation and held to ±3 (`PROBE_CHANGE_SIGNIFICANCE`), in a fourth word of the maps. Projection sums
+  them over the root of their count: the update's change score. Moved is the score past 3 of the probe's
+  own running deviation (at least 1) from its own running mean, both kept over the estimator's variance
+  window, 2τ, a running mean while young. A score past their reach counts at it, so a change in the light
+  does not widen the probe's spread at once, while a lasting shift of its own is taken in within a few
+  windows. A first update clears the slot's statistics, which were the last owner's.
+- **DEAD probes** are due every period at the fewest rays (F4), not every eighth at R;
+  `PROBE_DEAD_PERIODS` is gone.
+- **Not built: F3**, weighing a sample by its rays in the estimator. It waits on a measurement.
+- **Device, Sponza, 4090,** clock at 60 Hz, the camera and the light still:
+  - false alarms, the probes past 64 updates asking for the most, 3,600 frames settled: 4.2% when the
+    change score summed the raw falls against zero, 3.2% with each texel's fall bounded, 1.1–1.3% as
+    built, against the normal tail's 0.27%;
+  - the probes up to three updates old are 11% of the alive ones (477 of 4,387) and 69–76% of them ask
+    for the most, as new probes do. That churn is the lifetime's admissions and retirements, measured in
+    §8.3, not the request's;
+  - the frame's rays, the last frame's layout of each run: 48,704–65,856, against master's U·R;
+  - trace p50 404–600 µs against master's 726–790 µs, separate processes and not paired;
+  - the noise between reads six frames apart: texels 1.25–1.49% against master's 1.23%, band 0
+    0.38–0.46% against 0.35%;
+  - the sun doubled, the alive probes' mean band 0 reaches 50%, 90% and 95% of the change in 40, 156
+    and 246 frames, against master's 42, 177 and 257;
+  - the post-load dark spell is unchanged: measured with the first build of the request, the probes
+    were resident at 17.6 s and converged at about 32–35 s, master's timeline.
+- **Storage buffers:** the ray counts pass binds 5, the ray layout 3, projection's probe pass 6.
+- Tier 2: `probe_clipmap_project.spec.js` (the most after a first update; moved past three deviations
+  and the halving to the fewest; a steady offset sips once held; a jump asks the most while it lasts; a
+  lasting shift is taken in; a new probe forgets the slot's last owner), `probe_clipmap_accumulate.spec.js`
+  (the fall in its own deviation, bounded), `probe_clipmap_schedule.spec.js` (the counts by kind, the
+  budget's proportion, DEAD every period). Each was red against the shaders before it.
+
+**As built (the probes' order, 2026-10-30): the trace list is sorted by its probes' places, and the rays
+are not sorted**, the end of `PROBE_RAYS_VARIABLE_AND_SORTED_SCOPE_2026_10_30.md` §2, where every
+measurement is.
+- **The order pass** (`shader_probe_clipmap_order.js`) runs after the update's command: a workgroup a run
+  of 1,024 listed probes (`PROBE_ORDER_RUN`, through `PROBE_DISPATCH_ORDER` over the live count) sorts
+  its run in place by the cascade above the Morton code of the probe's lattice point in the cascade's
+  window, with the bitonic workgroup sort (`chunk_sort_bitonic_workgroup`). Every pass after it reads a
+  probe's place from the sorted list, so neighbouring probes' rays run in neighbouring waves. Past one
+  run, the list is ordered within each run.
+- **Why not the rays.** A wave already holds one probe's rays walking its texels in rows. Every ray sort
+  measured costs more than it buys: global radix keys, local sorts by direction (8×8 or 4×4 bins, chunks
+  of 2,048 to 512), within each probe, and position bits above the bin. On the iGPU at 131k rays the
+  local sorts lose 4–22%, a hash-keyed control 29–57% of the trace. The 4090 is level throughout.
+- **Device:** iGPU 1–4% off the rays' stretch at 131k rays in most batches, the 4090 level; the pass
+  costs 11.8 µs on the 4090. Storage buffers: 3.
+- Tier 1: the validity spec. Tier 2: `probe_clipmap_schedule.spec.js` (a workgroup a run, up to U). Tier
+  3: `GPUProbeClipmap.spec.js` (the pass after the update's command, through its command). The sort
+  itself runs workgroup barriers the emulator cannot, so the device checks it: each run ordered and a
+  permutation of the list.
+
 ### 8.7 Hit shading
 
 **shade**: one thread per ray.
@@ -1984,14 +2862,17 @@ The three irradiance terms of a HIT:
 - **E_loc** comes from the world light clusters at the hit, generalised to this mode's brick levels
   so that every hit position has a cell.
   - At most 32 lights, `IRRADIANCE_CLIPMAP_LIGHT_BUDGET`'s value. Past that, lights are dropped.
-  - Each light goes through `irradiance_clipmap_get_{point,spot}_light_info_by_index`, with shadow
-    from `volumetrics_{point,spot}_light_shadow`.
-  - A light whose shadow map is cleared lights hits unshadowed, which is a stated limit.
+  - Each light goes through `irradiance_clipmap_get_{point,spot}_light_info_by_index`. One of them is
+    picked by WRS on its luminance there and divided by the chance of the pick; its shadow is a ray
+    traced in the bricks (as built 2026-10-30, below). Until then each light was summed, its shadow from
+    `volumetrics_{point,spot}_light_shadow`, and a light whose shadow map was cleared lit hits
+    unshadowed.
 - **E_ind** is this mode's own diffuse sampling (§9.2) at the hit, with last frame's SH: the next
   bounce.
   - 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).
@@ -2001,7 +2882,7 @@ The three irradiance terms of a HIT:
 
 **As built (S4d, 2026-10-28)**, `probe/shader_probe_clipmap_shade.js`, a thread a ray after trace
 through the same command:
-- **Its radiance goes over the ray's light**, three half floats: no buffer of its own. With one, shade
+- **Its radiance goes over the ray's light** (RGB9E5 since 2026-10-30): no buffer of its own. With one, shade
   would bind eleven storage buffers, past the ten a stage has (§12): the rays, the origins, the trace
   list, the scene database, the texture means, the SDF headers and indirection, the card sets, the card
   rows, and the radiance. In place it binds nine.
@@ -2041,16 +2922,158 @@ 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.
+
+**As built (2026-10-30), shadow rays at hits.** Alex: a shadow map is made for the main view, so where rays
+reach it is wrong in most places, and the sun's cone soft shadow is made in another domain than the rays',
+so it is bound to leak light and shadow. Both are traced now, through the bricks the hit's own ray met:
+- **The sun**, in the trace pass: for each of the first `PROBE_SHADOWED_SUNS` lights that cast shadows, one
+  ray from a voxel off the hit along its normal toward a point of the light's disk, drawn as the path
+  tracer draws it (`cone_sample_direction`), from `pcg3d` of the ray's slot and packed direction and the
+  light's place among the shadowed. The sun is seen whole if the ray misses, not at all if it hits or
+  spends its steps. The probe's blend of its rays integrates the penumbra.
+- **The local lights**, in the light pass: one of the cell's point and spot lights, picked by weighted
+  reservoir sampling over their luminance at the hit, with one number stretched over the candidates as
+  `sample_discrete_wrs` does. The pick lights the hit by its irradiance over the chance of its pick, w/W,
+  so the probe's blend averages the picks to the cell's sum. Its shadow is one ray from a voxel off the
+  surface toward a point of the light's sphere (`sphere_sample_volume`, as the path tracer), stopping short
+  of it by the light's near clip or a voxel, whichever is more: the field's half-voxel expand at that end,
+  as the lift is at the other. A light that casts no shadow traces none. The pick and the point are
+  `pcg4d` of the ray's slot and direction, apart from the origin's draw.
+- What a ray cannot answer is no light, not all of it: a march that spends its steps shadows.
+- The light pass binds the brick textures in place of the shadow atlas, the same 8 storage buffers. The
+  GI no longer reads the shadow maps, and the renderer no longer hands it their atlas.
+- `brick_clipmap_soft_shadow` is deleted with its specs; nothing else called it.
+- **Cost**, paired on Sponza at 1280×720 (the sun and the playground's 8 shadowed point lights along the
+  nave; HEAD's passes and these in blocks of 4 frames, ABBA, each block's first frame dropped), p50:
+
+  | | 4090 | iGPU |
+  |---|---:|---:|
+  | trace (the sun) | 364.5 against 415.7 µs | 9.01 against 9.25 ms |
+  | light (local lights) | 43.0 against 28.7 µs | 3.38 against 2.43 ms |
+  | shade, unchanged, the clock's check | ×1.000 | ×0.995 |
+
+  A hit ray stops at its first occluder, where the cone estimate marched on into the umbra, so the sun
+  costs less. One traced ray in the light pass costs more than reading every light's map. On the iGPU the
+  two together are 0.72 ms a frame more.
+- Tier 2:
+  - `probe_clipmap_trace.spec.js`: under a slit 0.5 m wide in a roof, a sun of 0.25 rad, 128 probes'
+    rays each see the whole sun or none, and on average 0.258 of it against the 0.327 of the disk the
+    slit lets through, computed on the CPU with the walls standing out half a voxel (1,024 rays read
+    0.295: the bricks round the slit's corners). The cone estimate read 0.675 there.
+  - `probe_clipmap_light.spec.js`, over bricks built from boxes: a slab between a point light and the
+    hit shadows it, the floor under the hit and a slab past the light do not, and a light that casts no
+    shadow is lit through the slab; a slab shadows a spot; a light 3 cm under a ceiling lights 16 hits
+    from under it to 4 m out; over 256 rays at one hit, each ray is one of four lights over the chance of
+    its pick, each light picked within four sigma of its share, and the mean is their sum.
+  - Red against HEAD's passes, its light pass given a cleared atlas, as a light never drawn has: the
+    slab between the point light and the hit lit it, so did the slab over the spot, and every ray was the
+    four lights' sum.
+- Mutants: 11 of 11 killed: no division by the pick's chance; the first light always; the number not
+  stretched; the ray to the light's point, or short of it by its near clip only; from the surface, not
+  a voxel off it; a light's no-shadow flag ignored; a hit counted as light, for the sun and the local
+  light; the sun's disk centre alone; one draw for every probe.
+
 ### 8.8 Update
 
 **accumulate**: one workgroup per traced probe.
 - **Blend weight**: α = 1 on the first update. After that, α = max(1/(n+1), 1 − e^(−Δt/τ)), with Δt
   the seconds since the probe's previous update and τ = `response_time` (default 0.5 s).
   - DDGI's 0.97 a frame at 60 fps is τ = 0.55 s.
+  - As built (2026-10-30): Δt is the frames since the update and τ = `response_frames` (default 30), §8.2.
 - **Radiance**: each texel hit this update takes the mean of its rays, blended with its history.
   The history is read from the atlas through a sampled binding.
-- **Depth**: each depth texel takes the moments of the rays landing in it (a miss counts as √3),
-  blended the same way.
+- **Depth**: each depth texel takes the moments of the rays landing in it (a miss counts as the
+  depth limit, D9), blended the same way.
 - Texels without a ray keep their history; so does an unresolved ray's texel.
 - **The transient holds the probe's whole maps**, new texels and kept ones: n_r² × 8 B + n_d² × 4 B
   per traced probe, 1.2 MiB for U = 512. `publish` cannot read the atlas it writes, and it needs
@@ -2082,10 +3105,61 @@ a per-invocation function instead. Each is tier 2 whole, and no thread's loop ru
     between a texel's rays (n_r²/R below a ray a texel). Below a ray a texel, a texel's first ray is
     then taken whole whenever it comes, which the probe's count would get wrong. Depth blends by the
     probe's α.
+  - **The radiance is a multi-scale mean since 2026-10-29** (D11; `shader/chunk/filter/chunk_multiscale_mean.js`):
+    the texel's sample feeds Enshrouded's estimator. Its state past the mean is a slot's n_r² ×
+    16 B in `probe_estimators` (short mean, deviation, blend reduction, inconsistency, as halves
+    rounded stochastically): 4 KiB a slot at n_r = 16.
+    - The short mean blends by the α above, its variance by the same with 2τ. The mean takes at least
+      1/(a+1) until the count's cap, so a young texel is its running mean; the estimator's blend
+      reduction starts at nothing and would otherwise hold a new probe on its first ray.
+    - **The blend reduction follows by the reference's 0.1 a sample** (fixed 2026-10-29), not by the short
+      blend as first built. The catch-up takes the last sample's reduction. Once samples are a response
+      time apart, the short blend is 1 − 1/e, the reduction tracked each sample, and the long mean fell back
+      fastest from the bright ones. Measured on the emulator over samples of mean 1 and deviation 1, at
+      short blends of 0.55, 0.63, 0.78 and 0.9:
+      - the texel settled 7, 18, 28 and 39% low;
+      - at 0.1 a sample, 2, 3, 7 and 15%, with the same step response.
+
+      A texel the guide passes over has a short blend of 0.63 at 60 Hz with a period of 6 frames. At
+      15 fps, every texel's short blend is past 0.55. At the short blend of 0.18 that the table below ran
+      at, the fix moves nothing (error 13.9 → 14.0%, update to update 0.69 → 0.70%), and that table was
+      not measured again.
+    - The firefly clip, `0.1 + short + 8·deviation`, waits until 1/(a+1) is no longer the variance's
+      blend. Its 0.1 is the reference's, in radiance units; on Sponza under a sun of 7.2 a texel's
+      luma is under 0.26 at p99, so it clips only far outliers there.
+    - Measured on Sponza, the camera still, 4090 (`scratchpad/device/msme.js`, 2026-10-29):
+
+      | τ | texel change an update | band 0 change | 50% / 90% of a doubled sun | 50% / 90% of its halving |
+      |---|---|---|---|---|
+      | 0.5 s, before | 10.8% | 1.54% | 29 / 105 frames | 29 / 102 |
+      | 0.5 s | 1.0% | 0.27% | 55 / 389 | 54 / 212 |
+      | 0.25 s, before | 20.5% | 3.0% | 17 / 79 | 17 / 77 |
+      | 0.25 s | 5.0% | 1.24% | 23 / 234 | 24 / 99 |
+      | 0.125 s | 26% | 4.9% | 19 / >390 | 6 / 37 |
+
+      The screen's diffuse barely moved: a frame against the last at the same point, 4.72% → 4.66% of
+      all eight corners and 16.1% → 15.8% of the pick, still; 9.4% → 9.0% orbiting. The SH averages
+      a probe's texels, so what changes a still frame's diffuse is not the probes' radiance.
+    - Cost, the old pass beside the new in the same frames, which goes first alternating: 4090 15–16
+      against 13 µs; AMD iGPU 860–1,264 against 337–523 µs, 2.0–2.5×. A twin with the estimator's
+      arithmetic replaced by a plain blend costs what the shipped pass does: the time is the state's
+      load and store, not the estimator. Run order moves the iGPU's figures by 2×, so the split
+      between loading and packing the state is not settled.
   - **A new probe's history is its slot's last owner's**: on its first update a texel no ray reached is
-    cleared, radiance to nothing and depth to a miss's moments (√3, 3).
-  - Depth samples, in spacings: a miss √3, a back face 0.2·t, a hit t, each held to √3. A depth texel
+    cleared, radiance to nothing and depth to a miss's moments (L, L²), L the depth limit (D9).
+  - Depth samples, in spacings: a miss L, a back face 0.2·t, a hit t, each held to L. A depth texel
     gathers R/n_d² rays, so the GI refuses R > 64·n_d².
+  - **Since ray guiding (2026-10-29, §8.6)**: on a guided update a texel's rays are its run in the guide.
+    Its mean needs no weight for the guide's choice, since its rays spread evenly over it.
+    - p is one over the share of updates that reach the texel, averaged over the uniform period:
+      (min(R/n_r², 1) + (P − 1)·min(R·pdf, 1))/P. A texel the guide passes over then blends what the
+      uniform updates bring as fully as its rarity asks, and the response stays τ.
+    - A guided depth texel is the mean of its radiance texels' own means, taken only when every one of
+      them took rays. A plain mean would lean to the brighter ones' depths, and so would a mean over
+      only the lit ones. Its period counts a uniform update as reaching it, and a guided one as often
+      as its least reached radiance texel.
+    - Classification takes only uniform rays: a guided update keeps the kind and the back-face share,
+      since guided rays shun back faces (§8.4).
 - **the projection** (`probe/shader_probe_clipmap_project.js`): a thread a row of a probe's radiance
   map sums its texels as `convert_to_irradiance_sh(L, ω)·dω/(2π)` and its rays' counts; then a thread a
   probe sums its rows into the record's SH, its back-face share, its time, and its state: dead past a
@@ -2117,6 +3191,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 +3250,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 +3296,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 +3329,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 +3374,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 +3387,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 +3544,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:
@@ -2266,7 +3649,7 @@ the shadow knobs' pattern.
 - **The mesh cache fields** (`mesh_sdf_voxel_size`, `mesh_sdf_max_bricks`): a change rebakes every
   cached geometry.
 - **Budgets and times** (`brick_build_budget`, `mesh_sdf_bake_budget`, `card_capture_budget`,
-  `rays_per_probe`, `ray_budget`, `response_time`, `retention_time`): uniforms and transient sizes, so
+  `rays_per_probe`, `ray_budget`, `response_frames`): uniforms and transient sizes, so
   they take effect the next frame without a rebuild.
 
 | Setting | Default | Range | Changes |
@@ -2286,8 +3669,9 @@ the shadow knobs' pattern.
 | `depth_resolution` | 8 | 4–32, power of two | octahedral depth texels per side |
 | `rays_per_probe` | 256 | a power of two in [n_r²/4, 4·n_r²] | rays per probe update; below n_r² an update covers a spread subset of texels, above it each texel averages several |
 | `ray_budget` | 131,072 | ≥ `rays_per_probe` | rays per frame (a time knob) |
-| `response_time` | 0.5 s | > 0 | temporal time constant τ |
-| `retention_time` | 1 s | > 0 | how long an unwanted probe keeps its slot |
+| `response_frames` | 30 | > 0 | the radiance's short mean's time constant τ in frames (§8.8), and the depth's blend's |
+
+`retention_time` (1 s) was removed on 2026-10-30: probes are evicted by the pressure on the slots (§8.3).
 
 The defaults:
 - They sit between Enshrouded's low and mid tiers (100k and 250k rays; radiance 8 and 16).
@@ -2300,7 +3684,8 @@ The defaults:
 - the size-class step of two bricks;
 - the hit threshold and minimum step, ½ voxel;
 - 64 steps a ray;
-- 64 instances per cell in the mesh provider, 256 triangles per cell in the vgeo provider;
+- the mesh provider's 64 rows a batch and 512 nodes a level of a walk, past which the work goes on in more
+  batches and rounds (S9);
 - 32 cards per geometry, and 4 alpha continuations per capture texel;
 - the 2³-texel object cell;
 - 2 probes per pick;
@@ -2381,6 +3766,8 @@ specs. A real compile on a device catches what the validator misses.
   - The soft-shadow penumbra matches the analytic disk light at a sphere's edge.
     - As built (S3e): against the disk past the surface the tracer hits, half a voxel out, within 0.1;
       half at the edge within 0.1.
+    - Since 2026-10-30 the hits' shadows are rays: under a slit narrower than the sun's disk, each ray
+      sees all of the sun or none, and their mean the part of the disk the slit lets through (§8.7).
   - `mesh_card_surface`: a hit on a card's surface returns that texel's diffuse albedo and emissive,
     and a hit hidden from every card returns the material mean.
 - **Probes**:
@@ -2395,7 +3782,7 @@ specs. A real compile on a device catches what the validator misses.
   - The cascade blend is continuous across the skirt.
   - `resolve_irradiance_sh_to_specular` at g₁ = 2/3 equals `resolve_irradiance_sh_to_diffuse`, and
     returns L under constant radiance L at every α.
-- **Extracted pieces** (probe weight, pick, hash, soft-shadow estimator, free-list pop/push): their
+- **Extracted pieces** (probe weight, pick, hash, free-list pop/push): their
   old callers' specs stay green. LPV's and Brick4's sampling are unchanged to the bit.
 
 **Tier 3, SoftwareGPUDevice**: host orchestration, black-box on what reaches the device.
@@ -2430,6 +3817,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.
@@ -2444,7 +3963,8 @@ Each stage lands suite-green and is measured before the next.
 | S5 | next bounce (E_ind); local lights via generalised world clusters; the forward, water, SSR-hit and irradiance-clipmap alternatives | furnace (multi-bounce), Cornell vs path tracer |
 | S6 | specular: radiance ⊕ GGX-SH2, parallax, fused pass, SSR fallback, forward and water specular | parallax A/B, reflections in a closed room |
 | S7 | the virtual geometry provider: box cut, streaming invalidation | Zorah lit by its own geometry; timings |
-| S8 | measured follow-ups only (§17) | — |
+| S8 | virtual geometry's caches per geometry (Alex, 2026-10-29): a proxy cut from each, baked by the mesh path, adopted; the per-cell provider deleted; then measured follow-ups only (§17) | Zorah's holes, back faces and dead probes against S7e's and Sponza's; the frames and cost of the bake; the frame at rest |
+| S9 | the mesh provider without its cap (Alex, 2026-10-29): walks that hand on what they cannot hold, batches of 64 spread over workgroups by count, an atomic merge, the resolve on the cells the walks listed; contract 7, retry | Zorah's holes against S8's; the provider's cost on both GPUs, paired with S8's |
 
 ## 14. Decisions taken here
 
@@ -2470,8 +3990,8 @@ Each says what would reverse it.
   - A hit does no material work.
   - *Reverse:* none of mine; Alex chose it over cards that hold uvs.
 - **D6. No triangle is read per frame.** Meshes are read at bakes (the SDF, per geometry) and at
-  captures (the cards, per pair and per material change). The vgeo provider reads its cut per
-  requested cell, never per frame. *Reverse:* none; it is the review's rule.
+  captures (the cards, per pair and per material change). A virtual geometry's cut is read once, for
+  its proxy's bake (S8), never per frame. *Reverse:* none; it is the review's rule.
 - **D7. Hits are diffuse only: `L = emissive + ρ_d·E/π`.**
   - That is what Lumen's payload holds, and Lumen's surface cache lights diffusely too.
   - (b) first had the full BRDF's directional albedo at the hit's NoV (`tSplitSum`), which needed
@@ -2481,22 +4001,44 @@ Each says what would reverse it.
     of the diffuse one. That needs the same storage and no hit-side change.
 - **D8. Radiance `rgba16float`, two-pass update.** Hardware bilinear for every consumer.
   *Reverse:* if the stall bias measures visible, f32 history in a buffer.
-- **D9. Depth moments normalised by spacing, clamped at √3·s.**
+- **D9. Depth moments normalised by spacing, clamped at (1 + 0.45)·√3·s.**
+  - Chebyshev's bound asks only how many samples lie past the point, which a clamp past every point the
+    cage tests leaves as it was, and a larger clamp only loosens it. The clamp is one constant, so a
+    reader de-normalises with the spacing alone.
+  - **Corrected 2026-10-30**: it was √3·s, the cage diagonal, which holds only for a probe on its
+    lattice point. Relocation (§8.4) moves a probe up to 0.45 of a spacing on each axis, so a biased
+    point can be (1 + 0.45)·√3 ≈ 2.51 spacings from a corner probe. A direction that sees nothing read as
+    occluded past √3: visibility ≤ 0.41 at 1.8 spacings, 0.043 at 2.0. Over a cell, a corner moved 0.45
+    on every axis away from it lost up to 0.70% of the cage's trilinear weight; 0.25 on each, 0.013%.
+  - RTXGI clamps at `1.5·|spacing|` (`ProbeBlendingCS.hlsl`), the same reach over DDGI 2021's
+    half-spacing relocation bound; neither DDGI paper's text gives a value. RTXGI's own relocation is a
+    sphere of 0.45, so its clamp has headroom.
 - **D10. SH2 projected from blended radiance, not blended separately.**
-- **D11. Exponential blend over a response time in seconds; jittered stratified rays.**
+- **D11. Radiance by a multi-scale mean whose short mean follows a response time in seconds; depth
+  by an exponential blend; jittered stratified rays.**
   - Lumen overwrites without jitter, but its screen probes filter downstream. Here consumers read
     the probes directly.
   - DDGI 2021's per-texel change boost is left out. A texel here sees one ray an update, so a change
     test on it is a noise test.
-  - *Reverse:* if noise or lag measures visible at the defaults, Enshrouded's moving-average
-    estimator, which is the variance-aware form of that boost.
+  - **Reversed for the radiance, 2026-10-29**: Alex judged the noise visible, and Enshrouded's
+    estimator (RT Gems ch. 25) was built (§8.8, as built). Measured on Sponza at τ = 0.5 s: a texel
+    moves 1.0% an update against 10.8%, the SH's band 0 0.27% against 1.54%; a doubled sun is half
+    taken in 55 frames against 29, and 90% in 389 against 105.
+  - A variant testing the means' gap against the short mean's own deviation, as SSR's accumulation
+    does, was modelled on the CPU and followed a step on a noisy texel more slowly still; not built.
+  - **The rays' half reversed too (2026-10-29).** Alex found the probes' noise visible, and asked for
+    Enshrouded's importance-sampled rays, rotating corner and all (§8.6, as built). The estimator's short
+    mean now takes a texel's period from its share of the updates that reach it (§8.8).
 - **D12. Schedule: NEW first, then a slot-hashed phase with a period from the live count.**
 - **D13. Pixels pick 2 of 8 by WRS after visibility-only weights** (the review). Brick4's sampler and
   noise. *Reverse:* if the measured noise under TAA is visible, then a screen-space reservoir resolve,
   argued from that measurement.
-- **D14. Sun shadows at hits by SDF soft-shadow rays.** Shadow maps read lit off screen.
-- **D15. Local lights from the world clusters with the shadow-atlas lookups.** A light with a
-  cleared map is unshadowed at hits.
+- **D14. Sun shadows at hits by shadow rays traced in the bricks**, toward a point of the disk.
+  Shadow maps read lit off screen; the cone soft shadow S3e built leaked through gaps narrower than
+  the disk, and was replaced on 2026-10-30 (§8.7).
+- **D15. Local lights from the world clusters, one picked by WRS over the chance of its pick, its
+  shadow a ray traced in the bricks** (2026-10-30, §8.7). Until then every light of the cell, each
+  through its shadow map, a light with a cleared map unshadowed at hits.
 - **D16. Settings sub-object, rebuild on mismatch.**
 - **D17. Capacity learned from reported failures, never shrinks.**
 - **D18. The mode is named `ProbeClipmap`**, after what shading samples, as Brick4 and LPV are.
@@ -2555,6 +4097,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,8 +4167,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.
 - Foliage and translucency in the field, Enshrouded's open problem too.