@woosh/meep-engine 3.57.0 → 3.59.0

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

@@ -8,140 +8,17 @@ import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { MESHLET_COLLECTION_WRITE_STRUCT } from "../../../../rasterize/MESHLET_COLLECTION_WRITE_STRUCT.js";
 import { MESHLET_DEFINITION_STRUCT } from "../../../meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
-import { VGEO_CLUSTER_ROW_OFFSET } from "../layout/VGEO_CLUSTER_ROW_OFFSET.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
-import { VGEO_GROUP_FLAG_SELECTABLE } from "../layout/VGEO_GROUP_FLAG_SELECTABLE.js";
-import { VGEO_GROUP_ROW_OFFSET } from "../layout/VGEO_GROUP_ROW_OFFSET.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
-import { VGEO_NODE_ROW_OFFSET } from "../layout/VGEO_NODE_ROW_OFFSET.js";
-import { VGEO_NO_CHILD_PAGE } from "../layout/VGEO_NO_CHILD_PAGE.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_PARENT_ROW_OFFSET } from "../layout/VGEO_PARENT_ROW_OFFSET.js";
-import { VGEO_QUEUE_TARGET_PARENT_BIT } from "../layout/VGEO_QUEUE_TARGET_PARENT_BIT.js";
-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 { chunk_vgeo_cut_descent } from "./chunk_vgeo_cut_descent.js";
 import { VGEO_CUT_FLAG_CULL } from "./VGEO_CUT_FLAG_CULL.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./VGEO_CUT_PARAMS_STRUCT.js";
