@woosh/meep-engine 3.27.0 → 3.29.0

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js

@@ -5,12 +5,13 @@ import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_vgeo_cut_claim } from "./chunk_vgeo_cut_claim.js";
+import { chunk_vgeo_cut_queue } from "./chunk_vgeo_cut_queue.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
 import { VGEO_FEEDBACK_OFFSET } from "../layout/VGEO_FEEDBACK_OFFSET.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
 import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
 import { VGEO_PAGE_ROW_NONE } from "../layout/VGEO_PAGE_ROW_NONE.js";
-import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./VGEO_CUT_PARAMS_STRUCT.js";
 import { VGEO_CUT_WORKGROUP_SIZE } from "./VGEO_CUT_WORKGROUP_SIZE.js";
 
@@ -118,36 +119,18 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
      because it is also what stamps the root page as touched, and a root that never reports a touch
      is a root that ages out of the touch-LRU while it is on screen.
      */
-    let ordinal = vg_arena[
-        page_row * params.page_slot_words + ${VGEO_PAGE_ROW_OFFSET.ORDINAL}u
-    ];
-
-    let bit = claim_base + ordinal;
-
-    atomicOr(&claim[bit >> 5u], 1u << (bit & 31u));
-
-    atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.PAGES}u], 1u);
-
-    atomicOr(&feedback[params.touch_bits_base + (page_row >> 5u)], 1u << (page_row & 31u));
-
-    let slot = atomicAdd(&queue_out.count, 1u);
-
-    if (slot >= params.queue_capacity) {
-        atomicAdd(
-            &feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + ${VGEO_CUT_STAT.QUEUE_DROPPED}u], 1u
-        );
-
-        return;
-    }
-
-    let base = slot * 4u;
-
-    queue_out.elements[base] = instance_slot;
-    queue_out.elements[base + 1u] = page_row;
-    queue_out.elements[base + 2u] = 0u;
-    queue_out.elements[base + 3u] = 0u;
+    /*
+     Through the shared claim, and by slice rather than by instance record: the claim base was
+     written to the instance record two lines above and is still in a register here, so the
+     _at form spares the read back. The claim cannot fail — the root is pinned and the capacity
+     bound was taken above — but it is the same code the descent and the reseed run, which is
+     the point of taking it rather than open-coding the three atomics.
+    */
+    vg_claim_page_at(claim_base, capacity, page_row);
+
+    vg_queue_push_root(instance_slot, page_row);
 }
