@woosh/meep-engine 3.27.0 → 3.29.0

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

@@ -1,27 +1,18 @@
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { VGEO_CLUSTER_ROW_WORDS } from "../layout/VGEO_CLUSTER_ROW_WORDS.js";
-import { VGEO_GEOMETRY_ROW_WORDS } from "../layout/VGEO_GEOMETRY_ROW_WORDS.js";
-import { VGEO_GROUP_ROW_WORDS } from "../layout/VGEO_GROUP_ROW_WORDS.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
-import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
-import { VGEO_NODE_ROW_LEAF_BIT } from "../layout/VGEO_NODE_ROW_LEAF_BIT.js";
-import { VGEO_NODE_ROW_OFFSET } from "../layout/VGEO_NODE_ROW_OFFSET.js";
-import { VGEO_NODE_ROW_WORDS } from "../layout/VGEO_NODE_ROW_WORDS.js";
-import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
-import { VGEO_PAGE_ROW_WORDS } from "../layout/VGEO_PAGE_ROW_WORDS.js";
-import { VGEO_PARENT_ROW_WORDS } from "../layout/VGEO_PARENT_ROW_WORDS.js";
+import { chunk_vgeo_cut_arena } from "./chunk_vgeo_cut_arena.js";
 
 /**
- * Addressing and arithmetic shared by every pass of the cut — how to find a row, and how to project
- * an error.
+ * The arithmetic the cut rule is written in: where the camera is in an instance's own space, what
+ * an object-space error projects to in pixels, and whether a sphere is worth descending into at all.
  *
- * The arena is `array<u32>` with hand-written accessors rather than a marshalled struct array,
- * because it holds three different row types in one allocation per page and no struct array can say
- * that. The offsets it indexes with are the `layout/` constants, so the CPU writer and the kernel
- * are reading the same numbers rather than two copies of them.
+ * Addressing moved to {@link chunk_vgeo_cut_arena}, which this pulls in — a pass that only wants to
+ * find a row should not have to take the frustum test with it, and the passes that did not want to
+ * wrote their own accessor instead.
  *
- * Every buffer named here has to be declared by the importing shader. That is the price of sharing
- * addressing across passes, and it is the same bargain `chunk_scene_database_access` makes.
+ * Every buffer named here has to be declared by the importing shader — `instances`, plus whatever
+ * the arena chunk needs. That is the price of sharing addressing across passes, and it is the same
+ * bargain `chunk_scene_database_access` makes.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -30,17 +21,6 @@ import { VGEO_PARENT_ROW_WORDS } from "../layout/VGEO_PARENT_ROW_WORDS.js";
 export const chunk_vgeo_cut_access = CodeChunk.from(
     //language=WGSL
     `
-const VG_PAGE_ROW_WORDS = ${VGEO_PAGE_ROW_WORDS}u;
-const VG_NODE_ROW_WORDS = ${VGEO_NODE_ROW_WORDS}u;
-const VG_GROUP_ROW_WORDS = ${VGEO_GROUP_ROW_WORDS}u;
-const VG_CLUSTER_ROW_WORDS = ${VGEO_CLUSTER_ROW_WORDS}u;
-const VG_PARENT_ROW_WORDS = ${VGEO_PARENT_ROW_WORDS}u;
-const VG_INSTANCE_WORDS = ${VGEO_INSTANCE_WORDS}u;
-const VG_GEOMETRY_ROW_WORDS = ${VGEO_GEOMETRY_ROW_WORDS}u;
-
-const VG_NODE_LEAF_BIT = ${VGEO_NODE_ROW_LEAF_BIT}u;
-const VG_NODE_CHILD_COUNT_MASK = 0xffu;
-
 /**
  * Any error at or above this is the root's +infinity, however the file spelled it.
  *
@@ -51,63 +31,6 @@ const VG_NODE_CHILD_COUNT_MASK = 0xffu;
 const VG_ERROR_INFINITE = 3.0e38;
 const VG_PROJECTION_MAX = 3.4e38;
 
-/**
- * A page's slot: its header, then its node, group and cluster rows.
- *
- * The stride is a uniform rather than a constant because the tier derives it from the page size its
- * containers are bounded at, and it is a **multiply** rather than a table read because format
- * §11.14 made that legal — design §6 asked for fixed-size page slots from the start and the bound
- * is what it was waiting for. There is no page table, no allocator, and no second storage binding
- * to keep coherent with this one.
- */
-fn vg_slot_base(page_row: u32) -> u32 {
-    return page_row * params.page_slot_words;
-}
-
-fn vg_page_field(page_row: u32, field: u32) -> u32 {
-    return vg_arena[vg_slot_base(page_row) + field];
-}
-
-fn vg_node_base(page_row: u32) -> u32 {
-    return vg_slot_base(page_row) + VG_PAGE_ROW_WORDS;
-}
-
-fn vg_group_base(page_row: u32) -> u32 {
-    return vg_node_base(page_row)
-        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.NODE_COUNT}u) * VG_NODE_ROW_WORDS;
-}
-
-fn vg_cluster_base(page_row: u32) -> u32 {
-    return vg_group_base(page_row)
-        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.GROUP_COUNT}u) * VG_GROUP_ROW_WORDS;
-}
-
-/**
- * The fourth section: this page's parent rows, which is where a walk *up* reads.
- *
- * It may be empty, and a reader has to check rather than assume: the page row's parent
- * entry count is zero for
- * every page of a container written before format 4, which has no upward edge at all. Zero is not a
- * malformed page; it is an asset that can only be re-descended.
- */
-fn vg_parent_base(page_row: u32) -> u32 {
-    return vg_cluster_base(page_row)
-        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.CLUSTER_COUNT}u) * VG_CLUSTER_ROW_WORDS;
-}
-
-fn vg_arena_f32(word: u32) -> f32 {
-    return bitcast<f32>(vg_arena[word]);
-}
-
-fn vg_sphere_at(word: u32) -> vec4<f32> {
-    return vec4<f32>(
-        bitcast<f32>(vg_arena[word]),
-        bitcast<f32>(vg_arena[word + 1u]),
-        bitcast<f32>(vg_arena[word + 2u]),
-        bitcast<f32>(vg_arena[word + 3u])
-    );
-}
-
 fn vg_instance_f32(instance_base: u32, field: u32) -> f32 {
     return bitcast<f32>(instances[instance_base + field]);
 }
