@woosh/meep-engine 3.28.0 → 3.30.0

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

@@ -5,10 +5,12 @@
  * `VIRTUAL_GEOMETRY_DESIGN.md` §7 says why it exists rather than the cut reading the meshlet
  * metadata pool: freed slices of that pool hold garbage, and it carries no error pairs at all.
  *
- * The row is the cut rule's operands and its edge, and nothing more. Culling bounds
- * (`bounds_sphere`, `aabb`) are deliberately absent — the `aabb` becomes the meshlet metadata's
- * `bounds_box` at install and is culled downstream by the HZB filter, so carrying it here would be
- * a second copy read by nobody.
+ * The row is the cut rule's operands, its edge, and the bound its frustum test needs. The
+ * cluster's own `aabb` is deliberately absent — it becomes the meshlet metadata's `bounds_box` at
+ * install and is culled downstream by the HZB filter, so carrying it here would be a second copy
+ * read by nobody. {@link CULL_BOX} is a different box and not a second copy of anything: it bounds
+ * the cluster's whole subtree, which is what the cut's own test needs and what no other stage has
+ * any use for.
  *
  * `child_page_index` is **resolved at install**: a `SAME_PAGE` reference stores the owning page's
  * own global index, so the kernel's lookup path is uniform and there is no `SAME_PAGE` branch
@@ -48,4 +50,20 @@ export const VGEO_CLUSTER_ROW_OFFSET = {
      * *through*, which `VGEO_FORMAT.md` §10 wants for in-flight pinning.
      */
     CHILD_REF: 12,
+    /**
+     * The format's `subtree_aabb` (§7): this cluster's geometry and everything reachable below it,
+     * as `min xyz, max xyz`.
+     *
+     * The cut's per-cluster frustum test reads it, and it has to bound the subtree rather than the
+     * cluster because culling a cluster takes its whole child group out of the descent — a bound
+     * around the cluster alone would cull a parent with on-screen descendants
+     * (`CULL_PLAN_2026_09_16` §1). It is six words against the LOD sphere's four and worth them:
+     * measured on a converted Zorah container it visits 18% fewer pages at rest and 35–40% fewer at
+     * other viewpoints, where the tightest possible *sphere* was worth 5%.
+     *
+     * {@link SELF_SPHERE} stays and is still tested first — it is the projection's operand, so it is
+     * in the row either way, and for a container written before the box existed it is the only
+     * subtree bound there is.
+     */
+    CULL_BOX: 13,
 };

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

@@ -2,8 +2,13 @@
  * 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

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/probe/octahedral/GPUProbeAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;GAEG;AAIH;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;;OAQG;IACH;QAHsC,WAAW,EAAtC,iBAAiB;QACU,cAAc,EAAzC,iBAAiB;aAY3B;IAED;;;;;;;OAOG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACU,QAAQ,EAAjC,eAAe;QACE,gBAAgB,GAAjC,MAAM;eAuQhB;IAED,+BAGC;IAED,gBAGC;;CACJ;8BA9bY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;yBAI3D,OAAO,iEAAiE,EAAE,UAAU;kCAnB/D,uCAAuC"}
+{"version":3,"file":"GPUProbeAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;GAEG;AAIH;IAyEI;;;OAGG;IACH,+BAgBC;IAtFD;;;OAGG;IACH,0CAEC;IAGD;;;OAGG;IACH,2BAUC;IAQD;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,sCAGC;IAED;;;OAGG;IACH,QAFU,MAAM,MAAM,CAEM;IAgC5B;;;;OAIG;IACH,6BAFW,MAAM,QAiChB;IAED;;;;;;;;OAQG;IACH;QAHsC,WAAW,EAAtC,iBAAiB;QACU,cAAc,EAAzC,iBAAiB;aAY3B;IAED;;;;;;;OAOG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACU,QAAQ,EAAjC,eAAe;QACE,gBAAgB,GAAjC,MAAM;eAgRhB;IAED,+BAGC;IAED,gBAGC;;CACJ;8BAvcY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;yBAI3D,OAAO,iEAAiE,EAAE,UAAU;kCAnB/D,uCAAuC"}

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