-import { VGEO_CUT_WORKGROUP_SIZE } from "./VGEO_CUT_WORKGROUP_SIZE.js";
 
 /**
- * The virtual-geometry cut — design §7's pass, as a descent that lives inside one dispatch.
- *
- * ## The rule
- *
- * A cluster is drawn iff
- *
- * > `own group selectable AND project(parent) > tau AND (project(self) <= tau OR child group not
- * > selectable)`
- *
- * which is design §4's per-cluster form together with its first term. That term is load-bearing
- * and §4 states the rule without it: a group that is resident but not yet selectable has clusters
- * satisfying the rest of the rule while their coarse stand-in is drawn over the same surface, a few
- * microns apart, with the depth buffer choosing between them. That reads as corrupt geometry rather
- * than as a missing page, which is what makes it hard to attribute and worth stating first.
- *
- * ## The shape
- *
- * The loop over depth is *inside* this kernel: a dispatch is a spill generation rather than a level
- * of the descent. Depth is what a cut costs. Measured on a 28M-face container at tau = 1 on a 4090:
- * the descent converges at **39 levels**, carrying 15,027 items — an average frontier of 385 items,
- * or **six workgroups of 64 on a 128-SM part** — and an empty prepare/traverse pair costs 3.9 us
- * whatever it contains. Page depth grows like log2(triangles), so a dispatch per level gets *worse*
- * with better assets and no better with a faster GPU.
- *
- * What a lane cannot do is wait for another workgroup: WebGPU guarantees no forward progress across
- * workgroups, so persistent threads over an MPMC queue — Nanite's answer — is unbounded waiting.
- * What a lane *can* do is cooperate with the other lanes of its own subgroup, and that is enough:
- *
- * - Every lane executes its item and says how many children it produced. No lane walks its own
- *   subtree while its neighbours idle; production is a **count**, at constant cost.
- * - `subgroupExclusiveAdd` over those counts numbers the wave's whole production densely. The first
- *   `subgroup_size` of them are taken back into the wave's own lanes — perfectly packed, one child
- *   per lane, whoever produced them — and the descent takes another step without touching memory.
- * - Everything past a full wave **spills** to the global queue under one `atomicAdd`. Breadth the
- *   wave cannot hold becomes work for other waves rather than a serial loop inside this one.
- *
- * So the number of dispatches is the number of spill generations, and the narrow top of the DAG —
- * twenty levels that move between 1 and 120 items and draw nothing — is one wave taking twenty
- * steps in registers.
- *
- * This is Karis' "Variable sized work" (graphicrants, 2026-03) with its groupshared scatter
- * removed. That scatter needs HLSL's `GroupMemoryBarrier()` — memory ordering with no execution
- * sync, sound because a wave is in lockstep — and WGSL has no memory-only workgroup barrier.
- * `workgroupBarrier` synchronizes execution as well, which pins every subgroup of the workgroup to
- * the same number of steps and is a deadlock the moment they disagree; `workgroupUniformLoad` is
- * that same control barrier plus a load, and what it returns is one value uniform across the
- * workgroup, which is the opposite of the per-lane read a scatter is made of.
- * {@link vg_child_owner} finds each item's producer by binary search over the same prefix sums
- * instead: `log2(subgroup_size)` shuffles, no workgroup memory and no barrier anywhere in this
- * file, so nothing here needs the workgroup to agree on anything.
- *
- * ## What WGSL will not let this do
- *
- * Every loop around a subgroup operation needs a **uniform trip count**, and nothing launders one —
- * not `subgroupAdd`, not `subgroupMax`, not even `subgroupBroadcastFirst`, which launders a value
- * for a use but not for control flow. Nor may such a loop carry a non-uniform `break`, `continue`
- * or `return`. So the descent runs `params.descent_steps` times and masks; a wave that drains its
- * subtree early pays the remaining steps at about ten instructions each rather than leaving. That
- * makes `descent_steps` a tuning knob rather than a safety bound, and
- * `VGEO_CUT_STAT.QUEUE_REMAINING` is what says when it is set too low.
- *
- * Divergence *inside* the loop is free: Tint models reconvergence, so a non-uniform `if` that opens
- * and closes taints nothing after it, and the spill's per-lane loop is fine because it contains no
- * subgroup operation of its own.
- *
- * ## One lane per cluster
- *
- * A leaf produces one item per cluster of its groups and the wave packs them, so what bounds a
- * lane's work is the packing rather than a chunk size, and consecutive lanes read consecutive
- * cluster rows instead of striding over runs of them.
- *
- * ## Why page-granular dedup is enough, and why it is necessary
- *
- * The page DAG is many-parented — 82 of 91 pages of a measured 98k sphere have more than one parent
- * — so an undeduped descent would visit a page once per parent and draw its whole cut that many
- * times. The claim is one bit per (instance, resident page), which is affordable. Cluster-granular
- * dedup is what this avoids: the resident cluster count is exactly the number design §4 is trying
- * not to pay per frame.
- *
- * Visiting a cluster the descent "should not" have reached costs only the test, because the
- * predicate is a pure function of the row and gives the same answer from every direction. Missing
- * one costs a hole. That asymmetry is the whole design:
- *
- * - **No cluster is drawn twice.** It is evaluated once per page visit, and the claim makes that at
- *   most once per instance.
- * - **No cluster the flat rule would draw is missed.** If `project(C.parent) > tau`, then any
- *   parent cluster `P` of `C`'s group has `project(P.self) = project(C.parent) > tau` — every
- *   cluster of a group shares the consuming step's sphere and error — and monotonicity gives
- *   `project(P.parent) >= project(P.self)`, so `P` satisfies the predicate's first half and by
- *   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 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
- * the CPU resolved it to this page's own index at install, so it looks up a page that is trivially
- * resident and falls through to the only question it was really asking — is that group selectable.
- *
- * ## Bounds
- *
- * Every append is checked and every overflow is counted, and they all degrade in one direction —
- * coarser or missing, never doubled. The exception worth knowing is `QUEUE_DROPPED`: a dropped item
- * is a subtree never descended, and the parent that would have stood in over it was not drawn
- * either, so that one is a hole.
+ * The virtual-geometry cut of a view: {@link chunk_vgeo_cut_descent} culled against the view's
+ * object-space frustum, a cluster in the cut taken as a draw record into the meshlet collection.
  *
  * ## Bindings
  *
@@ -198,95 +75,21 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const VG_QUEUE_GROUP_BIT = ${VGEO_QUEUE_TARGET_GROUP_BIT}u;
-const VG_QUEUE_PARENT_BIT = ${VGEO_QUEUE_TARGET_PARENT_BIT}u;
-const VG_PAGE_ROW_NONE = ${VGEO_PAGE_ROW_NONE}u;
-const VG_NO_CHILD_PAGE = ${VGEO_NO_CHILD_PAGE}u;
-const VG_GROUP_SELECTABLE = ${VGEO_GROUP_FLAG_SELECTABLE}u;
-const VG_WANT_WORDS = ${VGEO_WANT_WORDS}u;
-
-const VG_EXPAND_NONE = ${VGEO_CUT_EXPAND.NONE}u;
-const VG_EXPAND_NODES = ${VGEO_CUT_EXPAND.NODES}u;
-const VG_EXPAND_CLUSTERS = ${VGEO_CUT_EXPAND.CLUSTERS}u;
-const VG_EXPAND_PAGE = ${VGEO_CUT_EXPAND.PAGE}u;
-const VG_EXPAND_PARENTS = ${VGEO_CUT_EXPAND.PARENTS}u;
-
-/**
- * One unit of work: a node visit, or a single cluster of one group.
- *
- * The same four words the queue holds, and bit 31 of \`visit\` tells the two apart — a node
- * index below it, a group index above it with \`aux\` naming the cluster inside that group.
- */
-struct VGItem {
-    instance_slot: u32,
-    page_row: u32,
-    visit: u32,
-    aux: u32,
-}
-
 /**
- * What an executed item wants done next, as a count and a rule for the k-th child rather than as
- * children written somewhere.
- *
- * This is the whole reason the descent can stay in registers: a producer states its production at
- * constant cost and any lane of the wave can then build child \`k\` of it from five numbers.
+ * The rule's culls, against the view's object-space frustum when the view culls at all.
  */