@@ -123,7 +46,7 @@ fn vg_instance_eye(instance_base: u32) -> vec3<f32> {
 /**
  * \`err_px = r_e * screen_height / (2 * tan(fov_y / 2) * d)\`, with \`d\` the distance to the
  * **closest point** of the sphere — design §4, and written in that order so that it agrees with
- * \`select_cut.js\` term for term rather than merely in the limit.
+ * \`vgeo_select_cut\` term for term rather than merely in the limit.
  *
  * Two conventions carry real weight. A zero error projects to zero **unconditionally**, so a leaf
  * — whose error is exactly zero — does not become undrawable the moment the camera enters its
@@ -172,4 +95,38 @@ fn vg_sphere_outside_frustum(instance_base: u32, sphere: vec4<f32>) -> bool {
 
     return false;
 }
-`, []);
+
+/**
+ * Whether a box is entirely outside the instance's object-space frustum.
+ *
+ * The same five planes, and one corner per plane rather than eight: the corner furthest along the
+ * plane's normal is the last of the box to leave the half-space, so if *it* is behind the plane the
+ * whole box is. Picking it per axis by the normal's sign is three selects and no branch.
+ *
+ * Unlike the sphere test this one does not care whether the planes are normalized — it compares a
+ * signed distance against zero rather than against a radius — which matters because the planes are
+ * the instance's own, pulled into object space through a transform that may not be a rotation.
+ *
+ * It is conservative in the direction that costs a visit rather than a hole: a box that lies past a
+ * frustum edge without crossing any single plane's half-space passes, and is descended into.
+ */
+fn vg_box_outside_frustum(instance_base: u32, lower: vec3<f32>, upper: vec3<f32>) -> bool {
+    for (var plane = 0u; plane < 5u; plane = plane + 1u) {
+        let word = instance_base + ${VGEO_INSTANCE_OFFSET.FRUSTUM}u + plane * 4u;
+
+        let normal = vec3<f32>(
+            bitcast<f32>(instances[word]),
+            bitcast<f32>(instances[word + 1u]),
+            bitcast<f32>(instances[word + 2u])
+        );
+
+        let far_corner = select(lower, upper, normal >= vec3<f32>(0.0));
+
+        if (dot(normal, far_corner) + bitcast<f32>(instances[word + 3u]) < 0.0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+`, [chunk_vgeo_cut_arena]);

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

@@ -0,0 +1,19 @@
+/**
+ * Where a row is, in the arena — and nothing else.
+ *
+ * Split out of {@link chunk_vgeo_cut_access} because three passes want an address and only one of
+ * them wants a projection. Before the split, a pass that needed one field of a page header wrote
+ * its own accessor rather than take a chunk that also declares the frustum test, the instance eye
+ * and the error projection; `shader_vgeo_cut_reseed` said so where its copy was
+ * (`vg_reseed_page_field`). The answer to "the chunk declares more than this pass binds" is a
+ * smaller chunk, not a second accessor.
+ *
+ * Requires the importing shader to declare `params` and `vg_arena`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_arena: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_cut_arena.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vgeo_cut_arena.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_arena.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH,mCAFU,SAAS,CA0FZ;0BAnHmB,0CAA0C"}

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

@@ -0,0 +1,116 @@
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { VGEO_CLUSTER_ROW_WORDS } from "../layout/VGEO_CLUSTER_ROW_WORDS.js";
+import { VGEO_GEOMETRY_ROW_WORDS } from "../layout/VGEO_GEOMETRY_ROW_WORDS.js";
+import { VGEO_GROUP_ROW_WORDS } from "../layout/VGEO_GROUP_ROW_WORDS.js";
+import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
+import { VGEO_NODE_ROW_LEAF_BIT } from "../layout/VGEO_NODE_ROW_LEAF_BIT.js";
+import { VGEO_NODE_ROW_WORDS } from "../layout/VGEO_NODE_ROW_WORDS.js";
+import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
+import { VGEO_PAGE_ROW_WORDS } from "../layout/VGEO_PAGE_ROW_WORDS.js";
+import { VGEO_PARENT_ROW_WORDS } from "../layout/VGEO_PARENT_ROW_WORDS.js";
+
+/**
+ * Where a row is, in the arena — and nothing else.
+ *
+ * Split out of {@link chunk_vgeo_cut_access} because three passes want an address and only one of
+ * them wants a projection. Before the split, a pass that needed one field of a page header wrote
+ * its own accessor rather than take a chunk that also declares the frustum test, the instance eye
+ * and the error projection; `shader_vgeo_cut_reseed` said so where its copy was
+ * (`vg_reseed_page_field`). The answer to "the chunk declares more than this pass binds" is a
+ * smaller chunk, not a second accessor.
+ *
+ * Requires the importing shader to declare `params` and `vg_arena`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_arena = CodeChunk.from(
+    //language=WGSL
+    `
+const VG_PAGE_ROW_WORDS = ${VGEO_PAGE_ROW_WORDS}u;
+const VG_NODE_ROW_WORDS = ${VGEO_NODE_ROW_WORDS}u;
+const VG_GROUP_ROW_WORDS = ${VGEO_GROUP_ROW_WORDS}u;
+const VG_CLUSTER_ROW_WORDS = ${VGEO_CLUSTER_ROW_WORDS}u;
+const VG_PARENT_ROW_WORDS = ${VGEO_PARENT_ROW_WORDS}u;
+const VG_INSTANCE_WORDS = ${VGEO_INSTANCE_WORDS}u;
+const VG_GEOMETRY_ROW_WORDS = ${VGEO_GEOMETRY_ROW_WORDS}u;
+
+const VG_NODE_LEAF_BIT = ${VGEO_NODE_ROW_LEAF_BIT}u;
+const VG_NODE_CHILD_COUNT_MASK = 0xffu;
+
+/**
+ * A page's slot: its header, then its node, group and cluster rows.
+ *
+ * The stride is a uniform rather than a constant because the tier derives it from the page size its
+ * containers are bounded at, and it is a **multiply** rather than a table read because format
+ * §11.14 made that legal — design §6 asked for fixed-size page slots from the start and the bound
+ * is what it was waiting for. There is no page table, no allocator, and no second storage binding
+ * to keep coherent with this one.
+ */
+fn vg_slot_base(page_row: u32) -> u32 {
+    return page_row * params.page_slot_words;
+}
+
+fn vg_page_field(page_row: u32, field: u32) -> u32 {
+    return vg_arena[vg_slot_base(page_row) + field];
+}
+
+fn vg_node_base(page_row: u32) -> u32 {
+    return vg_slot_base(page_row) + VG_PAGE_ROW_WORDS;
+}
+
+fn vg_group_base(page_row: u32) -> u32 {
+    return vg_node_base(page_row)
+        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.NODE_COUNT}u) * VG_NODE_ROW_WORDS;
+}
+
+fn vg_cluster_base(page_row: u32) -> u32 {
+    return vg_group_base(page_row)
+        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.GROUP_COUNT}u) * VG_GROUP_ROW_WORDS;
+}
+
+/**
+ * The fourth section: this page's parent rows, which is where a walk *up* reads.
+ *
+ * It may be empty, and a reader has to check rather than assume: the page row's parent
+ * entry count is zero for
+ * every page of a container written before format 4, which has no upward edge at all. Zero is not a
+ * malformed page; it is an asset that can only be re-descended.
+ */
+fn vg_parent_base(page_row: u32) -> u32 {
+    return vg_cluster_base(page_row)
+        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.CLUSTER_COUNT}u) * VG_CLUSTER_ROW_WORDS;
+}
+
+fn vg_arena_f32(word: u32) -> f32 {
+    return bitcast<f32>(vg_arena[word]);
+}
+
+fn vg_sphere_at(word: u32) -> vec4<f32> {
+    return vec4<f32>(
+        bitcast<f32>(vg_arena[word]),
+        bitcast<f32>(vg_arena[word + 1u]),
+        bitcast<f32>(vg_arena[word + 2u]),
+        bitcast<f32>(vg_arena[word + 3u])
+    );
+}
+
+/**
+ * Six consecutive words as an axis-aligned box: the lower corner, then the upper.
+ */
+fn vg_box_at(word: u32) -> array<vec3<f32>, 2> {
+    return array<vec3<f32>, 2>(
+        vec3<f32>(
+            bitcast<f32>(vg_arena[word]),
+            bitcast<f32>(vg_arena[word + 1u]),
+            bitcast<f32>(vg_arena[word + 2u])
+        ),
+        vec3<f32>(
+            bitcast<f32>(vg_arena[word + 3u]),
+            bitcast<f32>(vg_arena[word + 4u]),
+            bitcast<f32>(vg_arena[word + 5u])
+        )
+    );
+}
+`, []);

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

@@ -0,0 +1,31 @@
+/**
+ * One page, claimed once per instance, and touched when the claim is won.
+ *
+ * This is the invariant the whole cut rests on — "at most one draw record per (instance, cluster)" —
+ * and it was written out three times: here's-the-original in `shader_vgeo_cut_traverse`, a
+ * line-for-line copy in `shader_vgeo_cut_reseed`, and inline in `shader_vgeo_cut_seed`. The
+ * copies had already begun to differ: the seed pass omitted the `claim_word_count` bound the other
+ * two take. It was correct — the seed pass establishes that bound a few lines earlier — but a
+ * correctness invariant whose three spellings disagree about which checks it needs is one nobody
+ * can read off the source any more.
+ *
+ * The touch is the other half and travels with it, because a claim that does not stamp the page is
+ * a page that ages out of the LRU while it is on screen. LRU on last-**touched**, never on
+ * last-wanted: stamping at fetch time freezes the stamp of exactly the pages that are being drawn
+ * and evicts them, which is the 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.
+ *
+ * Requires the importing shader to declare `params`, `vg_arena`, `instances`, `claim` and
+ * `feedback`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_claim: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_cut_claim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vgeo_cut_claim.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_claim.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mCAFU,SAAS,CAiEQ;0BAlGD,0CAA0C"}

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

@@ -0,0 +1,99 @@
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.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_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
+import { chunk_vgeo_cut_arena } from "./chunk_vgeo_cut_arena.js";
+
+/**
+ * One page, claimed once per instance, and touched when the claim is won.
+ *
+ * This is the invariant the whole cut rests on — "at most one draw record per (instance, cluster)" —
+ * and it was written out three times: here's-the-original in `shader_vgeo_cut_traverse`, a
+ * line-for-line copy in `shader_vgeo_cut_reseed`, and inline in `shader_vgeo_cut_seed`. The
+ * copies had already begun to differ: the seed pass omitted the `claim_word_count` bound the other
+ * two take. It was correct — the seed pass establishes that bound a few lines earlier — but a
+ * correctness invariant whose three spellings disagree about which checks it needs is one nobody
+ * can read off the source any more.
+ *
+ * The touch is the other half and travels with it, because a claim that does not stamp the page is
+ * a page that ages out of the LRU while it is on screen. LRU on last-**touched**, never on
+ * last-wanted: stamping at fetch time freezes the stamp of exactly the pages that are being drawn
+ * and evicts them, which is the 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.
+ *
+ * Requires the importing shader to declare `params`, `vg_arena`, `instances`, `claim` and
+ * `feedback`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_claim = CodeChunk.from(
+    //language=WGSL
+    `
+fn vg_stat(slot: u32, amount: u32) {
+    atomicAdd(&feedback[${VGEO_FEEDBACK_OFFSET.STATS}u + slot], amount);
+}
+
+/**
+ * Record that this page was selected from this frame — design §6's eviction key.
+ */
+fn vg_touch_page(page_row: u32) {
+    atomicOr(&feedback[params.touch_bits_base + (page_row >> 5u)], 1u << (page_row & 31u));
+}
+
+/**
+ * The claim itself, against a slice of the bitmask the caller already has in hand.
+ *
+ * Taken this way rather than always through the instance record because the seed pass computes the
+ * slice base in the same invocation that claims with it — it has just written it to the instance
+ * record, and reading it straight back would be a storage round trip for a value already in a
+ * register.
+ *
+ * @returns whether this invocation is the one that claimed the page
+ */
+fn vg_claim_page_at(claim_base: u32, ordinal_capacity: u32, page_row: u32) -> bool {
+    let ordinal = vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.ORDINAL}u);
+
+    if (ordinal >= ordinal_capacity) {
+        return false;
+    }
+
+    let bit = claim_base + 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;
+}
+
+/**
+ * The same claim, for a caller holding an instance rather than its slice. An instance whose slice
+ * of the bitmask does not fit is refused upstream, in the seed pass, rather than run unclaimed.
+ */
+fn vg_claim_page(instance_base: u32, page_row: u32) -> bool {
+    return vg_claim_page_at(
+        instances[instance_base + ${VGEO_INSTANCE_OFFSET.CLAIM_BASE}u],
+        instances[instance_base + ${VGEO_INSTANCE_OFFSET.ORDINAL_CAPACITY}u],
+        page_row
+    );
+}
+`, [chunk_vgeo_cut_arena]);

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

@@ -0,0 +1,17 @@
+/**
+ * Put one page on the wavefront queue at its root node.
+ *
+ * Both passes that start a descent — the seed, from an instance's root page, and the reseed, from
+ * last frame's frontier — push the same four words and drop on the same bound, and both wrote it
+ * out. `shader_vgeo_cut_traverse` does not use this: it reserves a run for a whole workgroup's
+ * spill in one `atomicAdd` and writes into it, which is a different thing wearing the same words.
+ *
+ * Requires the importing shader to declare `params`, `queue_out` and `feedback`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_queue: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_cut_queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vgeo_cut_queue.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_queue.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,mCAFU,SAAS,CAsBQ;0BAtCD,0CAA0C"}

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

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
+import { chunk_vgeo_cut_claim } from "./chunk_vgeo_cut_claim.js";
+
+/**
+ * Put one page on the wavefront queue at its root node.
+ *
+ * Both passes that start a descent — the seed, from an instance's root page, and the reseed, from
+ * last frame's frontier — push the same four words and drop on the same bound, and both wrote it
+ * out. `shader_vgeo_cut_traverse` does not use this: it reserves a run for a whole workgroup's
+ * spill in one `atomicAdd` and writes into it, which is a different thing wearing the same words.
+ *
+ * Requires the importing shader to declare `params`, `queue_out` and `feedback`.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_queue = CodeChunk.from(
+    //language=WGSL
+    `
+fn vg_queue_push_root(instance_slot: u32, page_row: u32) {
+    let slot = atomicAdd(&queue_out.count, 1u);
+
+    if (slot >= params.queue_capacity) {
+        vg_stat(${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;
+    // node 0, which is how every page visit in this runtime begins
+    queue_out.elements[base + 2u] = 0u;
+    queue_out.elements[base + 3u] = 0u;
+}
+`, [chunk_vgeo_cut_claim]);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_reseed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_reseed.js"],"names":[],"mappings":"AAqLA,mDAIG;8BAtL2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_reseed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_reseed.js"],"names":[],"mappings":"AA6HA,mDAIG;8BA9H2B,qCAAqC"}

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

@@ -3,9 +3,9 @@ import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.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 { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.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";
@@ -70,46 +70,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-/**
- * A field of a page's slot header. Indexed rather than read through the traversal's accessors,
- * because those come with a chunk that declares rather more than this pass binds.
- */
-fn vg_reseed_page_field(page_row: u32, field: u32) -> u32 {
-    return vg_arena[page_row * params.page_slot_words + field];
-}
-
-/**
- * The claim, and the touch that goes with it — the seed pass's, taken against a page row that came
- * off a bitmask rather than off a reference already resolved.
- */
-fn vg_reseed_claim(instance_base: u32, page_row: u32) -> bool {
-    let ordinal = vg_reseed_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;
-    }
-
-    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));
-
-    return true;
-}
-
 @compute @workgroup_size(${VGEO_CUT_WORKGROUP_SIZE})
 fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     let rows = params.frontier_word_count * 32u;
@@ -145,8 +105,8 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
      would reject the ordinal eventually, but the geometry row is the honest test and it is two
      reads of a header that is already in cache.
     */
-    if (vg_reseed_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.GEOMETRY_ROW}u)
-        != vg_reseed_page_field(root_row, ${VGEO_PAGE_ROW_OFFSET.GEOMETRY_ROW}u)) {
+    if (vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.GEOMETRY_ROW}u)
+        != vg_page_field(root_row, ${VGEO_PAGE_ROW_OFFSET.GEOMETRY_ROW}u)) {
         return;
     }
 
@@ -155,29 +115,13 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
      which is the LRU's whole input, and it is what stops a page reached both from the frontier and
      from a descent later in this same cut from being drawn twice.
     */
-    if (!vg_reseed_claim(instance_base, page_row)) {
+    if (!vg_claim_page(instance_base, page_row)) {
         return;
     }
 
-    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;
-    // node 0, which is how every page visit in this runtime begins
-    queue_out.elements[base + 2u] = 0u;
-    queue_out.elements[base + 3u] = 0u;
+    vg_queue_push_root(instance_slot, page_row);
 }
-`, []);
+`, [chunk_vgeo_cut_claim, chunk_vgeo_cut_queue]);
 
 export const shader_vgeo_cut_reseed = ComputeShader.from({
     label: "VGeo cut reseed",

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

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_seed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js"],"names":[],"mappings":"AAuJA,iDAIG;8BAtJ2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_seed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_seed.js"],"names":[],"mappings":"AAsIA,iDAIG;8BArI2B,qCAAqC"}