@woosh/meep-engine 3.11.3 → 3.12.0

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

@@ -1,143 +1,142 @@
-import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "./BVH_BUFFER_LAYOUT.js";
-import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-import { chunk_bvh_determine_range } from "./chunk_bvh_determine_range.js";
-import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
-
-export const BVH_EMIT_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    // sorted Morton codes, and the leaf index each one came from
-    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
-    .addStorageBuffer("values", WebGPUArray.from(u32), false)
-    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
-    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), false)
-    // `{root: u32, nodes: array<BVH2_NODE_STRUCT>}`, written flat
-    .addStorageBuffer("nodes", WebGPUArray.from(u32), true)
-    // parent of every node, indexed the same way the node buffer is
-    .addStorageBuffer("parents", WebGPUArray.from(u32), true)
-    // which node each leaf ordinal lives at — see the shader's note on why this is written out
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
-const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-const NO_ROOT_WORD = ${BVH_NO_ROOT_WORD}u;
-
-fn bvh_node_word(node: u32) -> u32 {
-    return settings.node_word_offset + node * NODE_STRIDE;
-}
-
-@compute @workgroup_size(${BVH_EMIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-    let n = settings.element_count;
-
-    if (i >= n) {
-        return;
-    }
-
-    // Leaf j lives at node (n-1)+j, internal node k at node k. Root is internal node 0 by Karras's
-    // construction — it is the node whose range is the whole array.
-    let leaf_source = values[i];
-    let leaf_node = (n - 1u) + i;
-
-    let bounds_source = leaf_source * 6u;
-    let leaf_word = bvh_node_word(leaf_node);
-
-    for (var k = 0u; k < 6u; k += 1u) {
-        nodes[leaf_word + NODE_BOUNDS + k] = bitcast<u32>(leaf_bounds[bounds_source + k]);
-    }
-
-    nodes[leaf_word + NODE_CHILD_1] = BVH_NULL_NODE;
-    nodes[leaf_word + NODE_CHILD_2] = leaf_payload[leaf_source];
-
-    // Where the leaves are is an output of construction, not a convention two kernels have to
-    // share. For this layout it is (n-1)+i and the refit could work it out — but a tree that was
-    // copied rather than built has its leaves wherever its builder put them, and the refit reads
-    // this the same way for both.
-    leaf_nodes[i] = leaf_node;
-
-    // n leaves, n-1 internal nodes — the tail thread has only a leaf to write.
-    if (i < n - 1u) {
-        let range = bvh_determine_range(&keys, n, i);
-
-        let first = range.x;
-        let last = range.y;
-
-        let split = bvh_find_split(&keys, n, first, last);
-
-        // A subrange of one element is a leaf; otherwise it is owned by the internal node whose
-        // left boundary sits at that code index.
-        let child_1 = select(split, (n - 1u) + split, split == first);
-        let child_2 = select(split + 1u, (n - 1u) + split + 1u, split + 1u == last);
-
-        let node_word = bvh_node_word(i);
-
-        nodes[node_word + NODE_CHILD_1] = child_1;
-        nodes[node_word + NODE_CHILD_2] = child_2;
-
-        // The refit climbs these; internal-node bounds are its business, not this pass's.
-        parents[child_1] = i;
-        parents[child_2] = i;
-    }
-
-    if (i == 0u) {
-        // Constant by construction, but a tree whose format has a root word has consumers that read
-        // it. A BLAS has none — its root is node 0 by convention — and says so with NO_ROOT_WORD.
-        if (settings.root_word_offset != NO_ROOT_WORD) {
-            nodes[settings.root_word_offset] = 0u;
-        }
-
-        // Where the refit's climb stops.
-        parents[0] = BVH_NULL_NODE;
-    }
-}
-`, [
-    BVH_NULL_NODE_DEFINITION,
-    chunk_bvh_determine_range,
-    chunk_bvh_find_split,
-]);
-
-/**
- * Karras hierarchy emission — pass 3 of {@link graph_bvh_build_lbvh}, and a transliteration of
- * {@link ebvh_build_hierarchy_radix} with the DXR Fallback's index layout: internal node `k` at node
- * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
- *
- * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
- * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
- * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
- *
- * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
- * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
- * range and split and wire its two children.
- *
- * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
- * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the
- * in-repo CPU oracle, duplicate-code runs and all. Internal-node bounds are left to
- * {@link shader_bvh_refit}.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_emit_hierarchy = ComputeShader.from({
-    label: "BVHBuild/EmitHierarchy",
-    resources,
-    body,
-    group_size: [BVH_EMIT_WORKGROUP_SIZE, 1, 1],
-});
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_1_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "./BVH_BUFFER_LAYOUT.js";
+import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+import { chunk_bvh_determine_range } from "./chunk_bvh_determine_range.js";
+import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
+
+export const BVH_EMIT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
+    // sorted Morton codes, and the leaf index each one came from
+    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
+    .addStorageBuffer("values", WebGPUArray.from(u32), false)
+    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
+    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), false)
+    // `{root: u32, nodes: array<BVH2_NODE_STRUCT>}`, written flat
+    .addStorageBuffer("nodes", WebGPUArray.from(u32), true)
+    // parent of every node, indexed the same way the node buffer is
+    .addStorageBuffer("parents", WebGPUArray.from(u32), true)
+    // which node each leaf ordinal lives at — see the shader's note on why this is written out
+    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
+const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
+const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
+const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
+const NO_ROOT_WORD = ${BVH_NO_ROOT_WORD}u;
+
+fn bvh_node_word(node: u32) -> u32 {
+    return settings.node_word_offset + node * NODE_STRIDE;
+}
+
+@compute @workgroup_size(${BVH_EMIT_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = settings.element_count;
+
+    if (i >= n) {
+        return;
+    }
+
+    // Leaf j lives at node (n-1)+j, internal node k at node k. Root is internal node 0 by Karras's
+    // construction — it is the node whose range is the whole array.
+    let leaf_source = values[i];
+    let leaf_node = (n - 1u) + i;
+
+    let bounds_source = leaf_source * 6u;
+    let leaf_word = bvh_node_word(leaf_node);
+
+    for (var k = 0u; k < 6u; k += 1u) {
+        nodes[leaf_word + NODE_BOUNDS + k] = bitcast<u32>(leaf_bounds[bounds_source + k]);
+    }
+
+    nodes[leaf_word + NODE_CHILD_1] = BVH_NULL_NODE;
+    nodes[leaf_word + NODE_CHILD_2] = leaf_payload[leaf_source];
+
+    // Where the leaves are is an output of construction, not a convention two kernels have to
+    // share. For this layout it is (n-1)+i and the refit could work it out — but a tree that was
+    // copied rather than built has its leaves wherever its builder put them, and the refit reads
+    // this the same way for both.
+    leaf_nodes[i] = leaf_node;
+
+    // n leaves, n-1 internal nodes — the tail thread has only a leaf to write.
+    if (i < n - 1u) {
+        let range = bvh_determine_range(&keys, n, i);
+
+        let first = range.x;
+        let last = range.y;
+
+        let split = bvh_find_split(&keys, n, first, last);
+
+        // A subrange of one element is a leaf; otherwise it is owned by the internal node whose
+        // left boundary sits at that code index.
+        let child_1 = select(split, (n - 1u) + split, split == first);
+        let child_2 = select(split + 1u, (n - 1u) + split + 1u, split + 1u == last);
+
+        let node_word = bvh_node_word(i);
+
+        nodes[node_word + NODE_CHILD_1] = child_1;
+        nodes[node_word + NODE_CHILD_2] = child_2;
+
+        // The refit climbs these; internal-node bounds are its business, not this pass's.
+        parents[child_1] = i;
+        parents[child_2] = i;
+    }
+
+    if (i == 0u) {
+        // Constant by construction, but a tree whose format has a root word has consumers that read
+        // it. A BLAS has none — its root is node 0 by convention — and says so with NO_ROOT_WORD.
+        if (settings.root_word_offset != NO_ROOT_WORD) {
+            nodes[settings.root_word_offset] = 0u;
+        }
+
+        // Where the refit's climb stops.
+        parents[0] = BVH_NULL_NODE;
+    }
+}
+`, [
+    BVH_NULL_NODE_DEFINITION,
+    chunk_bvh_determine_range,
+    chunk_bvh_find_split,
+]);
+
+/**
+ * Karras hierarchy emission — pass 3 of {@link graph_bvh_build_lbvh}, and a transliteration of
+ * {@link ebvh_build_hierarchy_radix} with the DXR Fallback's index layout: internal node `k` at node
+ * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
+ *
+ * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
+ * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
+ * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
+ *
+ * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
+ * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
+ * range and split and wire its two children.
+ *
+ * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
+ * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the
+ * in-repo CPU oracle, duplicate-code runs and all. Internal-node bounds are left to
+ * {@link shader_bvh_refit}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_emit_hierarchy = ComputeShader.from({
+    label: "BVHBuild/EmitHierarchy",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AAwD5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAOpB;8BA9E2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AAwD5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAMpB;8BA7E2B,+BAA+B"}

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

@@ -79,5 +79,4 @@ export const shader_bvh_morton = ComputeShader.from({
     label: "BVHBuild/Morton",
     resources,
     body,
-    group_size: [BVH_MORTON_WORKGROUP_SIZE, 1, 1],
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAqG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAOpB;8BAxI2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAqG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAMpB;8BAvI2B,+BAA+B"}

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

@@ -1,141 +1,140 @@
-import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "./BVH_BUFFER_LAYOUT.js";
-import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-
-export const BVH_REFIT_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
-    // node index of each leaf ordinal; the only thing this pass knows about the tree's layout
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
-    // one arrival counter per internal node; must be zero at the start of every build
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // The same buffer the emission pass wrote as typed nodes, bound flat and atomic here. Every
-    // word this pass touches is communicated between workgroups, so every access to it is an
-    // atomic one — the strictest formulation WGSL offers, and the discipline the plan's R1 rests on.
-    .addStorageBuffer("nodes", WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
-const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-
-fn bvh_node_word(node: u32) -> u32 {
-    return settings.node_word_offset + node * NODE_STRIDE;
-}
-
-fn bvh_parent(node: u32) -> u32 {
-    return parents[settings.parents_offset + node];
-}
-
-fn bvh_read_bounds_low(node_word: u32) -> vec3<f32> {
-    return vec3<f32>(
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 1u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 2u])),
-    );
-}
-
-fn bvh_read_bounds_high(node_word: u32) -> vec3<f32> {
-    return vec3<f32>(
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 3u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 4u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 5u])),
-    );
-}
-
-@compute @workgroup_size(${BVH_REFIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-    let n = settings.element_count;
-
-    if (i >= n) {
-        return;
-    }
-
-    // Start above leaf i and climb. Which node that leaf is comes from the tree rather than from a
-    // layout this kernel assumes, so a tree that was built and a tree that was copied refit alike.
-    var node = bvh_parent(leaf_nodes[settings.leaf_nodes_offset + i]);
-
-    loop {
-        if (node == BVH_NULL_NODE) {
-            // climbed past the root
-            break;
-        }
-
-        // An internal node has exactly two children, so exactly two climbs pass through it. The
-        // first arrival exits — its sibling's subtree is still being fitted, and it has nothing to
-        // wait ON: no spin, no assumption about anyone else's forward progress. The second arrival
-        // finds both children written and owns the node from here up.
-        let arrivals = atomicAdd(&counters[node], 1u);
-
-        if (arrivals == 0u) {
-            break;
-        }
-
-        let node_word = bvh_node_word(node);
-
-        let child_1 = atomicLoad(&nodes[node_word + NODE_CHILD_1]);
-        let child_2 = atomicLoad(&nodes[node_word + NODE_CHILD_2]);
-
-        let word_1 = bvh_node_word(child_1);
-        let word_2 = bvh_node_word(child_2);
-
-        let low = min(bvh_read_bounds_low(word_1), bvh_read_bounds_low(word_2));
-        let high = max(bvh_read_bounds_high(word_1), bvh_read_bounds_high(word_2));
-
-        atomicStore(&nodes[node_word + NODE_BOUNDS], bitcast<u32>(low.x));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 1u], bitcast<u32>(low.y));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 2u], bitcast<u32>(low.z));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 3u], bitcast<u32>(high.x));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 4u], bitcast<u32>(high.y));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 5u], bitcast<u32>(high.z));
-
-        node = bvh_parent(node);
-    }
-}
-`, [
-    BVH_NULL_NODE_DEFINITION,
-]);
-
-/**
- * Bottom-up AABB refit — pass 4 of {@link graph_bvh_build_lbvh}, and the last thing a build does.
- *
- * One thread per leaf climbs the `parents` chain from the node `leaf_nodes` says that leaf occupies,
- * taking an arrival counter at each internal node on the way. Nothing waits: the thread that arrives first at a node simply
- * dies, and the one that arrives second is guaranteed both children are complete, because the only
- * way to arrive is to have finished a child. That is the whole synchronisation, and it assumes
- * atomic-word visibility rather than any scheduling fairness — which is why it sits on the accepted
- * side of the engine's line on cross-workgroup communication.
- *
- * The counters must be zero when the pass starts; the graph declares them with a clear range so a
- * pool-reused buffer is cleared and a fresh one arrives zeroed already.
- *
- * The same pass serves refit-only updates (topology frozen, leaf bounds rewritten) — which is what
- * per-frame skinned BLAS needs — so it exists as a standalone dispatch rather than fused into
- * emission. Node indices are local to the tree and `settings.node_word_offset` says where node 0
- * lands, so a BLAS living inside the shared geometry arena refits through this same kernel.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_refit = ComputeShader.from({
-    label: "BVHBuild/Refit",
-    resources,
-    body,
-    group_size: [BVH_REFIT_WORKGROUP_SIZE, 1, 1],
-});
+import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_1_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "./BVH_BUFFER_LAYOUT.js";
+import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+
+export const BVH_REFIT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
+    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
+    // node index of each leaf ordinal; the only thing this pass knows about the tree's layout
+    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
+    // one arrival counter per internal node; must be zero at the start of every build
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    // The same buffer the emission pass wrote as typed nodes, bound flat and atomic here. Every
+    // word this pass touches is communicated between workgroups, so every access to it is an
+    // atomic one — the strictest formulation WGSL offers, and the discipline the plan's R1 rests on.
+    .addStorageBuffer("nodes", WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
+const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
+const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
+const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
+
+fn bvh_node_word(node: u32) -> u32 {
+    return settings.node_word_offset + node * NODE_STRIDE;
+}
+
+fn bvh_parent(node: u32) -> u32 {
+    return parents[settings.parents_offset + node];
+}
+
+fn bvh_read_bounds_low(node_word: u32) -> vec3<f32> {
+    return vec3<f32>(
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 1u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 2u])),
+    );
+}
+
+fn bvh_read_bounds_high(node_word: u32) -> vec3<f32> {
+    return vec3<f32>(
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 3u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 4u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 5u])),
+    );
+}
+
+@compute @workgroup_size(${BVH_REFIT_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = settings.element_count;
+
+    if (i >= n) {
+        return;
+    }
+
+    // Start above leaf i and climb. Which node that leaf is comes from the tree rather than from a
+    // layout this kernel assumes, so a tree that was built and a tree that was copied refit alike.
+    var node = bvh_parent(leaf_nodes[settings.leaf_nodes_offset + i]);
+
+    loop {
+        if (node == BVH_NULL_NODE) {
+            // climbed past the root
+            break;
+        }
+
+        // An internal node has exactly two children, so exactly two climbs pass through it. The
+        // first arrival exits — its sibling's subtree is still being fitted, and it has nothing to
+        // wait ON: no spin, no assumption about anyone else's forward progress. The second arrival
+        // finds both children written and owns the node from here up.
+        let arrivals = atomicAdd(&counters[node], 1u);
+
+        if (arrivals == 0u) {
+            break;
+        }
+
+        let node_word = bvh_node_word(node);
+
+        let child_1 = atomicLoad(&nodes[node_word + NODE_CHILD_1]);
+        let child_2 = atomicLoad(&nodes[node_word + NODE_CHILD_2]);
+
+        let word_1 = bvh_node_word(child_1);
+        let word_2 = bvh_node_word(child_2);
+
+        let low = min(bvh_read_bounds_low(word_1), bvh_read_bounds_low(word_2));
+        let high = max(bvh_read_bounds_high(word_1), bvh_read_bounds_high(word_2));
+
+        atomicStore(&nodes[node_word + NODE_BOUNDS], bitcast<u32>(low.x));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 1u], bitcast<u32>(low.y));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 2u], bitcast<u32>(low.z));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 3u], bitcast<u32>(high.x));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 4u], bitcast<u32>(high.y));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 5u], bitcast<u32>(high.z));
+
+        node = bvh_parent(node);
+    }
+}
+`, [
+    BVH_NULL_NODE_DEFINITION,
+]);
+
+/**
+ * Bottom-up AABB refit — pass 4 of {@link graph_bvh_build_lbvh}, and the last thing a build does.
+ *
+ * One thread per leaf climbs the `parents` chain from the node `leaf_nodes` says that leaf occupies,
+ * taking an arrival counter at each internal node on the way. Nothing waits: the thread that arrives first at a node simply
+ * dies, and the one that arrives second is guaranteed both children are complete, because the only
+ * way to arrive is to have finished a child. That is the whole synchronisation, and it assumes
+ * atomic-word visibility rather than any scheduling fairness — which is why it sits on the accepted
+ * side of the engine's line on cross-workgroup communication.
+ *
+ * The counters must be zero when the pass starts; the graph declares them with a clear range so a
+ * pool-reused buffer is cleared and a fresh one arrives zeroed already.
+ *
+ * The same pass serves refit-only updates (topology frozen, leaf bounds rewritten) — which is what
+ * per-frame skinned BLAS needs — so it exists as a standalone dispatch rather than fused into
+ * emission. Node indices are local to the tree and `settings.node_word_offset` says where node 0
+ * lands, so a BLAS living inside the shared geometry arena refits through this same kernel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_refit = ComputeShader.from({
+    label: "BVHBuild/Refit",
+    resources,
+    body,
+});

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_radix_sort_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAOpB;8BAjF2B,+BAA+B"}
+{"version":3,"file":"shader_radix_sort_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAMpB;8BAhF2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js

@@ -81,5 +81,4 @@ export const shader_radix_sort_histogram = ComputeShader.from({
     label: "RadixSort/Histogram",
     resources,
     body,
-    group_size: [SORT_WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_radix_sort_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js"],"names":[],"mappings":"AA8KA;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CAOpB;8BA3L2B,+BAA+B"}
+{"version":3,"file":"shader_radix_sort_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js"],"names":[],"mappings":"AA8KA;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CAMpB;8BA1L2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js

@@ -188,5 +188,4 @@ export const shader_radix_sort_scatter = ComputeShader.from({
     label: "RadixSort/Scatter",
     resources,
     body,
-    group_size: [SORT_WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/light/cluster/cull/graph_cull_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_cull_lights.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/cluster/cull/graph_cull_lights.js"],"names":[],"mappings":"AA4KA;;;;;;GAMG;AACH,uFAkBC"}
+{"version":3,"file":"graph_cull_lights.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/cluster/cull/graph_cull_lights.js"],"names":[],"mappings":"AAqKA;;;;;;GAMG;AACH,uFAkBC"}