@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/global_illumination/probe/octahedral/graph_lpv_shade.js

@@ -5,7 +5,7 @@ import { chunk_taa_decode_color } from "../../../postprocess/taa/chunk_taa_decod
 import { chunk_taa_encode_color } from "../../../postprocess/taa/chunk_taa_encode_color.js";
 import { chunk_BRDF_GGX } from "../../../shader/chunk/brdf/chunk_BRDF_GGX.js";
 import { chunk_oren_nayar_compensated_diffuse } from "../../../shader/chunk/brdf/diffuse/EON.js";
-import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_F_Schlick } from "../../../shader/chunk/brdf/fresnel/chunk_F_Schlick.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
 import {
@@ -122,7 +122,7 @@ fn lpv_shade_light_record(
 
     let light_irradiance = light_record.emission * NoL;
 
-    let F = F_Hauber(specularF0, specularF90, VoH);
+    let F = F_Schlick(specularF0, specularF90, VoH);
     let kD = (vec3(1.0) - F);
 
     let irradiance_diffuse = light_irradiance * diffuse_color * kD;
@@ -320,7 +320,7 @@ fn main(
         chunk_uv_octahedral_unit_encode,
         chunk_uv_to_texel_coordinate,
         chunk_v2_bilinear_weight,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
     ]
 );
 

package/src/shade/renderer/global_illumination/probe/octahedral/graph_sample_light_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_sample_light_probes.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/graph_sample_light_probes.js"],"names":[],"mappings":"AA6MA;;;;;;;;;;;;;GAaG;AACH,0OA4CC"}
+{"version":3,"file":"graph_sample_light_probes.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/graph_sample_light_probes.js"],"names":[],"mappings":"AAiNA;;;;;;;;;;;;;GAaG;AACH,0OA4CC"}

package/src/shade/renderer/global_illumination/probe/octahedral/graph_sample_light_probes.js

