@woosh/meep-engine 3.28.0 → 3.29.0

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CLUSTER_ROW_WORDS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGEO_CLUSTER_ROW_WORDS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CLUSTER_ROW_WORDS.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qCAFU,MAAM,CAEyB"}
+{"version":3,"file":"VGEO_CLUSTER_ROW_WORDS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CLUSTER_ROW_WORDS.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAEyB"}

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CLUSTER_ROW_WORDS.js

@@ -2,11 +2,16 @@
  * Words in one selection-buffer cluster row.
  *
  * Not rounded up to a power of two. At the million resident clusters
- * `VIRTUAL_GEOMETRY_DESIGN.md` §4 targets, thirteen words is 52 MB and sixteen is 64 — and the
- * addressing is a multiply either way, so the padding would buy nothing and cost twelve megabytes.
+ * `VIRTUAL_GEOMETRY_DESIGN.md` §4 targets, nineteen words is 76 MB and thirty-two is 128 — and the
+ * addressing is a multiply either way, so the padding would buy nothing and cost fifty megabytes.
+ *
+ * Nineteen since the frustum test moved onto the subtree box: thirteen were the cut rule's operands
+ * and the edge, and the last six are {@link VGEO_CLUSTER_ROW_OFFSET.CULL_BOX}. On a 64 KB page the
+ * widest page of a converted Zorah container goes from 851 words of its 2,048-word slot to 1,163,
+ * so the stride {@link vgeo_runtime_page_slot_words} picks still holds it with room over.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  * @type {number}
  */
-export const VGEO_CLUSTER_ROW_WORDS = 13;
+export const VGEO_CLUSTER_ROW_WORDS = 19;

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CUT_STAT.d.ts

@@ -14,5 +14,6 @@ export namespace VGEO_CUT_STAT {
     let WAVEFRONTS: number;
     let QUEUE_REMAINING: number;
     let CULLED_CLUSTER: number;
+    let CULLED_CLUSTER_BOX: number;
 }
 //# sourceMappingURL=VGEO_CUT_STAT.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CUT_STAT.js

@@ -107,4 +107,14 @@ export const VGEO_CUT_STAT = {
      * (RUNTIME_PLAN_2026_09_14 §0, §2.1).
      */
     CULLED_CLUSTER: 14,
+    /**
+     * Of the clusters the frustum discarded, the ones the LOD sphere let through and the subtree box
+     * caught — what the tighter bound of `CULL_PLAN_2026_09_16` is worth, per frame and per view.
+     *
+     * A container written before `format_version` 5 carries no such box and the reader stands the
+     * sphere's own cube in for it, which rejects nothing the sphere did not: **this counter reading
+     * zero is how an older container announces itself**, and it is the measurement behind that
+     * promise rather than an argument for it.
+     */
+    CULLED_CLUSTER_BOX: 15,
 };

package/src/shade/renderer/geometry/virtual/runtime/layout/VGEO_CUT_STAT_COUNT.js

@@ -5,4 +5,4 @@
  * @copyright Company Named Limited (c) 2026
  * @type {number}
  */
-export const VGEO_CUT_STAT_COUNT = 15;
+export const VGEO_CUT_STAT_COUNT = 16;

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_slot_words.d.ts

@@ -5,21 +5,23 @@
  * are a factor of fifteen apart, so the number here is a **choice** rather than a derivation and it
  * is worth writing down which.
  *
- * **The provable bound is about half the page size.** A page's decoded bytes are
+ * **The provable bound is close to the page size.** A page's decoded bytes are
  * `56 + 32·nodes + 8·groups + 112·clusters + payload`, and its runtime rows are
- * `32·nodes + 16·groups + 52·clusters`. Every group holds at least one cluster (format §11.1) and
+ * `32·nodes + 16·groups + 76·clusters`. Every group holds at least one cluster (format §11.1) and
  * the node tree over `g` groups has at most `(g+2)/2` nodes, so the runtime side is at most