-struct VGExpand {
-    kind: u32,
-    count: u32,
-    page_row: u32,
-    first: u32,
-    span: u32,
+fn vg_cut_sphere_outside(instance_base: u32, sphere: vec4<f32>) -> bool {
+    return (params.flags & ${VGEO_CUT_FLAG_CULL}u) != 0u
+        && vg_sphere_outside_frustum(instance_base, sphere);
 }
 
-fn vg_expand_none() -> VGExpand {
-    return VGExpand(VG_EXPAND_NONE, 0u, 0u, 0u, 0u);
+fn vg_cut_box_outside(instance_base: u32, lower: vec3<f32>, upper: vec3<f32>) -> bool {
+    return (params.flags & ${VGEO_CUT_FLAG_CULL}u) != 0u
+        && vg_box_outside_frustum(instance_base, lower, upper);
 }
 
-/*
- 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.
- *
- * Deduped on the child page, so a hundred clusters clamped against one page produce one request.
- * The record names the page the want was discovered **through** as well as the page wanted: the
- * source page's child table holds the exact byte range at child_ref, so the fetch costs one
- * round trip and no metadata request, and it is also the page format §10 asks to be pinned while
- * the child is in flight — which nothing but the cut can name, since the format stores parent counts
- * rather than parent references.
- *
- * Priority is the first writer's projected error rather than the maximum over all of them. Taking a
- * true maximum needs the record's slot, and a later writer cannot read that slot without waiting
- * for the first writer to publish it. It is pixels of error either way, comparable across assets,
- * and VGeoResidencyManager maxes across frames.
- */
-fn vg_want(source_page_row: u32, child_ref: u32, child_page_index: u32, lookup_base: u32, projected: f32) {
-    // persistent and frame-tagged rather than cleared: a stamp already holding this frame's tag
-    // was written by this frame, and anything else is a frame that has gone
-    if (atomicExchange(&vg_want_stamps[lookup_base + child_page_index], params.frame_tag)
-        == params.frame_tag) {
-        return;
-    }
-
-    // this view's slice and this view's counter, so an earlier view's full list takes no room here
-    let slot = atomicAdd(&feedback[params.want_count_offset], 1u);
-
-    if (slot >= params.want_capacity) {
-        vg_stat(${VGEO_CUT_STAT.WANTS_DROPPED}u, 1u);
-        return;
-    }
-
-    let base = params.want_base + slot * VG_WANT_WORDS;
-
-    atomicStore(&feedback[base], source_page_row);
-    atomicStore(&feedback[base + 1u], child_ref);
-    atomicStore(&feedback[base + 2u], child_page_index);
-    // over this view's own threshold, so the residency can rank wants from views that count in
-    // different units at different thresholds on one scale
-    atomicStore(&feedback[base + 3u], bitcast<u32>(projected / params.tau));
+fn vg_cut_take(instance_base: u32, page_row: u32, verdict: VGVerdict) {
+    vg_draw(page_row, verdict.cluster, instances[instance_base + ${VGEO_INSTANCE_OFFSET.MESH_INDEX}u]);
 }
 
 /**
@@ -326,572 +129,9 @@ fn vg_draw(page_row: u32, cluster: u32, mesh_index: u32) {
         atomicOr(&frontier[frontier_word], 1u << (page_row & 31u));
     }
 }
-
-fn vg_group_row(page_row: u32, group: u32) -> u32 {
-    return vg_group_base(page_row) + group * VG_GROUP_ROW_WORDS;
-}
-
-fn vg_group_selectable(page_row: u32, group: u32) -> bool {
-    return (vg_arena[vg_group_row(page_row, group) + ${VGEO_GROUP_ROW_OFFSET.FLAGS}u]
-        & VG_GROUP_SELECTABLE) != 0u;
-}
-
-/**
- * A node: cull, then say what it expands into.
- *
- * Nothing is enqueued here. An interior node expands into its child nodes and a leaf into every
- * cluster of its groups, and either is a base and a count — which is what lets the wave take the
- * first \`subgroup_size\` of them into its own lanes and spill the rest.
- */
-fn vg_visit_node(instance_base: u32, page_row: u32, node: u32) -> VGExpand {
-    let row = vg_node_base(page_row) + node * VG_NODE_ROW_WORDS;
-
-    let sphere = vg_sphere_at(row + ${VGEO_NODE_ROW_OFFSET.SPHERE}u);
-
-    if ((params.flags & ${VGEO_CUT_FLAG_CULL}u) != 0u
-        && vg_sphere_outside_frustum(instance_base, sphere)) {
-        vg_stat(${VGEO_CUT_STAT.CULLED_FRUSTUM}u, 1u);
-        return vg_expand_none();
-    }
-
-    let eye = vg_instance_eye(instance_base);
-    let k = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u);
-    let w = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u);
-
-    /*
-     Format §6.2's load-bearing field. A cluster draws only while project(parent) > tau, so if the
-     *largest* parent error under this node still projects to no more than tau, nothing under it can
-     be drawn and the whole subtree goes. The node's sphere is the union of the covered clusters'
-     parent spheres, so the projection is conservative in both terms.
-
-     **It is a descent-only accelerator**, and the coarsen flag turns it off. Its premise is that
-     a subtree nothing can be drawn in is a subtree worth skipping, which is true of a traversal
-     that only ever looks for what to draw. A walk up is looking for something else: the groups
-     under this node are below the cut, and being below the cut is precisely what sends them to
-     their parents. Skipping them here is what made a cut seeded at the leaves draw nothing at all
-     -- the subtree carrying the whole walk was pruned at its first node, silently and by a rule
-     that is correct for the direction it was written for.
-
-     A node has no parent list of its own -- the upward edge is per group (format §6.3) -- so
-     there is nothing to coarsen *from* here, and entering the subtree is the only way to reach
-     the groups that can. That is the cost of walking up through a page: the pages on the way
-     are evaluated whole. It is why CUT_PLAN §1 keeps a frontier at all rather than re-deriving
-     one, and why the frontier is what makes this affordable rather than this pass.
-    */
-    if ((params.flags & ${VGEO_CUT_FLAG_COARSEN}u) == 0u
-        && vg_project(vg_arena_f32(row + ${VGEO_NODE_ROW_OFFSET.MAX_PARENT_ERROR}u), sphere, eye, k, w)
-            <= params.tau) {
-        vg_stat(${VGEO_CUT_STAT.CULLED_LOD}u, 1u);
-        return vg_expand_none();
-    }
-
-    let child_first = vg_arena[row + ${VGEO_NODE_ROW_OFFSET.CHILD_FIRST}u];
-    let child_word = vg_arena[row + ${VGEO_NODE_ROW_OFFSET.CHILD_COUNT_AND_FLAGS}u];
-
-    let child_count = child_word & VG_NODE_CHILD_COUNT_MASK;
-
-    if ((child_word & VG_NODE_LEAF_BIT) == 0u) {
-        return VGExpand(VG_EXPAND_NODES, child_count, page_row, child_first, 0u);
-    }
-
-    // a leaf's children are groups, and its production is every cluster they hold
-    var total = 0u;
-
-    for (var i = 0u; i < child_count; i = i + 1u) {
-        total = total + vg_arena[
-            vg_group_row(page_row, child_first + i) + ${VGEO_GROUP_ROW_OFFSET.CLUSTER_COUNT}u
-        ];
-    }
-
-    return VGExpand(VG_EXPAND_CLUSTERS, total, page_row, child_first, child_count);
-}
-
-/**
- * The k-th cluster under a leaf, as a group and an index inside it.
- *
- * Bounded by the leaf's own group count and branchless, which are both about the same hazard. Every
- * lane of the wave runs this, including the lanes past the end of the wave's production, and those
- * hold a \`k\` with no cluster behind it. A walk that stopped when it found the group would run off
- * the end of the group rows for them, and a run of zero-member rows is an infinite loop rather than
- * a wrong answer — a hung GPU, on data the builder is free to produce.
- *
- * Their result is nonsense and is never executed, because the lane is inactive. It only has to be
- * in-range and finite.
- *
- * It is a loop with a non-uniform trip count and no subgroup operation inside, which WGSL permits
- * and which taints nothing after it.
- */
-fn vg_leaf_cluster(page_row: u32, group_first: u32, group_count: u32, k: u32) -> vec2<u32> {
-    var remaining = k;
-    var group = 0u;
-    var found = false;
-
-    for (var i = 0u; i < group_count; i = i + 1u) {
-        let members = vg_arena[
-            vg_group_row(page_row, group_first + i) + ${VGEO_GROUP_ROW_OFFSET.CLUSTER_COUNT}u
-        ];
-
-        /*
-         The latch is the whole of it. Walking on without one is not a slower answer but a wrong
-         one: the walk keeps testing \`remaining\` against later groups, and any later group smaller
-         than the remainder it already settled on takes the item off the group that owns it. Two
-         values of k then name one cluster, and one cluster drawn twice is the exact failure the
-         claim bitmask and the own-group term exist to prevent.
-         */
-        let here = !found && remaining < members;
-
-        group = select(group, i, here);
-        found = found || here;
-
-        // consumed only while still searching, so this never underflows
-        remaining = select(remaining - members, remaining, found);
-    }
-
-    return vec2<u32>(group_first + group, remaining);
-}
-
-/**
- * One cluster: the rule, once.
- */
-fn vg_visit_cluster(
-    instance_base: u32,
-    page_row: u32,
-    group: u32,
-    member: u32
-) -> VGExpand {
-    /*
-     The own-group term. A group that is resident but not selectable draws nothing at all — its
-     coarser selectable ancestors are already covering that surface, and drawing both is the
-     double-draw this whole runtime is arranged to avoid.
-     */
-    if (!vg_group_selectable(page_row, group)) {
-        return vg_expand_none();
-    }
-
-    let group_row = vg_group_row(page_row, group);
-
-    let cluster = vg_arena[group_row + ${VGEO_GROUP_ROW_OFFSET.CLUSTER_FIRST}u] + member;
-
-    let row = vg_cluster_base(page_row) + cluster * VG_CLUSTER_ROW_WORDS;
-
-    let eye = vg_instance_eye(instance_base);
-    let k = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u);
-    let w = vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u);
-    let mesh_index = instances[instance_base + ${VGEO_INSTANCE_OFFSET.MESH_INDEX}u];
-    let lookup_base = instances[instance_base + ${VGEO_INSTANCE_OFFSET.LOOKUP_WORD_OFFSET}u];
-
-    vg_stat(${VGEO_CUT_STAT.CLUSTERS_TESTED}u, 1u);
-
-    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),
-        eye, k, w
-    );
-
-    if (parent_projected <= params.tau) {
-        /*
-         Below the cut: something coarser covers this surface. A descent from the root never
-         arrives here -- it only descends through a step that projected above tau -- so this
-         is the branch a cut that was *kept* between frames lands in when the camera pulls
-         back, and stopping is what makes such a cut unable to coarsen.
-
-         parent_error and parent_sphere are the consuming step's, and every cluster of a group
-         shares that one step (FORMAT section 11.16), so this decision is group-uniform and
-         the group's first member can carry it alone. That is an election with nothing to
-         communicate: the other members reach the same answer and defer to the same lane.
-        */
-        let group_row_here = vg_group_row(page_row, group);
-
-        let parent_count = vg_arena[group_row_here + ${VGEO_GROUP_ROW_OFFSET.PARENT_COUNT}u];
-
-        if ((params.flags & ${VGEO_CUT_FLAG_COARSEN}u) == 0u || member != 0u
-            || parent_count == 0u) {
-            return vg_expand_none();
-        }
-
-        return VGExpand(
-            VG_EXPAND_PARENTS,
-            parent_count,
-            page_row,
-            vg_arena[group_row_here + ${VGEO_GROUP_ROW_OFFSET.PARENT_FIRST}u],
-            0u
-        );
-    }
-
-    /*
-     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),
-        eye, k, w
-    );
-
-    let child_page_index = vg_arena[row + ${VGEO_CLUSTER_ROW_OFFSET.CHILD_PAGE_INDEX}u];
-
-    if (self_projected <= params.tau || child_page_index == VG_NO_CHILD_PAGE) {
-        vg_draw(page_row, cluster, mesh_index);
-        return vg_expand_none();
-    }
-
-    let child_page_row = vg_lookup[lookup_base + child_page_index];
-
-    if (child_page_row == VG_PAGE_ROW_NONE) {
-        /*
-         The clamp. Drawing this cluster is not a fallback for a missing one — it is the correct
-         coarser surface over exactly the region the missing page would have refined, which is
-         what makes an arriving cut watertight at every moment rather than only at the end.
-         */
-        vg_draw(page_row, cluster, mesh_index);
-
-        vg_stat(${VGEO_CUT_STAT.CLAMPED}u, 1u);
-
-        vg_want(
-            page_row,
-            vg_arena[row + ${VGEO_CLUSTER_ROW_OFFSET.CHILD_REF}u],
-            child_page_index,
-            lookup_base,
-            self_projected
-        );
-
-        return vg_expand_none();
-    }
-
-    let child_group = vg_arena[row + ${VGEO_CLUSTER_ROW_OFFSET.CHILD_GROUP}u];
-
-    if (!vg_group_selectable(child_page_row, child_group)) {
-        /*
-         The bytes are here and the group is still waiting on a page holding one of its *other*
-         parents, so there is nothing to fetch from this cluster. Another cluster in this same
-         cut is clamped directly against that page and wants it — monotonicity puts every
-         ancestor of a cluster projecting above tau above tau as well.
-         */
-        vg_draw(page_row, cluster, mesh_index);
-
-        vg_stat(${VGEO_CUT_STAT.CLAMPED}u, 1u);
-        vg_stat(${VGEO_CUT_STAT.CLAMPED_ON_ACTIVATION}u, 1u);
-
-        return vg_expand_none();
-    }
-
-    if (!vg_claim_page(instance_base, child_page_row)) {
-        // another lane, or another parent of this page, got there first
-        return vg_expand_none();
-    }
-
-    return VGExpand(VG_EXPAND_PAGE, 1u, child_page_row, 0u, 0u);
-}
-
-/**
- * One entry of a page's parent rows: the page holding that parent, claimed and queued.
- *
- * The mirror of the descent's page crossing, and deliberately page-granular like it. The
- * entry names a cluster as well, and this ignores it: a page reached from any direction is
- * evaluated whole, the rule is a pure function of each row, and visiting a cluster the walk
- * did not need costs only the test. What the cluster half of the entry is for is the
- * refine-side election of CUT_PLAN_2026_09_14 section 3, which is section 7.6's work.
- *
- * A parent that is not resident stops the walk rather than clamping. There is nothing to
- * clamp *to* -- the surface this lane is standing on is below the cut and is not drawn -- so
- * the honest answer is that this instance cannot be served incrementally this frame, which
- * is the fallback section 4 already defines and section 7.6 wires up.
- */
-fn vg_visit_parent(instance_base: u32, page_row: u32, entry: u32) -> VGExpand {
-    if (entry >= vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.PARENT_ENTRY_COUNT}u)) {
-        return vg_expand_none();
-    }
-
-    let row = vg_parent_base(page_row) + entry * VG_PARENT_ROW_WORDS;
-
-    let parent_page_index = vg_arena[row + ${VGEO_PARENT_ROW_OFFSET.PAGE_INDEX}u];
-
-    if (parent_page_index == VG_NO_CHILD_PAGE) {
-        return vg_expand_none();
-    }
-
-    let lookup_base = instances[instance_base + ${VGEO_INSTANCE_OFFSET.LOOKUP_WORD_OFFSET}u];
-
-    let parent_page_row = vg_lookup[lookup_base + parent_page_index];
-
-    if (parent_page_row == VG_PAGE_ROW_NONE) {
-        return vg_expand_none();
-    }
-
-    if (!vg_claim_page(instance_base, parent_page_row)) {
-        // this page is already in this instance's cut, from above or from another parent
-        return vg_expand_none();
-    }
-
-    return VGExpand(VG_EXPAND_PAGE, 1u, parent_page_row, 0u, 0u);
-}
-
-/**
- * Execute whatever this lane is holding.
- */
-fn vg_execute(item: VGItem, holding: bool) -> VGExpand {
-    if (!holding) {
-        return vg_expand_none();
-    }
-
-    vg_stat(${VGEO_CUT_STAT.ITEMS}u, 1u);
-
-    let instance_base = item.instance_slot * VG_INSTANCE_WORDS;
-
-    if ((item.visit & VG_QUEUE_GROUP_BIT) != 0u) {
-        return vg_visit_cluster(
-            instance_base, item.page_row, item.visit & ~VG_QUEUE_GROUP_BIT, item.aux
-        );
-    }
-
-    if ((item.visit & VG_QUEUE_PARENT_BIT) != 0u) {
-        return vg_visit_parent(
-            instance_base, item.page_row, item.visit & ~VG_QUEUE_PARENT_BIT
-        );
-    }
-
-    return vg_visit_node(instance_base, item.page_row, item.visit);
-}
-
-/**
- * Child \`k\` of an expansion, as an item.
- *
- * Pure, and that is what lets the same rule serve both consumers: the lane that keeps a child calls
- * it with values shuffled out of the producer's registers, and the lane that spills one calls it
- * with its own.
- */
-fn vg_child(instance_slot: u32, expand: VGExpand, k: u32) -> VGItem {
-    if (expand.kind == VG_EXPAND_NODES) {
-        return VGItem(instance_slot, expand.page_row, expand.first + k, 0u);
-    }
-
-    if (expand.kind == VG_EXPAND_CLUSTERS) {
-        let at = vg_leaf_cluster(expand.page_row, expand.first, expand.span, k);
-
-        return VGItem(instance_slot, expand.page_row, at.x | VG_QUEUE_GROUP_BIT, at.y);
-    }
-
-    if (expand.kind == VG_EXPAND_PARENTS) {
-        // entry first + k of the *producing* page's parent rows; the page it names is
-        // resolved and claimed when this item is executed, not here
-        return VGItem(
-            instance_slot, expand.page_row, (expand.first + k) | VG_QUEUE_PARENT_BIT, 0u
-        );
-    }
-
-    // VG_EXPAND_PAGE: the child page's node 0, which is how a descent crosses a page boundary
-    return VGItem(instance_slot, expand.page_row, 0u, 0u);
-}
-
-/**
- * Which lane of the wave produced the item at \`index\` of its densely numbered production.
- *
- * The owner is the **largest** lane whose base is at or below the index — largest, because a lane
- * that produced nothing repeats its neighbour's base, and a repeat sits at the start of the next
- * producer's run rather than the end of the previous one. The bases are non-decreasing, so this is
- * a binary search, and \`span\` starts at a builtin so the loop's trip count is uniform.
- */
-fn vg_child_owner(first: u32, index: u32, lane_count: u32) -> u32 {
-    var owner = 0u;
-    var span = lane_count;
-
-    while (span > 1u) {
-        let step_half = span >> 1u;
-        let mid = owner + step_half;
-
-        // branchless: a non-uniform if around the next iteration's shuffle would not compile
-        owner = select(owner, mid, subgroupShuffle(first, mid) <= index);
-
-        span = span - step_half;
-    }
-
-    return owner;
-}
-
-fn vg_queue_write(slot: u32, item: VGItem) {
-    if (slot >= params.queue_capacity) {
-        vg_stat(${VGEO_CUT_STAT.QUEUE_DROPPED}u, 1u);
-        return;
-    }
-
-    let base = slot * 4u;
-
-    queue_out.elements[base] = item.instance_slot;
-    queue_out.elements[base + 1u] = item.page_row;
-    queue_out.elements[base + 2u] = item.visit;
-    queue_out.elements[base + 3u] = item.aux;
-}
-
-@compute @workgroup_size(${VGEO_CUT_WORKGROUP_SIZE})
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-    @builtin(subgroup_size) lane_count: u32,
-    @builtin(subgroup_invocation_id) lane_index: u32,
-) {
-    let slot = global_id.x;
-
-    /*
-     The queue's count against what the queue holds. \`shader_vgeo_cut_queue_prepare\` runs
-     immediately before every dispatch of this kernel and stores exactly this clamp back, so the
-     bound is already there — but it was the *read* below that carried it here and not the predicate
-     that decides whether a lane executes, and those two have to agree. A lane held past capacity
-     reads the clamped index, which is the last item of the queue: it would execute a duplicate of
-     an item another lane is already holding, and a cluster visited twice from two lanes is two draw
-     records for one surface. That is the one failure the claim bitmask and the own-group term are
-     both arranged to prevent, so the predicate does not get to be the looser of the two.
-    */
-    let queue_count = min(queue_in.count, params.queue_capacity);
-
-    /*
-     One per dispatch that had work, which is one per spill generation rather than one per level of
-     the descent: the depth is inside this kernel. Reaching params.descent_steps with items still
-     held is what QUEUE_REMAINING reports, and nothing else can.
-    */
-    if (slot == 0u && queue_count > 0u) {
-        vg_stat(${VGEO_CUT_STAT.WAVEFRONTS}u, 1u);
-    }
-
-    var holding = slot < queue_count;
-
-    let base = slot * 4u;
-
-    /*
-     Read unconditionally and mask the result. A branch here would be a non-uniform if, which is
-     harmless on its own — but every lane must reach every subgroup operation below, and a lane that
-     returned early is a lane the shuffles are not allowed to read.
-    */
-    let in_bounds = min(base, params.queue_capacity * 4u - 4u);
-
-    var item = VGItem(
-        queue_in.elements[in_bounds],
-        queue_in.elements[in_bounds + 1u],
-        queue_in.elements[in_bounds + 2u],
-        queue_in.elements[in_bounds + 3u]
-    );
-
-    for (var step = 0u; step < params.descent_steps; step = step + 1u) {
-        let expand = vg_execute(item, holding);
-
-        let first = subgroupExclusiveAdd(expand.count);
-        let total = subgroupAdd(expand.count);
-
-        // ----- what this wave keeps: one child per lane, densely packed, whoever produced it -----
-
-        let owner = vg_child_owner(first, lane_index, lane_count);
-
-        let kept = vg_child(
-            subgroupShuffle(item.instance_slot, owner),
-            VGExpand(
-                subgroupShuffle(expand.kind, owner),
-                0u,
-                subgroupShuffle(expand.page_row, owner),
-                subgroupShuffle(expand.first, owner),
-                subgroupShuffle(expand.span, owner)
-            ),
-            lane_index - subgroupShuffle(first, owner)
-        );
-
-        // ----- what it cannot hold: spilled, packed, under one reservation for the whole wave -----
-
-        let mine_first = max(first, lane_count);
-        let mine_last = max(first + expand.count, lane_count);
-
-        let spill_count = mine_last - mine_first;
-
-        let spill_offset = subgroupExclusiveAdd(spill_count);
-        let spill_total = subgroupAdd(spill_count);
-
-        /*
-         Elected *before* the branch, so the branch carries no subgroup operation of its own and is
-         free to be non-uniform — which lets a wave with nothing to spill skip the reservation
-         outright. An atomic on the queue head is a global round trip; a descent step that keeps
-         everything it produced is otherwise register work, and would spend more reserving zero
-         slots than on the step.
-        */
-        let spill_elected = subgroupElect();
-
-        var reserved = 0u;
-
-        if (spill_elected && spill_total > 0u) {
-            reserved = atomicAdd(&queue_out.count, spill_total);
-        }
-
-        // after the branch closes, which Tint permits: it models reconvergence
-        let spill_base = subgroupBroadcastFirst(reserved) + spill_offset;
-
-        for (var i = 0u; i < spill_count; i = i + 1u) {
-            vg_queue_write(spill_base + i, vg_child(
-                item.instance_slot, expand, mine_first - first + i
-            ));
-        }
-
-        item = kept;
-        holding = lane_index < total;
-    }
-
-    /*
-     Whatever is still held has not been executed, so it goes back to the queue rather than being
-     dropped. This is the descent handing its unfinished frontier to the next dispatch, and at
-     lane_count items per wave it is the common case rather than an overflow path.
-    */
-    let tail_count = select(0u, 1u, holding);
-
-    let tail_offset = subgroupExclusiveAdd(tail_count);
-    let tail_total = subgroupAdd(tail_count);
-
-    let tail_elected = subgroupElect();
-
-    var tail_reserved = 0u;
-
-    // as above: a wave holding nothing does not reserve
-    if (tail_elected && tail_total > 0u) {
-        tail_reserved = atomicAdd(&queue_out.count, tail_total);
-    }
-
-    let tail_base = subgroupBroadcastFirst(tail_reserved) + tail_offset;
-
-    if (holding) {
-        vg_queue_write(tail_base, item);
-    }
-}
 `, [
+    chunk_vgeo_cut_descent,
     chunk_vgeo_cut_access,
-    chunk_vgeo_cut_claim,
     MESHLET_DEFINITION_STRUCT.declaration_chunk,
 ]);