-`, []);
+`, [chunk_vgeo_cut_claim, chunk_vgeo_cut_queue]);
 
 export const shader_vgeo_cut_seed = ComputeShader.from({
     label: "VGeo cut seed",

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

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_traverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js"],"names":[],"mappings":"AAq5BA,qDAIG;8BAt5B2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_traverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js"],"names":[],"mappings":"AAm4BA,qDAIG;8BAp4B2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_traverse.js

@@ -23,6 +23,7 @@ import { VGEO_QUEUE_TARGET_PARENT_BIT } from "../layout/VGEO_QUEUE_TARGET_PARENT
 import { VGEO_QUEUE_TARGET_GROUP_BIT } from "../layout/VGEO_QUEUE_TARGET_GROUP_BIT.js";
 import { VGEO_WANT_WORDS } from "../layout/VGEO_WANT_WORDS.js";
 import { chunk_vgeo_cut_access } from "./chunk_vgeo_cut_access.js";
+import { chunk_vgeo_cut_claim } from "./chunk_vgeo_cut_claim.js";
 import { VGEO_CUT_EXPAND } from "./VGEO_CUT_EXPAND.js";
 import { VGEO_CUT_FLAG_COARSEN } from "./VGEO_CUT_FLAG_COARSEN.js";
 import { VGEO_CUT_FLAG_CULL } from "./VGEO_CUT_FLAG_CULL.js";
@@ -122,8 +123,14 @@ import { VGEO_CUT_WORKGROUP_SIZE } from "./VGEO_CUT_WORKGROUP_SIZE.js";
  *   induction its page is visited. `P` fails `project(self) <= tau`, so it either enqueues `C`'s
  *   page or clamps, and it clamps only when `C`'s group is not selectable, in which case `C` must
  *   not be drawn. Neither cull intervenes: a node's sphere contains `P.parent_sphere` and its
- *   `max_parent_error` is at least `P.parent_error`, so the LOD cull cannot fire, and the frustum
- *   cull fires only where `C` is off-screen anyway.
+ *   `max_parent_error` is at least `P.parent_error`, so the LOD cull cannot fire, and both frustum
+ *   culls are on bounds of `P`'s whole subtree, which contains `C` — so they fire only where `C`
+ *   is off-screen anyway.
+ *
+ * Note that the per-cluster frustum tests do **not** have to agree across a group's several
+ * parents, and nothing here asks them to. A group is claimed and descended once, by whichever
+ * parent reaches it first; a parent that culls itself out simply is not that one. What each test
+ * promises is about its own subtree and nothing else.
  *
  * Descent crosses a page boundary by producing the child page's **node 0**: uniform items, one
  * kernel, no special case for "entering a page". `SAME_PAGE` needs no special case either, because
@@ -237,58 +244,10 @@ fn vg_expand_none() -> VGExpand {
     return VGExpand(VG_EXPAND_NONE, 0u, 0u, 0u, 0u);
 }
 
-fn vg_stat(slot: u32, amount: u32) {
-    atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + slot], amount);
-}
-
-/**
- * Claim a page for one instance, and touch it if the claim was won.
- *
- * The claim is what makes "at most one draw record per (instance, cluster)" true, so an instance
- * whose slice of the bitmask does not fit is refused upstream rather than run unclaimed.
- */
-fn vg_claim_page(instance_base: u32, page_row: u32) -> bool {
-    let ordinal = vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.ORDINAL}u);
-
-    if (ordinal >= instances[instance_base + ${VGEO_INSTANCE_OFFSET.ORDINAL_CAPACITY}u]) {
-        return false;
-    }
-
-    let bit = instances[instance_base + ${VGEO_INSTANCE_OFFSET.CLAIM_BASE}u] + ordinal;
-
-    let word = bit >> 5u;
-
-    if (word >= params.claim_word_count) {
-        return false;
-    }
-
-    let mask = 1u << (bit & 31u);
-
-    if ((atomicOr(&claim[word], mask) & mask) != 0u) {
-        return false;
-    }
-
-    vg_stat(${VGEO_CUT_STAT.PAGES}u, 1u);
-
-    vg_touch_page(page_row);
-
-    return true;
-}
-
-/**
- * Record that this page was selected from this frame — design §6's eviction key.
- *
- * LRU on last-*touched*, never on last-wanted: stamping at fetch time freezes the stamp of exactly
- * the pages that are on screen and evicts them, which is the classic fallback-chain bug the virtual
- * texture cache already keys on touch to avoid.
- *
- * One bit per page row, because the feedback buffer is per frame rather than per invocation: the
- * bit dedups across every view and bucket of the frame and is the record the host reads, so
- * there is no list to fill and no touch a full list could lose.
- */
-fn vg_touch_page(page_row: u32) {
-    atomicOr(&feedback[params.touch_bits_base + (page_row >> 5u)], 1u << (page_row & 31u));
-}
+/*
+ vg_stat, vg_claim_page and vg_touch_page are chunk_vgeo_cut_claim's — the seed and reseed
+ passes take the same three, which is why they are no longer written here.
+*/
 
 /**
  * Ask for the page a clamped cluster could not reach.
@@ -519,23 +478,6 @@ fn vg_visit_cluster(
 
     vg_stat(${VGEO_CUT_STAT.CLUSTERS_TESTED}u, 1u);
 
-    /*
-     Before the cluster can refine, and the reason is residency rather than the draw: refining
-     claims the child page, and a claim is a touch — the LRU's whole input — so an off-screen
-     cluster that refined anyway would keep pages nobody can see hot and the tier full of them.
-     self_sphere contains the cluster's own vertices (FORMAT §7), so this rejects nothing on
-     screen; and every parent of a group shares one self_sphere, so a group's parents decide this
-     uniformly and the cut's proofs stand (RUNTIME_PLAN §4.4).
-     */
-    if ((params.flags & ${VGEO_CUT_FLAG_CULL}u) != 0u
-        && vg_sphere_outside_frustum(
-            instance_base, vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_SPHERE}u)
-        )) {
-        vg_stat(${VGEO_CUT_STAT.CULLED_CLUSTER}u, 1u);
-
-        return vg_expand_none();
-    }
-
     let parent_projected = vg_project(
         vg_arena_f32(row + ${VGEO_CLUSTER_ROW_OFFSET.PARENT_ERROR}u),
         vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.PARENT_SPHERE}u),