@@ -17,6 +17,7 @@ import {
 import {
     chunk_lpv_mask_weights_by_visibility
 } from "../../../shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../../../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
 import { chunk_compute_indirect_specular } from "../../../shader/chunk/material/chunk_compute_indirect_specular.js";
 import { chunk_metalness_to_specular_color } from "../../../shader/chunk/material/chunk_metalness_to_specular_color.js";
 import { chunk_v3_is_nan } from "../../../shader/chunk/math/chunk_is_nan.js";
@@ -155,6 +156,8 @@ fn main(
         view_direction,
         diffuse,
         specularF0,
+        vec3(MIN_DIELECTRICS_F0),
+        albedo,
         specularF90,
         roughness
     );
@@ -176,6 +179,7 @@ fn main(
         RAY_STRUCT.declaration_chunk,
         LPV_SAMPLE_COORDINATES.declaration_chunk,
         chunk_metalness_to_specular_color,
+        chunk_MIN_DIELECTRICS_F0,
         chunk_grid2d_to_index,
         chunk_lpv_mesh_lookup_nearest_cell,
         chunk_lpv_sample_light,

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_radiance_sample_reflection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,mDAFU,SAAS,CA+ClB;0BAxDyB,0CAA0C"}
+{"version":3,"file":"chunk_lpv_radiance_sample_reflection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,mDAFU,SAAS,CA+ClB;0BAzDyB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js

@@ -4,6 +4,7 @@ import { chunk_lpv_atlas_sample_probe_radiance } from "./chunk_lpv_atlas_sample_
 import {
     chunk_parallax_correct_spherical_probe_iterative
 } from "./chunk_parallax_correct_spherical_probe_iterative.js";
+import { LPV_PROBES_RESOURCE } from "../LPV_SHADER_RESOURCE_GROUP.js";
 
 
 /**
@@ -56,3 +57,5 @@ fn lpv_radiance_sample_reflection(
         chunk_f32_array_as_vec3,
     ]
 )
+
+chunk_lpv_radiance_sample_reflection.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_resolve_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js"],"names":[],"mappings":"AA8GA,2DAyBE;4BA3H0B,0BAA0B"}
+{"version":3,"file":"shader_resolve_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js"],"names":[],"mappings":"AAkHA,2DAyBE;4BA9H0B,0BAA0B"}

package/src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js

@@ -2,6 +2,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
 import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
 import { BSDF_ROUGHNESS_MINIMUM } from "../light/environment/DEFINES.js";
 import { chunk_compute_specular_occlusion_bn } from "../shader/chunk/brdf/chunk_compute_specular_occlusion_bn.js";
+import { chunk_MIN_DIELECTRICS_F0 } from "../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
 import { chunk_project_position_from_depth } from "../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
@@ -82,6 +83,8 @@ fn main(
         view_direction,
         material_color_diffuse,
         material_specularF0,
+        vec3(MIN_DIELECTRICS_F0),
+        albedo,
         material_specularF90,
         roughness,
     );
@@ -104,6 +107,7 @@ fn main(
         chunk_decode_g_buffer_metalness,
         chunk_decode_g_buffer_roughness,
         chunk_metalness_to_specular_color,
+        chunk_MIN_DIELECTRICS_F0,
         chunk_compute_specular_occlusion_bn,
     ]
 );

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.d.ts

@@ -0,0 +1,10 @@
+/**
+ * {@link BVH_REFIT_DEFERRED_LAYOUT} as WGSL constants: the seed a bound word holds until it is
+ * fitted, and the deferred list's layout. One declaration shared by the climb, the repair and the
+ * kernels that seed, for the reason {@link BVH_NODE_LAYOUT_DEFINITION} is one.
+ *
+ * @type {CodeChunk}
+ */
+export const BVH_REFIT_DEFERRED_DEFINITION: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=BVH_REFIT_DEFERRED_DEFINITION.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH_REFIT_DEFERRED_DEFINITION.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,4CAFU,SAAS,CAUhB;0BAxBuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    BVH_REFIT_DEFERRED_COUNT_WORD,
+    BVH_REFIT_DEFERRED_ENTRIES_WORD,
+    BVH_REFIT_DEFERRED_ENTRY_WORDS,
+    BVH_REFIT_REPAIR_WORKGROUP_SIZE,
+    BVH_UNFITTED
+} from "./BVH_REFIT_DEFERRED_LAYOUT.js";
+
+/**
+ * {@link BVH_REFIT_DEFERRED_LAYOUT} as WGSL constants: the seed a bound word holds until it is
+ * fitted, and the deferred list's layout. One declaration shared by the climb, the repair and the
+ * kernels that seed, for the reason {@link BVH_NODE_LAYOUT_DEFINITION} is one.
+ *
+ * @type {CodeChunk}
+ */
+export const BVH_REFIT_DEFERRED_DEFINITION = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH_UNFITTED = ${BVH_UNFITTED}u;
+const BVH_REFIT_DEFERRED_COUNT = ${BVH_REFIT_DEFERRED_COUNT_WORD}u;
+const BVH_REFIT_DEFERRED_ENTRIES = ${BVH_REFIT_DEFERRED_ENTRIES_WORD}u;
+const BVH_REFIT_DEFERRED_ENTRY_WORDS = ${BVH_REFIT_DEFERRED_ENTRY_WORDS}u;
+const BVH_REFIT_REPAIR_WORKGROUP_SIZE = ${BVH_REFIT_REPAIR_WORKGROUP_SIZE}u;
+`);

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bytes a deferred list needs for climbs over `internal_node_count` internal nodes. A node is
+ * deferred at most once — only its second arrival reads its children — so that many entries is
+ * the most there can be. Memory, not work: the repair dispatches over the count the climb wrote.
+ *
+ * @param {number} internal_node_count
+ * @returns {number}
+ */
+export function bvh_refit_deferred_byte_size(internal_node_count: number): number;
+/**
+ * The bit pattern a node's bound words hold between being seeded and being fitted: a quiet NaN that
+ * no union of real bounds produces.
+ *
+ * Whatever runs a refit climb ({@link chunk_bvh_refit_climb}) seeds every bound word the climb will
+ * read with this, in an earlier dispatch. The climb hands boxes between invocations through relaxed
+ * atomics, and a store need not have reached the invocation that reads it. A read of a seeded word
+ * then returns either the store or the seed — never a box from before the seed, because the seeding
+ * dispatch ended first. So a box that has not arrived is a box the climb can see is missing.
+ *
+ * @type {number}
+ */
+export const BVH_UNFITTED: number;
+/**
+ * Where a node the climb deferred goes: `[command x, y, z, count, entries...]`, one buffer.
+ *
+ * The first three words are the repair's indirect dispatch command, folded as the engine's command
+ * builders fold one (x filled to the per-dimension limit before y grows), written by the climb as it
+ * defers. Word 3 counts the entries. Each entry is three words: the tree's `node_word_offset`, its
+ * `parents_offset`, and the node — so one repair serves trees that own their buffers and trees that
+ * are tenants in an arena.
+ *
+ * The header must be zero when the climb starts; the entries need not be anything.
+ */
+export const BVH_REFIT_DEFERRED_COUNT_WORD: 3;
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRIES_WORD: 4;
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRY_WORDS: 3;
+/**
+ * The header, which is all that needs clearing before a climb.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_DEFERRED_HEADER_BYTES: number;
+/**
+ * Threads per workgroup of the repair, and so entries per workgroup the climb counts into the command.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_REPAIR_WORKGROUP_SIZE: number;
+//# sourceMappingURL=BVH_REFIT_DEFERRED_LAYOUT.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH_REFIT_DEFERRED_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.js"],"names":[],"mappings":"AAmDA;;;;;;;GAOG;AACH,kEAHW,MAAM,GACJ,MAAM,CAKlB;AA9DD;;;;;;;;;;;GAWG;AACH,2BAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;GAUG;AACH,8CAA+C;AAE/C;;GAEG;AACH,gDAAiD;AAEjD;;GAEG;AACH,+CAAgD;AAEhD;;;;GAIG;AACH,8CAFU,MAAM,CAE+F;AAE/G;;;;GAIG;AACH,8CAFU,MAAM,CAEkC"}

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.js

@@ -0,0 +1,63 @@
+/**
+ * The bit pattern a node's bound words hold between being seeded and being fitted: a quiet NaN that
+ * no union of real bounds produces.
+ *
+ * Whatever runs a refit climb ({@link chunk_bvh_refit_climb}) seeds every bound word the climb will
+ * read with this, in an earlier dispatch. The climb hands boxes between invocations through relaxed
+ * atomics, and a store need not have reached the invocation that reads it. A read of a seeded word
+ * then returns either the store or the seed — never a box from before the seed, because the seeding
+ * dispatch ended first. So a box that has not arrived is a box the climb can see is missing.
+ *
+ * @type {number}
+ */
+export const BVH_UNFITTED = 0x7FC0FFEE;
+
+/**
+ * Where a node the climb deferred goes: `[command x, y, z, count, entries...]`, one buffer.
+ *
+ * The first three words are the repair's indirect dispatch command, folded as the engine's command
+ * builders fold one (x filled to the per-dimension limit before y grows), written by the climb as it
+ * defers. Word 3 counts the entries. Each entry is three words: the tree's `node_word_offset`, its
+ * `parents_offset`, and the node — so one repair serves trees that own their buffers and trees that
+ * are tenants in an arena.
+ *
+ * The header must be zero when the climb starts; the entries need not be anything.
+ */
+export const BVH_REFIT_DEFERRED_COUNT_WORD = 3;
+
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRIES_WORD = 4;
+
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRY_WORDS = 3;
+
+/**
+ * The header, which is all that needs clearing before a climb.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_DEFERRED_HEADER_BYTES = BVH_REFIT_DEFERRED_ENTRIES_WORD * Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Threads per workgroup of the repair, and so entries per workgroup the climb counts into the command.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_REPAIR_WORKGROUP_SIZE = 64;
+
+/**
+ * Bytes a deferred list needs for climbs over `internal_node_count` internal nodes. A node is
+ * deferred at most once — only its second arrival reads its children — so that many entries is
+ * the most there can be. Memory, not work: the repair dispatches over the count the climb wrote.
+ *
+ * @param {number} internal_node_count
+ * @returns {number}
+ */
+export function bvh_refit_deferred_byte_size(internal_node_count) {
+    return (BVH_REFIT_DEFERRED_ENTRIES_WORD + internal_node_count * BVH_REFIT_DEFERRED_ENTRY_WORDS)
+        * Uint32Array.BYTES_PER_ELEMENT;
+}

package/src/shade/renderer/gpu_primitive/bvh/GPU_BVH_BUILD_PLAN.md

@@ -554,6 +554,9 @@ bounds from the CPU tree, whose copy for a GPU-authority row can be arbitrarily
 reason this build reads the `meshes` table. The one thing `N == 1` actually needed was a counters
 buffer WebGPU will accept, so it is sized `max(1, N-1)`.
 
+**[addition, 2026-10-16]** Up to one sort tile of leaves (1,024), these passes are one
+dispatch of one workgroup, with the same output word for word. See §4.7.
+
 ### 4.2.1 The sort — `gpu_primitive/sort/`, rebuilt around CSDLDF
 
 Commit `b6049214c` cleared the ground; this project re-founds the directory with one blessed
@@ -766,6 +769,246 @@ toward it.
 - Known, documented, temporary quality dip vs the treelet-optimised CPU tree (raw LBVH SAH cost is
   worse; phase 2 exists to close exactly this). The flag stays available until phase 2's gate.
 
+### 4.7 The single-workgroup path for small builds — landed 2026-10-16
+
+**Why.** Over a few hundred leaves every one of the 19 dispatches is nearly empty, so a rebuild
+costs 19 times a dispatch's fixed overhead. On the RTX 4090 that is ~73 µs at any count up to a
+tile (below). A consumer that rebuilds per spawn or despawn pays it every time. The GPU fluid
+(`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md` §10/§14) rebuilds a tree over effector and obstacle
+boxes every frame. The TLAS gets the path automatically for small scenes. The engine has no
+"typical" scene, but most scenes have few elements. So this is a fast path keyed on the runtime
+count, and the multi-pass build stays first-class above it.
+
+**What.** `graph_bvh_build_lbvh` records one dispatch of one workgroup,
+`shader_bvh_build_single_workgroup`, when `element_count <= SORT_TILE_SIZE` (256 × 4 = 1,024,
+`sort/defs.js`). Above that, the multi-pass recording is unchanged. The shader runs the four phases
+inside one workgroup, fenced by barriers:
+
+1. **Morton.** Each of the 256 threads takes four leaves, striped. Each leaf's code goes into
+   workgroup `keys` and its index into `values`.
+2. **Sort.** A bitonic network in workgroup memory, `chunk_sort_bitonic_workgroup`, ordered by
+   (code, leaf index). Seeding each value with its leaf index makes that a stable sort by code,
+   which is exactly the radix sort's order, so the permutation matches it word for word. The
+   network spans the next power of two of `n`, padded with the largest pair. It is
+   `log2(P)(log2(P)+1)/2` steps of one barrier each: 10 at 16 leaves, 55 at 1,024. The scatter's
+   own in-tile sort (stable binary splits, `chunk_sort_rank`) would fit in the memory too, but a
+   30-bit key is 30 rounds of a ~15-barrier workgroup scan at any count, about 450 barriers.
+3. **Emission**, as `shader_bvh_emit_hierarchy` does it. The sorted keys and leaf order are
+   published to the same transients the multi-pass build returns. Node words are stored
+   atomically, because the refit reads them atomically.
+4. **Refit** with the multi-pass climb, `chunk_bvh_refit_climb`, unchanged. Counters and node
+   words stay storage atomics, as there. The arrival counters are a transient the shader zeroes
+   itself, so the descriptor needs no clear. They are not workgroup atomics: a first arrival's
+   bounds go out as storage stores, and nothing would order those against a shared-memory
+   counter.
+
+Workgroup memory is `keys` + `values` + `parents` (2N−1) = 16,380 bytes, inside the default
+16 KiB with four to spare. The parents are there rather than in storage because the climb reads
+them once per step. Every per-thread loop is bounded by the tile constants. Nothing waits on
+another workgroup, because there is none. No subgroups, and default limits only.
+
+**Reuse map.** Nothing is copied:
+
+| piece | from | how |
+|---|---|---|
+| `chunk_bvh_morton_code` | the body of `shader_bvh_morton` | extracted; `shader_bvh_morton` now calls it |
+| `chunk_bvh_internal_children` | range, split and child selects inline in `shader_bvh_emit_hierarchy` | extracted; emission now calls it |
+| `bvh_delta` / `bvh_determine_range` / `bvh_find_split` | as they were | read `keys` by name instead of through `ptr<storage, array<u32>>` |
+| `chunk_bvh_refit_climb` | as it was | reused unchanged; `parents` resolves to workgroup memory here |
+| `chunk_sort_bitonic_comparator`, `chunk_sort_bitonic_workgroup` | new, in `sort/` | pure index maths split from the barrier loop, as `chunk_sort_rank` is from the scatter |
+
+The by-name change follows the precedent the climb chunk set with `parents`, `counters` and
+`nodes`. A WGSL pointer type carries its address space and access mode. So one function taking
+`ptr<storage, array<u32>>` cannot be handed a workgroup array, nor a storage array its own shader
+writes. Emission's sorted codes are a read-only storage binding in one kernel and workgroup
+memory in the other.
+
+The brick4 bake's `chunk_sort_f32_array_32` is a bitonic network over a private 32-element array.
+It is per-thread and not reusable here.
+
+**Tests.**
+
+- **Tier 1:** the new shader assembles clean (`bvh_lbvh.spec.js`).
+- **Tier 2:** `chunk_bvh_morton_code.spec.js` checks the chunk against `v3_morton_encode_bounded`.
+  `chunk_sort_bitonic_comparator.spec.js` checks the comparator maths. Every step is a perfect
+  matching a stride apart inside one block, the last block ascends, and the network run through
+  the chunk gives the stable order on duplicate-heavy keys. A direction mutant, a tiebreak mutant
+  and a size mutant each turn it red.
+- **Tier 3:** `graph_bvh_build_lbvh.spec.js` checks the encoded dispatches. n = 1, 2, 1,023 and
+  1,024 give exactly one one-workgroup dispatch, red before the change, when 1 gave 3 and the rest
+  19. 1,025 gives 19. The TLAS spec now expects the single dispatch for small scenes and keeps the
+  multi-pass expectations above a tile.
+
+**Device, RTX 4090 only (D3D12, headless Chrome 155), 2026-10-16.** All one-offs from the
+session scratchpad; nothing device-backed went into the repo.
+
+- **Equivalence: 300/300 cases bit-identical** to the multi-pass build. The single-workgroup
+  path's node buffer, guard words around the tree included, its sorted keys and its leaf order all
+  match the multi-pass build's output from the same input. Counts were 1–5, 7–9, 15–17, 31–33,
+  63–65, 127–129, 255–257, 511–513, 777, 1,000, 1,023 and 1,024. Shapes were scattered (two
+  seeds), coincident (one Morton code for all), clustered (long duplicate runs), degenerate
+  (zero-volume), mixed (half at the origin) and lattice (centroids on exact quantisation halves).
+  Each ran in the TLAS layout, and scattered and coincident also in a headerless arena layout
+  (node 0 at word 97, `BVH_NO_ROOT_WORD`). `check_bvh_structure` found nothing on any
+  single-workgroup tree. Negative controls show the comparison is live: one leaf's payload +1, or
+  one bound moved by 1e-3, is reported in every one of six cases.
+- **Harnesses:** `verify_radix_sort`, `verify_gpu_bvh_build` and `verify_gpu_tlas_build` through
+  `playground/bvh_repro` give 118 PASS lines per run, with every builder case at n ≤ 1,024 now on
+  the new path. The topology matches the CPU oracle node for node.
+- **Cost per build.** Medians over 48 blocks of 16 back-to-back builds, ABBA/BAAB across 24
+  submissions. A constant ~85 µs ballast dispatch ran each round as the clock check, and it read
+  84–85 µs throughout:
+
+  | n | single workgroup | multi-pass (19 dispatches) | multi-pass ÷ single |
+  |---|---|---|---|
+  | 16 | 7.3 µs | 73.5 µs | 10.0× |
+  | 128 | 13.2 µs | 77.5 µs | 5.9× |
+  | 1,024 | 53.2 µs | 83.8 µs | 1.6× |
+
+  CPU-side recording and encoding was ~6 µs a build against ~60–100 µs. That figure is indicative
+  only, read from a 100 µs timer over blocks of 16.
+- **Where the single workgroup's time goes.** Medians per build from deleted-workload twin
+  pipelines swapped at `setPipeline`; nothing in the engine was edited:
+
+  | n | dispatch + Morton | + sort | + emission | + refit = full |
+  |---|---|---|---|---|
+  | 128 | 1.7 µs | 4.8 µs | 8.2 µs | 13.2 µs |
+  | 1,024 | 2.4 µs | 12.0 µs | 26.4 µs | 53.0 µs |
+
+  At 1,024 the refit climb is half and emission a quarter. Emission's node stores are 2.4 µs of
+  that; the rest is the range and split search. The kernel is latency-bound by construction:
+  256 threads are eight warps on one SM, each thread walks four leaves in turn, and the default
+  limits fix both numbers. It still wins at the tile boundary, so the threshold stands as derived.
+
+**Observed during this work: R1 once, in the multi-pass path.** In one of 30 harness runs on this
+tree, `verify_gpu_tlas_build` failed `scattered 20000 after movement`: internal node 8195 did not
+contain child 8192. The parent's x-max was exactly 3.0 below the child's, and the movement grows
+every box by 3. So the parent was fitted from that child's bounds left by the previous build. That
+is a stale read in the cross-workgroup climb, the hazard R1 names. 20,000 leaves takes the
+multi-pass path, whose recording and kernels this change leaves as they were. None of these
+reproduced it:
+
+- the other 29 runs on this tree;
+- 28 runs on its base commit `b2fe0c44f`, alternated with them;
+- 1,000 forced rebuilds per tree at 20,000 leaves over reused node buffers, alternating two
+  far-apart leaf sets, 200 of them one per submission and 800 eight per submission.
+
+It was reproduced and attributed the same day, and the climb now handles it: §4.8.
+
+### 4.8 R1 measured, and the refit's repair — landed 2026-10-16
+
+**What happens.** The climb's second arrival at a node sometimes reads its sibling's box before the
+sibling's stores have reached it. It is not rare enough to ignore. A refit-only probe, which builds a
+tree once and then re-runs only the refit, 64 a submission, alternating two leaf sets of one
+topology, measured it. Each refit's internal bounds were compared word for word with the CPU's exact
+tree:
+
+| configuration, RTX 4090, 20,000 leaves | refits | stale |
+|---|---|---|
+| refit only, nothing else on the GPU | 32,000 | 14 |
+| refit only, a second device hammering the GPU | 16,000 | 9 |
+| harness-shaped full builds, nothing else | 1,000 builds | 0 |
+| harness-shaped full builds, second device | 1,000 builds | 2 |
+
+That is about one refit in 2,000. It accounts for the harness's single failure, and for the 1,000
+rebuilds that showed nothing. The node pair the harness reported, 8195 and 8192, recurs in the
+refit-only probe at the same seed.
+
+**What it is, and what it is not.** The pooled arrival counters were read back after every build and
+every refit, and every internal node read exactly 2, so the protocol ran as designed and no counter
+was stale. The stale node is always the union of its fresh child and its other child's previous
+value, with 1 to 4 of the 6 words stale, and the stale child is always internal: leaves come from
+emission, a dispatch earlier. A copy of the climb that records the thread of each arrival found the
+same in 17 of 17 events: the stale child's writer was the parent's first arrival, which then exits,
+and the reader, the second arrival, was always in a different workgroup, always an adjacent one. It
+is cross-workgroup visibility of the bound stores after the counter, exactly as AR3 named it.
+
+**Why no ordering fix.** WGSL has no device-scope fence. Its atomics are relaxed, and
+`storageBarrier` is workgroup-scoped and needs uniform control flow. Inside one dispatch the only
+formally coherent channel between workgroups is a single word's read-modify-write, and a box is six
+words. So the fix is the CSDLDF one: make the read that went wrong detectable, and finish the job
+where a dispatch boundary guarantees visibility.
+
+**The fix.**
+
+1. Emission seeds every internal node's six bound words with `BVH_UNFITTED`, a quiet NaN no union
+   produces (`BVH_REFIT_DEFERRED_LAYOUT.js`). Emission's dispatch ends before the refit's begins, so
+   a refit read returns the store or the seed, never the previous build's box.
+2. The climb's second arrival reads both children through a check (`chunk_bvh_refit_climb`). A seed
+   word counts as the empty box's word (±inf, made at runtime from the seed, because WGSL will not
+   fold an infinity), the node is fitted from what can be seen and the climb goes on, and the node is
+   appended to a deferred list with its tree's node and parents offsets. The list's first three words
+   are the repair's dispatch command, folded as the engine's builders fold one, and raised with
+   `atomicMax` as entries are taken, so no prepare pass is needed.
+3. `shader_bvh_refit_repair`, the build's 20th dispatch, is indirect over that command, so it is
+   empty unless something was deferred. For each listed node it takes the union of the children,
+   now visible, and grows the node and every ancestor with `atomic_min/max_f32_storage`
+   (`chunk_bvh_refit_repair`).
+
+Why that is exact. Everything the climb fitted holds no more than the true box, because an
+unarrived word reads as empty. Every repair contribution holds no more than the true box either.
+For any leaf under a node, the lowest node on the path between them that fails to hold it must
+have read a seed for its path child, so it was listed, and its repair grows the whole path with a
+box that holds the leaf. Growth is a per-word min or max, which commute, so repairs that meet need no
+order.
+
+The single-workgroup build takes the same climb with the same seed. It repairs in-workgroup after one
+more barrier, which gives one workgroup what a dispatch boundary gives the multi-pass build. The
+per-frame skinned BLAS refit (`GPUBLASRefitBatch`) takes it too, with a seeding dispatch of its own
+(`shader_blas_refit_batch_seed`, one lane per node slot) and the same repair over every tree in the
+batch. The batch writes its leaf boxes in the same dispatch too, so the seed covers leaves as
+well. On the device every stale read classified so far was of an internal child, 6 of 6
+(`BLAS_REFIT_BATCH_PLAN.md` §3.7).
+
+The refit-only update of a built tree (`graph_bvh_refit_lbvh`, the GPU fluid's forcing tree above a
+sort tile) has no emission ahead of its climb, so its prepare pass (`shader_bvh_refit_prepare`), the
+dispatch before the climb, seeds each internal node as it rebuilds that node's children's parents. It
+binds a deferred list and records the same indirect repair: three dispatches. On the RTX 4090 at
+20,000 leaves, refits alternating with a pre-R1 twin (no seed, no repair) in every submission: 0
+stale in 96,000 against the twin's 92 in 96,000, with the repair firing in 129. The seed moved the
+prepare from 2.99 to 3.62 µs (mean, 1 µs timer), the empty repair costs 2.64 µs, and the sum of
+passes went from 19.5 to 22.7 µs.
+
+R1's per-level-dispatch fallback was not built. It needs a dispatch per tree level. The 100,000-leaf
+tree is 22 levels deep, and the recorder would have to record the worst case, about 64, because the
+depth is only known on the device. At the measured 3.1 µs for an empty indirect dispatch that is
+70–200 µs, against the ~8 µs below.
+
+**Measured, RTX 4090, on the device:**
+
+- **Stale rate, refit only, the real kernels before and after:** 23 stale refits in 48,000
+  before, 0 in 48,000 after. The fallback fired 62 times in those 48,000, and every refit came out
+  exact.
+- **The skinned batch, before and after:** eight UV spheres, about 45,000 leaves, two poses
+  alternated over the meshlet data. Before, 11 stale refits in 48,000, at least 9 of them real
+  holes, a child escaping its parent; one genuine stale node per bad tree. In the 32,000 that were
+  classified, all 6 stale children were internal and none a leaf. After, 0 in 48,000. At that
+  size the batch's own refit pass is unchanged (p10 about 38 µs either way); the seeding pass adds
+  10.2 µs at p10 (16–19 µs median) and the empty repair 3.1 µs.
+- **Equivalence:** the fix's trees equal the old recorder's, word for word, at 1, 2, 16, 1,000,
+  1,024, 1,025, 4,096, 20,000 and 100,000 leaves.
+- **Harness:** `bvh_repro` "Run all", three times: 118 PASS, 0 FAIL.
+- **Cost:** per-pass timestamps, medians of 320 builds per arm, builds alternating between the old
+  recorder and the new in one page, with other sessions holding the GPU at about 50%:
+
+  | | before | after |
+  |---|---|---|
+  | 100,000 leaves, sum of passes | 140.3 µs | 148.5 µs (+8.2, +5.8%) |
+  | … emission | 25.6 µs | 27.7 µs |
+  | … refit | 41.0 µs | 43.0 µs |
+  | … repair, empty | — | 3.1 µs |
+  | 1,024 leaves, one workgroup | 50.2 µs | 54.3 µs (+4.1) |
+  | 128 leaves, one workgroup | 12.3 µs | 13.3 µs (+1.0) |
+
+  The gaps between passes are not inside these spans; the extra pass adds one.
+
+**Specs.** `bvh_refit_late_stores.spec.js` runs emission, the refit and the repair on the emulator
+with node cells whose stores reach other invocations only when the dispatch ends — a visibility the
+memory model allows, and the one the device showed. It holds the tree exact for one late store, the
+harness's case, and for none landing before the end. `shader_blas_refit_batch.spec.js` does the same
+for a batch frame. On the old kernels the harness's case leaves the parent exactly 3.0 short, and the
+batch leaves children outside their parents.
+
 ---
 
 ## 5. Phases 2–4
@@ -957,7 +1200,10 @@ through `array<atomic<u32>>` accesses only, never plain loads/stores gated by an
 strictest formulation available in WGSL; (d) the browser verify harness asserts structural
 validity per platform, and a formally-clean fallback (iterative per-level dispatches —
 inter-dispatch ordering is guaranteed by WebGPU) is sketched and cheap to add if a platform ever
-misbehaves. Not hand-waved: named, bounded, fallback designed.
+misbehaves. Not hand-waved: named, bounded, fallback designed. **Update, 2026-10-16:** the RTX 4090
+does misbehave, about one refit in 2,000, and (c) alone does not prevent it. The landed answer is
+not the per-level fallback: emission seeds the bounds, the climb defers what it cannot see, and a
+repair dispatch grows it (§4.8).
 
 **AR4 — "The 32-slot traversal stack is shared TLAS+BLAS and your LBVH can exceed the depth the
 current balanced trees keep. Silent geometry drop-out is the failure mode."** The sharpest finding
@@ -1032,7 +1278,7 @@ toward AR2's alternative rather than against it.
 
 | # | risk | mitigation |
 |---|---|---|
-| R1 | WGSL relaxed-atomic cross-workgroup visibility (refit/treelet climbs) is beyond formal guarantees | All-atomic access discipline; no unbounded waiting anywhere (arrival-counter losers exit); per-platform structural verification in the harness; per-level-dispatch fallback designed (inter-dispatch ordering is spec-guaranteed); precedent: csdldf ships on the same visibility assumption. See AR3. |
+| R1 | WGSL relaxed-atomic cross-workgroup visibility (refit/treelet climbs) is beyond formal guarantees | **Realised and closed for the refit, 2026-10-16** (§4.8): about one refit in 2,000 at 20,000 leaves on the RTX 4090 read a sibling's box before it arrived, always across workgroups. Emission seeds the bounds with `BVH_UNFITTED`, the climb defers a node it cannot see whole, and an indirect repair grows it after the dispatch boundary. This is exact, with no waits, and costs +8 µs at 100,000 leaves. The same climb serves the single-workgroup build and the skinned BLAS batch, which seed and repair too. Treelet climbs, when they come, inherit the discipline: a read across an in-dispatch handoff must be able to see that it read too early. |
 | R2 | The sort is new engineering on phase 1's critical path (the fallback-less port was removed; nothing shippable exists today) | v1 deliberately assembled from proven parts — `graph_prefix_scan_csdldf` reused as-is for the spine, ranking/scatter machinery adapted from the deleted port in history, interface kept; ships and verifies before the builder consumes it; single-pass v2 deferred behind a measurement. See AR7, §4.2.1. |
 | R3 | ~~Phase-1 quality dip (raw LBVH vs treelet-optimised dynamic tree)~~ | **Retired.** Measured (§4.6): a dip at ~100 instances that does not reach the frame, and an improvement on every axis at 20k. See AR1. |
 | R4 | Tree depth vs the shared 32-slot traversal stack; occlusion path truncates silently | Depth histogram in verify harness + phase gates; treelets shorten chains; `BVH_TRAVERSAL_STACK_SIZE` bump is a measured last resort. Pre-existing cliff, now instrumented — and **measured**: 22/32 at 100k scattered instances, 20/32 at 20k (§4.6). Not a hypothetical any more. See AR4. |

package/src/shade/renderer/gpu_primitive/bvh/chunk_bvh_delta.d.ts

@@ -11,6 +11,13 @@
  * which is a tree the traversal cannot walk. `countLeadingZeros` is the exact counterpart of the
  * oracle's `Math.clz32`, zero included (both answer 32).
  *
+ * The sorted codes are the module-scope array `keys`, read by name — the way
+ * {@link chunk_bvh_refit_climb} assumes `parents`, `counters` and `nodes`. That is a storage binding
+ * in {@link shader_bvh_emit_hierarchy} and workgroup memory in
+ * {@link shader_bvh_build_single_workgroup}, and no one parameter could take both: a WGSL pointer
+ * type carries its address space and access mode, so a function taking `ptr<storage, array<u32>>`
+ * cannot be handed a workgroup array, nor a storage array the same shader also writes.
+ *
  * @type {CodeChunk}
  */
 export const chunk_bvh_delta: CodeChunk;

package/src/shade/renderer/gpu_primitive/bvh/chunk_bvh_delta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bvh_delta.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/chunk_bvh_delta.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,8BAFU,SAAS,CAsBhB;0BArCuB,oCAAoC"}
+{"version":3,"file":"chunk_bvh_delta.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/chunk_bvh_delta.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAFU,SAAS,CAsBhB;0BA5CuB,oCAAoC"}