- * `84·clusters + 32` against a decoded side of at least `56 + 112·clusters` — a ratio of 0.75, or
- * 0.53 once a cluster's minimum payload is counted. A stride sized that way is correct for every
- * container the format admits and wastes an order of magnitude on every container anyone builds.
+ * `108·clusters + 32` against a decoded side of at least `56 + 112·clusters` — a ratio just under
+ * one, or about 0.7 once a cluster's minimum payload is counted. A stride sized that way is correct
+ * for every container the format admits and wastes an order of magnitude on every container anyone
+ * builds.
  *
- * **The measured maximum is 3.9%.** A 160×80 torus built at 16, 32, 64 and 128 KB pages put its
- * widest page's rows at 3.7%, 3.9%, 3.4% and 3.5% of the page size respectively, because a page is
- * overwhelmingly payload: 38 clusters in a 64 KB page is 4.5 KB of records against 59 KB of
- * vertices and indices.
+ * **The measured maximum is about 7%.** The widest page of a converted Zorah container — 52
+ * clusters, 5 nodes, 15 groups, 25 parent entries — comes to 1,163 words against a 64 KB page,
+ * which is 7.1% of it, because a page is overwhelmingly payload: 52 clusters is 4.5 KB of records
+ * against 59 KB of vertices and indices. It was 3.9% before the cluster row carried a cull box
+ * (`CULL_PLAN_2026_09_16` §2.4), and the eighth below still holds it at 1.76× rather than 3.2×.
  *