@@ -572,6 +514,45 @@ fn vg_visit_cluster(
         );
     }
 
+    /*
+     The frustum, on two bounds of this cluster's whole subtree, and **below the election above**.
+
+     Why here and not at the top of the function. The reason to cull is residency rather than the
+     draw: refining claims the child page, and a claim is a touch — the LRU's whole input — so an
+     off-screen cluster that refined anyway would keep pages nobody can see hot and the tier full of
+     them. A cluster that took the branch above is below the cut: it refines into nothing, claims
+     nothing and draws nothing, so culling it buys residency exactly nothing, while skipping its
+     election costs a coarsen its walk up. The parent that election reaches can protrude on screen
+     past everything under it — that is what a coarser surface covering the same region looks like —
+     and with the test above the election it was never reached, so it was neither drawn nor stood in
+     for. A hole, and the tighter the bound the more often.
+
+     Why two bounds. Both contain every vertex reachable below this cluster, which is what makes
+     either safe to cull a subtree on: self_sphere by the builder's construction and FORMAT §11.7,
+     CULL_BOX by §11.17. The box is much the tighter of the two on real geometry — a subtree is a
+     patch of surface and its box is thin where a sphere is round — and the sphere stays because a
+     container written before the box existed has its cube there instead, and a cube culls less than
+     the sphere inside it.
+    */
+    if ((params.flags & ${VGEO_CUT_FLAG_CULL}u) != 0u) {
+        if (vg_sphere_outside_frustum(
+            instance_base, vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_SPHERE}u)
+        )) {
+            vg_stat(${VGEO_CUT_STAT.CULLED_CLUSTER}u, 1u);
+
+            return vg_expand_none();
+        }
+
+        let cull_box = vg_box_at(row + ${VGEO_CLUSTER_ROW_OFFSET.CULL_BOX}u);
+
+        if (vg_box_outside_frustum(instance_base, cull_box[0], cull_box[1])) {
+            vg_stat(${VGEO_CUT_STAT.CULLED_CLUSTER}u, 1u);
+            vg_stat(${VGEO_CUT_STAT.CULLED_CLUSTER_BOX}u, 1u);
+
+            return vg_expand_none();
+        }
+    }
+
     let self_projected = vg_project(
         vg_arena_f32(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_ERROR}u),
         vg_sphere_at(row + ${VGEO_CLUSTER_ROW_OFFSET.SELF_SPHERE}u),
@@ -906,6 +887,7 @@ fn main(
 }
 `, [
     chunk_vgeo_cut_access,
+    chunk_vgeo_cut_claim,
     MESHLET_DEFINITION_STRUCT.declaration_chunk,
 ]);
 

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

@@ -6,5 +6,6 @@ export namespace VGEO_CLUSTER_ROW_OFFSET {
     let CHILD_PAGE_INDEX: number;
     let CHILD_GROUP: number;
     let CHILD_REF: number;
+    let CULL_BOX: number;
 }
 //# sourceMappingURL=VGEO_CLUSTER_ROW_OFFSET.d.ts.map

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/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"}