@@ -317,9 +317,18 @@ export class GPUProbeAtlas {
         */
         let t_radiance = graph_import_texture(graph, this.texture_radiance);
         let t_depth = graph_import_texture(graph, this.#texture_depth);
-        const b_probes = graph_import_buffer(graph, scene.light_probe_volume.buffer_probes)
+        const b_probes = graph_import_buffer(graph, scene.light_probe_volume.buffer_probes);
 
-        ({ radiance: t_radiance } = graph_lpv_shade({
+        /*
+         Plain assignment off the returned record, not a parenthesised destructuring assignment. The
+         line above used to end without a semicolon, and ASI does not insert one before an open
+         paren, so the two statements parsed as a single call expression: the handle
+         `graph_import_buffer` returns was invoked as a function and `graph_update` threw a TypeError
+         out of `Renderer.update_lpv` on its first frame, after `graph_lpv_shade` had already added
+         its pass and before the depth accumulation, border painting, SH convolution and SH store
+         were scheduled at all. This shape cannot recur.
+        */
+        t_radiance = graph_lpv_shade({
             graph,
             scene,
             atlas: this,
@@ -335,7 +344,7 @@ export class GPUProbeAtlas {
             g_buffer_pbr,
             g_buffer_position,
             g_buffer_indirect,
-        }));
+        }).radiance;
 
         // avoid upsetting WebGPU validator with empty buffers
         if (update_count > 0) {

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/light/environment/rgbe/RGBE_ReadPixels_RLE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RGBE_ReadPixels_RLE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,wCAFW,UAAU,kBAkGpB;AAED;;;;;;GAMG;AACH,4CALW,UAAU,KACV,MAAM,KACN,MAAM,GACJ,UAAU,CAmItB;+BAxU8B,qBAAqB"}
+{"version":3,"file":"RGBE_ReadPixels_RLE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js"],"names":[],"mappings":"AAiGA;;;GAGG;AACH,wCAFW,UAAU,kBAkGpB;AAED;;;;;;GAMG;AACH,4CALW,UAAU,KACV,MAAM,KACN,MAAM,GACJ,UAAU,CAmItB;+BA9U8B,qBAAqB"}

package/src/shade/renderer/light/environment/rgbe/RGBE_ReadPixels_RLE.js

@@ -64,7 +64,13 @@ function fgets(buffer, lineLimit = 1024, consume = true) {
         s += chunk;
         len += chunk.length;
         p += chunkSize;
-        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
+
+        //`=`, not `+=`. Appending left `chunk` holding every chunk read so far while `s` already
+        //held them, so the line came back with its first 128 characters repeated and `len` — which
+        //line 81 below adds to `buffer.pos` — overshot the real line end by 128 per extra read.
+        //Every later `fgets` then read from the wrong offset, and a header with a comment longer
+        //than one chunk, which Radiance writers emit as a matter of course, was rejected outright.
+        chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
 
     }
 

package/src/shade/renderer/lightmap/GPULightMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAmBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBA0DC;IAED,iBA+DC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCA3UiC,iCAAiC"}
+{"version":3,"file":"GPULightMap.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/lightmap/GPULightMap.js"],"names":[],"mappings":"AAmBA;IAgCI;;;OAGG;IACH,+BA6CC;IA/ED;;;OAGG;IACH,WAFU,iBAAiB,GAAC,IAAI,CAEf;IACjB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IACpB;;;OAGG;IACH,cAFU,iBAAiB,GAAC,IAAI,CAEZ;IAEpB;;;OAGG;IACH,aAFU,iBAAiB,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yBAEC;IA2ED;;;;OAIG;IACH,wEAmCC;IA6BD;;OAEG;IACH,oBA0DC;IAED,iBA4EC;IAED;;;;OAIG;IACH,kEAQC;;CAEJ;kCAxViC,iCAAiC"}