@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js

@@ -13,6 +13,7 @@ import { BRICK4_PROBE_ENCODED_SIZE } from "../../BRICK4_PROBE_ENCODED_SIZE.js";
 import { brick4_extract_probe_locations } from "../../cpu/brick4_extract_probe_locations.js";
 import { brick4_optimize_probe_placement } from "../../cpu/brick4_optimize_probe_placement.js";
 import { shader_brick4_bake_probes } from "./shader_brick4_bake_probes.js";
+import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { shader_brick4_bake_resolve_probes } from "./shader_brick4_bake_resolve_probes.js";
 
 const QUALITY_PROFILE = {
@@ -172,6 +173,8 @@ export async function brick4_bake_basic({
                 //
                 light_data: scene.lights.buffer_data,
                 tEnvironment: scene.lights.environment.obtainView(),
+                tParticipatingMediaNoise: scene.volumetrics.noise_atlas.texture.obtainView(),
+                sParticipatingMediaNoise: graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                 //
                 probe_positions: gr_cycle_probe_positions,
                 output: gr_cycle_trace_data,

package/src/shade/renderer/global_illumination/brick4/gpu/bake/shader_brick4_bake_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick4_bake_probes.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/shader_brick4_bake_probes.js"],"names":[],"mappings":"AA+GA,sDAIG;8BApG2B,qCAAqC"}
+{"version":3,"file":"shader_brick4_bake_probes.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/shader_brick4_bake_probes.js"],"names":[],"mappings":"AAmHA,sDAIG;8BAxG2B,qCAAqC"}

package/src/shade/renderer/global_illumination/brick4/gpu/bake/shader_brick4_bake_probes.js

@@ -16,6 +16,7 @@ import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { RESOURCE_GROUP_RTX } from "../../../../geometry/sr_create_group_RTX.js";
+import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { chunk_direction_by_index_rand1 } from "./sampling/chunk_direction_by_index_rand1.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -30,6 +31,9 @@ resources.createGroup()
 resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
     .addTexture("tEnvironment", "unfilterable-float", "2d")
+    // the fog volumes' noise, read through participating_media_volume_density_at
+    .addTexture("tParticipatingMediaNoise", "float", "3d")
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
 
 const BRICK4_BAKE_SETTINGS_STRUCT = WebGPUStruct.from({
     sample_count: u32,

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick4_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js"],"names":[],"mappings":"AAsMA,0DAwBE;4BAxM0B,mCAAmC"}
+{"version":3,"file":"shader_brick4_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js"],"names":[],"mappings":"AA0MA,0DAwBE;4BA3M0B,mCAAmC"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js

@@ -3,6 +3,7 @@ import { chunk_stbn_sample_vec2 } from "../../../../shader/chunk/noise/chunk_stb
 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";
@@ -161,6 +162,8 @@ fn main(
         view_direction,
         material_color_diffuse,
         material_specularF0,
+        vec3(MIN_DIELECTRICS_F0),
+        albedo,
         material_specularF90,
         roughness,
     );
@@ -181,6 +184,7 @@ fn main(
         chunk_decode_g_buffer_metalness,
         chunk_decode_g_buffer_roughness,
         chunk_metalness_to_specular_color,
+        chunk_MIN_DIELECTRICS_F0,
         chunk_brick4_node_by_position,
         chunk_brick4_node_sample_probes_meta,
         chunk_brick4_probe_meta_pick2,

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAUhB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAmGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA7XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAZtC,uCAAuC;uCAFlC,8CAA8C"}
+{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAsBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAUhB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAqGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA/XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAbtC,uCAAuC;uCAFlC,8CAA8C"}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js

@@ -18,6 +18,7 @@ import {
 } from "../deprecated/probe_trace_compute_shader_code.js";
 import { graph_generate_probe_locations } from "../placement/graph_generate_probe_locations.js";
 import { PROBE_RAYS_PER_WORKGROUP } from "./PROBE_RAYS_PER_WORKGROUP.js";
+import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 
 /**
  * @typedef {import("../../../GraphicsContext.js").GraphicsContext} GraphicsContext
@@ -301,6 +302,8 @@ export class GPULightProbeVolumeRenderer {
                 textures: r_materials.textureView,
                 bake_settings: bake_uniform,
                 tEnvironment: this.#environment.obtainView(),
+                tParticipatingMediaNoise: scene.volumetrics.noise_atlas.texture.obtainView(),
+                sParticipatingMediaNoise: this.#graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
                 //
                 tlas: scene.tlas.buffer,
                 blas_lookup: blas.buffer_metadata,

package/src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_trace_compute_shader_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js"],"names":[],"mappings":"AAyBA,sDAIG;AAoKH,4DAIG;6BAnM0B,sCAAsC;8BAiBrC,kCAAkC"}
+{"version":3,"file":"probe_trace_compute_shader_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js"],"names":[],"mappings":"AA0BA,sDAIG;AAuKH,4DAIG;6BAvM0B,sCAAsC;8BAiBrC,kCAAkC"}

package/src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js

@@ -22,6 +22,7 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 import { PROBE_RAYS_PER_WORKGROUP } from "../bake/PROBE_RAYS_PER_WORKGROUP.js";
 import { LIGHT_PROBE_STRUCT } from "../LIGHT_PROBE_STRUCT.js";
 import { LIGHT_PROBE_VOLUME_METADATA_STRUCT } from "../LIGHT_PROBE_VOLUME_METADATA_STRUCT.js";
+import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 
 export const PROBE_BAKE_UNIFORMS_STRUCT = WebGPUStruct.from({
     direction: vec3f,
@@ -43,6 +44,9 @@ resources.createGroup({ label: 'LPV & scene' })
     .addTexture('textures', 'unfilterable-float', '2d-array', false)
     .addUniform('bake_settings', PROBE_BAKE_UNIFORMS_STRUCT)
     .addTexture('tEnvironment', 'unfilterable-float')
+    // the fog volumes' noise, read through participating_media_volume_density_at
+    .addTexture("tParticipatingMediaNoise", "float", "3d")
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
 
 sr_create_group_RTX(resources);
 

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/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/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,133 @@ 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.
+
+So the rate is low and unattributed. The climb's visibility assumption is the open question, and
+R1's per-level-dispatch fallback is its designed answer.
+
 ---
 
 ## 5. Phases 2–4
@@ -1032,7 +1162,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 | 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. **Observed once, 2026-10-16**: one stale-sibling fit in the multi-pass refit, in one harness run on the RTX 4090; not reproduced since (§4.7). |
 | 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"}

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

@@ -1,38 +1,45 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * Karras longest-common-prefix length between the Morton codes at `i` and `j`, transliterated from
- * `delta` inside {@link ebvh_build_hierarchy_radix}.
- *
- * `-1` for a `j` outside `[0, n-1]` — the canonical Karras out-of-range sentinel, and the reason
- * this returns `i32` rather than `u32`.
- *
- * The `32 + countLeadingZeros(i ^ j)` branch for identical codes is the duplicate-key tiebreak, and
- * it is load-bearing rather than defensive: identical instance positions collide long before a
- * 30-bit grid fills, and without a tiebreak an internal node's range can collapse to a single leaf,
- * which is a tree the traversal cannot walk. `countLeadingZeros` is the exact counterpart of the
- * oracle's `Math.clz32`, zero included (both answer 32).
- *
- * @type {CodeChunk}
- */
-export const chunk_bvh_delta = CodeChunk.from(
-    //language=WGSL
-    `
-fn bvh_delta(codes: ptr<storage, array<u32>>, n: u32, i: u32, j: i32) -> i32 {
-    if (j < 0 || u32(j) >= n) {
-        return -1;
-    }
-
-    let other = u32(j);
-
-    let code_i = codes[i];
-    let code_j = codes[other];
-
-    if (code_i == code_j) {
-        // identical codes: break the tie by index, so every internal node still owns a >= 2-leaf range
-        return 32 + i32(countLeadingZeros(i ^ other));
-    }
-
-    return i32(countLeadingZeros(code_i ^ code_j));
-}
-`);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Karras longest-common-prefix length between the Morton codes at `i` and `j`, transliterated from
+ * `delta` inside {@link ebvh_build_hierarchy_radix}.
+ *
+ * `-1` for a `j` outside `[0, n-1]` — the canonical Karras out-of-range sentinel, and the reason
+ * this returns `i32` rather than `u32`.
+ *
+ * The `32 + countLeadingZeros(i ^ j)` branch for identical codes is the duplicate-key tiebreak, and
+ * it is load-bearing rather than defensive: identical instance positions collide long before a
+ * 30-bit grid fills, and without a tiebreak an internal node's range can collapse to a single leaf,
+ * 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.from(
+    //language=WGSL
+    `
+fn bvh_delta(n: u32, i: u32, j: i32) -> i32 {
+    if (j < 0 || u32(j) >= n) {
+        return -1;
+    }
+
+    let other = u32(j);
+
+    let code_i = keys[i];
+    let code_j = keys[other];
+
+    if (code_i == code_j) {
+        // identical codes: break the tie by index, so every internal node still owns a >= 2-leaf range
+        return 32 + i32(countLeadingZeros(i ^ other));
+    }
+
+    return i32(countLeadingZeros(code_i ^ code_j));
+}
+`);

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

@@ -9,6 +9,8 @@
  *
  * Returned as `vec2<u32>(first, last)`; both ends are always valid leaf indices.
  *
+ * Reads the sorted codes through {@link chunk_bvh_delta}, so from the module-scope array `keys`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_bvh_determine_range: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_bvh_determine_range.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/chunk_bvh_determine_range.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,wCAFU,SAAS,CAgEhB;0BA9EuB,oCAAoC"}
+{"version":3,"file":"chunk_bvh_determine_range.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/chunk_bvh_determine_range.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,wCAFU,SAAS,CAgEhB;0BAhFuB,oCAAoC"}

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

@@ -1,79 +1,81 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_bvh_delta } from "./chunk_bvh_delta.js";
-
-/**
- * The `[first, last]` code range internal node `idx` covers — a transliteration of `determineRange`
- * inside {@link ebvh_build_hierarchy_radix}: pick the direction the node grows in by comparing the
- * prefixes shared with either neighbour, find an upper bound on its length by doubling, then binary
- * search inside that bound.
- *
- * Node 0 is short-circuited to the whole array, as on the CPU, so callers do not special-case the
- * root.
- *
- * Returned as `vec2<u32>(first, last)`; both ends are always valid leaf indices.
- *
- * @type {CodeChunk}
- */
-export const chunk_bvh_determine_range = CodeChunk.from(
-    //language=WGSL
-    `
-fn bvh_determine_range(codes: ptr<storage, array<u32>>, leaf_count: u32, idx: u32) -> vec2<u32> {
-    // For the root the range is unambiguously [0, leaf_count - 1].
-    if (idx == 0u) {
-        return vec2<u32>(0u, leaf_count - 1u);
-    }
-
-    let index = i32(idx);
-    let count = i32(leaf_count);
-
-    let prefix_right = bvh_delta(codes, leaf_count, idx, index + 1);
-    let prefix_left = bvh_delta(codes, leaf_count, idx, index - 1);
-
-    var direction = -1;
-    if (prefix_right - prefix_left > 0) {
-        direction = 1;
-    }
-
-    // Minimum prefix length required to stay in this range — anything sharing fewer bits than this
-    // is outside the node's subtree.
-    let min_prefix_range = bvh_delta(codes, leaf_count, idx, index - direction);
-
-    // Expand the maximum range with exponential growth, bounded by the array.
-    var lmax = 2;
-    var next_key = index + lmax * direction;
-
-    loop {
-        if (!(next_key >= 0 && next_key < count
-            && bvh_delta(codes, leaf_count, idx, next_key) > min_prefix_range)) {
-            break;
-        }
-
-        lmax = lmax * 2;
-        next_key = index + lmax * direction;
-    }
-
-    // Binary-search for the actual length within [0, lmax].
-    var length = 0;
-    loop {
-        lmax = (lmax + 1) >> 1u;
-
-        let candidate = index + (length + lmax) * direction;
-
-        if (candidate >= 0 && candidate < count) {
-            if (bvh_delta(codes, leaf_count, idx, candidate) > min_prefix_range) {
-                length = length + lmax;
-            }
-        }
-
-        if (lmax <= 1) {
-            break;
-        }
-    }
-
-    let other = index + length * direction;
-
-    return vec2<u32>(u32(min(index, other)), u32(max(index, other)));
-}
-`, [
-    chunk_bvh_delta,
-]);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bvh_delta } from "./chunk_bvh_delta.js";
+
+/**
+ * The `[first, last]` code range internal node `idx` covers — a transliteration of `determineRange`
+ * inside {@link ebvh_build_hierarchy_radix}: pick the direction the node grows in by comparing the
+ * prefixes shared with either neighbour, find an upper bound on its length by doubling, then binary
+ * search inside that bound.
+ *
+ * Node 0 is short-circuited to the whole array, as on the CPU, so callers do not special-case the
+ * root.
+ *
+ * Returned as `vec2<u32>(first, last)`; both ends are always valid leaf indices.
+ *
+ * Reads the sorted codes through {@link chunk_bvh_delta}, so from the module-scope array `keys`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bvh_determine_range = CodeChunk.from(
+    //language=WGSL
+    `
+fn bvh_determine_range(leaf_count: u32, idx: u32) -> vec2<u32> {
+    // For the root the range is unambiguously [0, leaf_count - 1].
+    if (idx == 0u) {
+        return vec2<u32>(0u, leaf_count - 1u);
+    }
+
+    let index = i32(idx);
+    let count = i32(leaf_count);
+
+    let prefix_right = bvh_delta(leaf_count, idx, index + 1);
+    let prefix_left = bvh_delta(leaf_count, idx, index - 1);
+
+    var direction = -1;
+    if (prefix_right - prefix_left > 0) {
+        direction = 1;
+    }
+
+    // Minimum prefix length required to stay in this range — anything sharing fewer bits than this
+    // is outside the node's subtree.
+    let min_prefix_range = bvh_delta(leaf_count, idx, index - direction);
+
+    // Expand the maximum range with exponential growth, bounded by the array.
+    var lmax = 2;
+    var next_key = index + lmax * direction;
+
+    loop {
+        if (!(next_key >= 0 && next_key < count
+            && bvh_delta(leaf_count, idx, next_key) > min_prefix_range)) {
+            break;
+        }
+
+        lmax = lmax * 2;
+        next_key = index + lmax * direction;
+    }
+
+    // Binary-search for the actual length within [0, lmax].
+    var length = 0;
+    loop {
+        lmax = (lmax + 1) >> 1u;
+
+        let candidate = index + (length + lmax) * direction;
+
+        if (candidate >= 0 && candidate < count) {
+            if (bvh_delta(leaf_count, idx, candidate) > min_prefix_range) {
+                length = length + lmax;
+            }
+        }
+
+        if (lmax <= 1) {
+            break;
+        }
+    }
+
+    let other = index + length * direction;
+
+    return vec2<u32>(u32(min(index, other)), u32(max(index, other)));
+}
+`, [
+    chunk_bvh_delta,
+]);

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

@@ -9,6 +9,8 @@
  * and its child then both claim the same leaf — a shared node, which is not a tree, and which only
  * shows up when duplicate codes appear mid-range.
  *
+ * Reads the sorted codes through {@link chunk_bvh_delta}, so from the module-scope array `keys`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_bvh_find_split: CodeChunk;