- * So this takes **an eighth of the page**, which is 3.2× the widest measured page at the tightest
- * page size, and an install that does not fit is **refused and counted** rather than overrunning
+ * So this takes **an eighth of the page**, which is 1.76× the widest measured page, and an install
+ * that does not fit is **refused and counted** rather than overrunning
  * its slot — the same direction `register` takes for a container built at the wrong page size, and
  * for the same reason: a tier that silently reconciles a size it was not built for is a tier whose
  * pages point into each other. A caller holding an asset this refuses raises `page_slot_words`,

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_slot_words.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_page_slot_words.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_slot_words.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wDANW,MAAM,GACJ,MAAM,CAUlB"}
+{"version":3,"file":"vgeo_runtime_page_slot_words.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_slot_words.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wDANW,MAAM,GACJ,MAAM,CAUlB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_slot_words.js

@@ -7,21 +7,23 @@ import { assert } from "../../../../../core/assert.js";
  * are a factor of fifteen apart, so the number here is a **choice** rather than a derivation and it
  * is worth writing down which.
  *
- * **The provable bound is about half the page size.** A page's decoded bytes are
+ * **The provable bound is close to the page size.** A page's decoded bytes are
  * `56 + 32·nodes + 8·groups + 112·clusters + payload`, and its runtime rows are
- * `32·nodes + 16·groups + 52·clusters`. Every group holds at least one cluster (format §11.1) and
+ * `32·nodes + 16·groups + 76·clusters`. Every group holds at least one cluster (format §11.1) and
  * the node tree over `g` groups has at most `(g+2)/2` nodes, so the runtime side is at most
- * `84·clusters + 32` against a decoded side of at least `56 + 112·clusters` — a ratio of 0.75, or
- * 0.53 once a cluster's minimum payload is counted. A stride sized that way is correct for every
- * container the format admits and wastes an order of magnitude on every container anyone builds.
+ * `108·clusters + 32` against a decoded side of at least `56 + 112·clusters` — a ratio just under
+ * one, or about 0.7 once a cluster's minimum payload is counted. A stride sized that way is correct
+ * for every container the format admits and wastes an order of magnitude on every container anyone
+ * builds.
  *
- * **The measured maximum is 3.9%.** A 160×80 torus built at 16, 32, 64 and 128 KB pages put its
- * widest page's rows at 3.7%, 3.9%, 3.4% and 3.5% of the page size respectively, because a page is
- * overwhelmingly payload: 38 clusters in a 64 KB page is 4.5 KB of records against 59 KB of
- * vertices and indices.
+ * **The measured maximum is about 7%.** The widest page of a converted Zorah container — 52
+ * clusters, 5 nodes, 15 groups, 25 parent entries — comes to 1,163 words against a 64 KB page,
+ * which is 7.1% of it, because a page is overwhelmingly payload: 52 clusters is 4.5 KB of records
+ * against 59 KB of vertices and indices. It was 3.9% before the cluster row carried a cull box
+ * (`CULL_PLAN_2026_09_16` §2.4), and the eighth below still holds it at 1.76× rather than 3.2×.
  *
- * So this takes **an eighth of the page**, which is 3.2× the widest measured page at the tightest
- * page size, and an install that does not fit is **refused and counted** rather than overrunning
+ * So this takes **an eighth of the page**, which is 1.76× the widest measured page, and an install
+ * that does not fit is **refused and counted** rather than overrunning
  * its slot — the same direction `register` takes for a container built at the wrong page size, and
  * for the same reason: a tier that silently reconciles a size it was not built for is a tier whose
  * pages point into each other. A caller holding an asset this refuses raises `page_slot_words`,

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_write_page_block.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qDAXW,WAAW,UACX,YAAY,QAEZ,MAAM,mBAEJ,MAAM,CAkIlB"}
+{"version":3,"file":"vgeo_runtime_write_page_block.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qDAXW,WAAW,UACX,YAAY,QAEZ,MAAM,mBAEJ,MAAM,CAsIlB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js

@@ -109,6 +109,10 @@ export function vgeo_runtime_write_page_block(words, floats, base, page) {
                 page.parent_sphere[cluster * 4 + c];
         }
 
+        for (let c = 0; c < 6; c++) {
+            floats[row + VGEO_CLUSTER_ROW_OFFSET.CULL_BOX + c] = page.subtree_aabb[cluster * 6 + c];
+        }
+
         floats[row + VGEO_CLUSTER_ROW_OFFSET.SELF_ERROR] = page.self_error[cluster];
         floats[row + VGEO_CLUSTER_ROW_OFFSET.PARENT_ERROR] = page.parent_error[cluster];
 

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAmGA,+CAIG;8BAnG2B,kCAAkC"}
+{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAkGA,+CAIG;8BAlG2B,kCAAkC"}

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js

@@ -26,11 +26,10 @@ const PUSH_CONSTANTS = WebGPUStruct.from({
     capacity: u32,
 });
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+// per-dispatch, eight bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", PUSH_CONSTANTS);
+
 resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS)
     .addStorageBuffer('hashMapData', HASH_MAP_DATA_STRUCT, true)
     .addStorageBuffer("voxelData", WebGPUArray.from(vec4u))
     .addStorageBuffer('evictionRequests', EVICTION_STRUCT);

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.d.ts

@@ -6,16 +6,20 @@
  * @param {number} buffer_input_offset where to start reading from, in bytes
  * @param {GPUBuffer} buffer_command
  * @param {number} buffer_command_offset where to start writing at, in bytes
+ * @param {boolean} [fold] spread a count past one dimension's limit over `y` and `z` instead of
+ *        clamping it away. Only for a shader that reads its index through
+ *        {@link chunk_grid3d_to_index} — see {@link create_pipeline}.
  */
-export function build_indirect_compute_dispatch_command(elements_per_workgroup: number, encoder: ShadeGPUCommandContext, buffer_input: GPUBuffer, buffer_input_offset: number, buffer_command: GPUBuffer, buffer_command_offset: number): void;
+export function build_indirect_compute_dispatch_command(elements_per_workgroup: number, encoder: ShadeGPUCommandContext, buffer_input: GPUBuffer, buffer_input_offset: number, buffer_command: GPUBuffer, buffer_command_offset: number, fold?: boolean): void;
 /**
  *
  * @param {FrameGraph} graph
  * @param {number} input input buffer ID
  * @param {number} [workgroup_size]
+ * @param {boolean} [fold] see {@link build_indirect_compute_dispatch_command}
  * @returns {number}
  */
-export function graph_build_indirect_dispatch_command(graph: FrameGraph, input: number, workgroup_size?: number): number;
+export function graph_build_indirect_dispatch_command(graph: FrameGraph, input: number, workgroup_size?: number, fold?: boolean): number;
 export const INDIRECT_COMPUTE_COMMAND_DESCRIPTOR: BufferResourceDescriptor;
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 //# sourceMappingURL=IndirectComputeCommandBuildPass.d.ts.map

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AA4GA;;;;;;;;GAQG;AACH,gFAPW,MAAM,iFAGN,MAAM,oDAEN,MAAM,QAoFhB;AAED;;;;;;GAMG;AACH,gFAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAiClB;AAxID,2EAIE;yCArGuC,mDAAmD"}
+{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AAoLA;;;;;;;;;;;GAWG;AACH,gFAVW,MAAM,iFAGN,MAAM,oDAEN,MAAM,SACN,OAAO,QAuFjB;AAED;;;;;;;GAOG;AACH,gFALW,MAAM,mBACN,MAAM,SACN,OAAO,GACL,MAAM,CAkClB;AA9ID,2EAIE;yCA7KuC,mDAAmD"}

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js

@@ -8,6 +8,46 @@ import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDe
 import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "./STRUCT_DISPATCH_COMPUTE_COMMAND.js";
 
 /**
+ * How a workgroup count that does not fit one dimension is spread over three.
+ *
+ * `maxComputeWorkgroupsPerDimension` is 65,535 on Chrome/Dawn and {@link Renderer#initialize} does
+ * not raise it — an adapter will not hand up more. At the engine's group size of 128 that is
+ * 8,388,480 elements in one dimension, which a real scene passes: a map of a million ordinary mesh
+ * rows expands to twelve million meshlets.
+ *
+ * Neither of the things that happen there is acceptable. A command **over** the limit makes
+ * `dispatchWorkgroupsIndirect` do nothing at all — measured against Dawn on nvidia/lovelace, where
+ * 65,535 workgroups run and 65,536 write not one element, with no validation error and nothing
+ * logged. Clamping it back into range, which is what this pass used to do, is the milder version of
+ * the same thing: a pass that silently covers its first 8,388,480 elements and no more. Neither
+ * moves a counter, because the collection's own `count` is written by a different pass.
+ *
+ * So the count is folded instead: `x` fills to the limit, then `y`, then `z`. Nothing is dropped
+ * and the reachable size becomes 65,535³ groups, which is not a limit anyone will meet.
+ *
+ * **A folded command's shader has to read its index accordingly.** `global_invocation_id.x` only
+ * carries the x dimension, so a shader that keeps using it would run its first 8,388,480 elements
+ * once per `y`, which is worse than dropping the rest. Fold and index are one decision:
+ *
+ * ```wgsl
+ * fn main(
+ *     @builtin(workgroup_id) workgroup_id : vec3<u32>,
+ *     @builtin(num_workgroups) group_count : vec3<u32>,
+ *     @builtin(local_invocation_index) local_index : u32,
+ * ){
+ *     let index = grid3d_to_index(workgroup_id, group_count.xy) * GROUP_SIZEu + local_index;
+ *
+ *     if(index >= count){ return; }
+ * ```
+ *
+ * {@link chunk_grid3d_to_index} is the same flattening the light and decal clusters use, and a
+ * folded grid is exactly a 3D grid whose extents happen to be a dispatch's. When the count fits,
+ * `y` and `z` are 1 and the expression is `global_invocation_id.x` term for term, so a pass under
+ * the ceiling pays nothing for this.
+ *
+ * Folding is opt-in because it is only safe once the shader indexes this way, and most passes
+ * driven by this builder cannot reach the ceiling to begin with — a scene is capped at 3,047,424
+ * mesh rows by the `transforms` table, which is 23,808 groups.
  *
  * @param {PipelineCacheKey} key
  * @returns {ComputePipelineDescriptor}
@@ -17,6 +57,28 @@ function create_pipeline(key) {
     const device = key.device;
     const max_workgroup_count = device.limits.maxComputeWorkgroupsPerDimension;
 
+    //language=WGSL
+    const clamped_dispatch = `
+    // clamp, it's generally better to be wrong than to fail
+    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(
+        min( ${max_workgroup_count}u, desired_groups ),
+        1u,
+        1u
+    );`;
+
+    //language=WGSL
+    const folded_dispatch = `
+    const LIMIT = ${max_workgroup_count}u;
+
+    // x to the limit, what is left of it in rows of x, what is left of those in slices of x*y
+    let rows = divide_round_up(desired_groups, LIMIT);
+    let slices = divide_round_up(rows, LIMIT);
+
+    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(
+        min( desired_groups, LIMIT ),
+        min( max( rows, 1u ), LIMIT ),
+        max( slices, 1u )
+    );`;
 
 //language=WGSL
     const shader_code = `
@@ -25,22 +87,22 @@ function create_pipeline(key) {
 @group(0) @binding(0) var<storage, read> input : u32;
 @group(0) @binding(1) var<storage, read_write> command : ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref};
 
+fn divide_round_up(value: u32, divisor: u32) -> u32 {
+    return (value + divisor - 1u) / divisor;
+}
+
 @compute @workgroup_size(1, 1, 1)
 fn main(){
 
     let elements_per_group = ${key.elements_per_workgroup}u;
-    let desired_dispatch_x = (input + elements_per_group - 1u) / elements_per_group;
-
-    // clamp, it's generally better to be wrong than to fail
-    let dispatch_x = min( ${max_workgroup_count}, desired_dispatch_x );
-    
-    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(dispatch_x, 1u, 1u);
+    let desired_groups = divide_round_up(input, elements_per_group);
+${key.fold ? folded_dispatch : clamped_dispatch}
 
 }
         `;
 
     return ComputePipelineDescriptor.simplified({
-        label: "IndirectComputeCommandBuildPass",
+        label: key.fold ? "IndirectComputeCommandBuildPass/folded" : "IndirectComputeCommandBuildPass",
         code:
         shader_code,
         bindings: [[
@@ -64,14 +126,23 @@ class PipelineCacheKey {
      */
     elements_per_workgroup = 256
 
-    static from(device, elements_per_workgroup = 256) {
+    /**
+     * Whether a count past one dimension's limit is spread over `y` and `z` rather than clamped
+     * away. See {@link create_pipeline} — the shader it drives has to index for it.
+     * @type {boolean}
+     */
+    fold = false;
+
+    static from(device, elements_per_workgroup = 256, fold = false) {
         assert.defined(device, 'device');
         assert.isNonNegativeInteger(elements_per_workgroup, 'workgroup_size');
+        assert.isBoolean(fold, 'fold');
 
         const r = new PipelineCacheKey();
 
         r.device = device;
         r.elements_per_workgroup = elements_per_workgroup;
+        r.fold = fold;
 
         return r;
     }
@@ -79,11 +150,12 @@ class PipelineCacheKey {
     equals(other) {
         return this.device === other.device
             && this.elements_per_workgroup === other.elements_per_workgroup
+            && this.fold === other.fold
             ;
     }
 
     hash() {
-        return this.elements_per_workgroup;
+        return this.elements_per_workgroup * 2 + (this.fold ? 1 : 0);
     }
 }
 
@@ -114,6 +186,9 @@ export const INDIRECT_COMPUTE_COMMAND_DESCRIPTOR = BufferResourceDescriptor.from
  * @param {number} buffer_input_offset where to start reading from, in bytes
  * @param {GPUBuffer} buffer_command
  * @param {number} buffer_command_offset where to start writing at, in bytes
+ * @param {boolean} [fold] spread a count past one dimension's limit over `y` and `z` instead of
+ *        clamping it away. Only for a shader that reads its index through
+ *        {@link chunk_grid3d_to_index} — see {@link create_pipeline}.
  */
 export function build_indirect_compute_dispatch_command(
     elements_per_workgroup,
@@ -122,6 +197,7 @@ export function build_indirect_compute_dispatch_command(
     buffer_input_offset,
     buffer_command,
     buffer_command_offset,
+    fold = false,
 ) {
     assert.defined(encoder, 'encoder');
     assert.notNull(encoder, 'encoder');
@@ -172,7 +248,7 @@ export function build_indirect_compute_dispatch_command(
 
     }
 
-    const key = PipelineCacheKey.from(device, elements_per_workgroup);
+    const key = PipelineCacheKey.from(device, elements_per_workgroup, fold);
 
     const pipeline = pipeline_cache.getOrCompute(key, create_pipeline);
 
@@ -204,9 +280,10 @@ export function build_indirect_compute_dispatch_command(
  * @param {FrameGraph} graph
  * @param {number} input input buffer ID
  * @param {number} [workgroup_size]
+ * @param {boolean} [fold] see {@link build_indirect_compute_dispatch_command}
  * @returns {number}
  */
-export function graph_build_indirect_dispatch_command(graph, input, workgroup_size = 256) {
+export function graph_build_indirect_dispatch_command(graph, input, workgroup_size = 256, fold = false) {
     const data = new IndirectComputeDispatchPassData();
 
     /**
@@ -226,7 +303,8 @@ export function graph_build_indirect_dispatch_command(graph, input, workgroup_si
             buffer_input,
             0,
             buffer_command,
-            0
+            0,
+            fold,
         );
     };
 

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Workgroups per dimension that **every** WebGPU device allows.
+ *
+ * `maxComputeWorkgroupsPerDimension` has this as its default, and a device may only report more,
+ * never less — so a shader that writes an indirect dispatch command can fold against this literal
+ * and be certain the command is in range wherever it runs, without the device's own figure having
+ * to reach it through a binding.
+ *
+ * Folding sooner than a particular device would have needed costs nothing: the extents are only
+ * how the workgroups are arranged, and the shaders on the other side flatten them back with
+ * {@link chunk_grid3d_to_index} whatever they are. It is the other direction that is
+ * unrecoverable — a command over the device's limit does not run at all, and nothing reports it.
+ *
+ * {@link build_indirect_compute_dispatch_command} does not use this: it builds its pipeline per
+ * device and inlines the real figure. This is for {@link shader_prefix_sum_to_command}, which is a
+ * shared {@link ComputeShader} compiled once and cannot.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION: number;
+//# sourceMappingURL=WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts.map

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAFU,MAAM,CAE4D"}

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js

@@ -0,0 +1,21 @@
+/**
+ * Workgroups per dimension that **every** WebGPU device allows.
+ *
+ * `maxComputeWorkgroupsPerDimension` has this as its default, and a device may only report more,
+ * never less — so a shader that writes an indirect dispatch command can fold against this literal
+ * and be certain the command is in range wherever it runs, without the device's own figure having
+ * to reach it through a binding.
+ *
+ * Folding sooner than a particular device would have needed costs nothing: the extents are only
+ * how the workgroups are arranged, and the shaders on the other side flatten them back with
+ * {@link chunk_grid3d_to_index} whatever they are. It is the other direction that is
+ * unrecoverable — a command over the device's limit does not run at all, and nothing reports it.
+ *
+ * {@link build_indirect_compute_dispatch_command} does not use this: it builds its pipeline per
+ * device and inlines the real figure. This is for {@link shader_prefix_sum_to_command}, which is a
+ * shared {@link ComputeShader} compiled once and cannot.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION = 65535;

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAuD3B,iDAIG;6BA3G0B,mCAAmC;8BAGlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AA2D3B,iDAIG;6BAhH0B,mCAAmC;8BAIlC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit.js

@@ -3,6 +3,7 @@ import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -52,9 +53,8 @@ export const EMIT_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', EMIT_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -63,9 +63,7 @@ resources.createGroup()
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', EMIT_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 const body = CodeChunk.from(
     /* language=wgsl */
@@ -74,8 +72,14 @@ const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
 const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
 
 @compute @workgroup_size(${PARTICLE_EMIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let i = gid.x;
+fn main(
+    @builtin(workgroup_id) workgroup_id : vec3<u32>,
+    @builtin(num_workgroups) group_count : vec3<u32>,
+    @builtin(local_invocation_index) local_index : u32,
+) {
+    // shader_prefix_sum_to_command folds its count over three dimensions, so the newborn this lane
+    // belongs to is the flattened workgroup, not gid.x. Identical while y and z are 1.
+    let i = grid3d_to_index(workgroup_id, group_count.xy) * ${PARTICLE_EMIT_WORKGROUP_SIZE}u + local_index;
 
     let assignment = particle_emit_assignment(&spawn_prefix.elements, spawn_prefix.count, i);
     if (!assignment.valid) { return; }
@@ -99,6 +103,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     alive_out[a] = slot;
 }
 `, [
+    chunk_grid3d_to_index,
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
 ]);

package/src/shade/renderer/particles/shaders/shader_particle_simulate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAyD/B,qDAIG;iDAvH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_simulate.js

@@ -67,9 +67,8 @@ export const SIMULATE_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', SIMULATE_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -78,9 +77,7 @@ resources.createGroup()
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', SIMULATE_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 
 const body = CodeChunk.from(/* language=wgsl */ `

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CAwUnH"}
+{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CAgUnH"}

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
 import { cpu_build_hash_table } from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
 import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
@@ -22,7 +22,7 @@ import { shader_count_meshlets_by_material } from "./shader_count_meshlets_by_ma
 import {
     shader_make_meshlet_indirect_draw_commands_by_material
 } from "./shader_make_meshlet_indirect_draw_commands_by_material.js";
-import { PUSH_CONSTANTS, shader_read_out_bucket } from "./shader_read_out_bucket.js";
+import { shader_read_out_bucket } from "./shader_read_out_bucket.js";
 import { shader_sort_meshlets_by_material } from "./shader_sort_meshlets_by_material.js";
 
 /**
@@ -83,16 +83,11 @@ export function graph_prepare_meshlet_draw_commands_by_material({
             0
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_settings = encoder.allocateTransientValueBuffer(PUSH_CONSTANTS, {
-            bucket_id,
-        });
-
         shader_read_out_bucket.dispatchIndirect({
             encoder,
             command,
             bindings: {
-                settings: u_settings,
+                settings: { bucket_id },
                 input: buckets_buffer,
                 output,
             }
@@ -165,15 +160,12 @@ export function graph_prepare_meshlet_draw_commands_by_material({
             const hzb = resources.get(data.texture_hzb);
             const command = resources.get(data.command);
 
-            // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-            const u_resolution = encoder.allocateTransientValueBuffer(vec2u, resolution);
-
             shader_hzb_meshlet_filter_1way_full.dispatchIndirect({
                 encoder,
                 command,
                 bindings: {
                     camera: camera_state,
-                    resolution: u_resolution,
+                    resolution,
                     scene_database: scene.scene_database_buffer,
                     meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
                     texture_hzb: hzb.obtainView(),

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.d.ts

@@ -1,5 +1,3 @@
-export const PUSH_CONSTANTS: WebGPUStruct;
 export const shader_read_out_bucket: ComputeShader;
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_read_out_bucket.d.ts.map

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_read_out_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js"],"names":[],"mappings":"AAcA,0CAEG;AAsCH,mDAIE;6BAzD2B,mCAAmC;8BAIlC,+BAA+B"}
+{"version":3,"file":"shader_read_out_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js"],"names":[],"mappings":"AAqDA,mDAIE;8BApD4B,+BAA+B"}

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js

@@ -12,14 +12,13 @@ import {
 
 const resources = new ShaderResourceSetDescriptor();
 
-export const PUSH_CONSTANTS = WebGPUStruct.from({
+const PUSH_CONSTANTS = WebGPUStruct.from({
     bucket_id: u32,
 });
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads 65535 and culls everything. Revert 7c9700b87.
-resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS);
+// per-dispatch, four bytes, read-only: immediate data rather than a pooled buffer, a staging copy
+// and a bind group of its own
+resources.setImmediate("settings", PUSH_CONSTANTS);
 
 resources.createGroup()
     .addStorageBuffer("input", RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_READ)