@woosh/meep-engine 3.57.0 → 3.59.0

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

@@ -1,6 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
-import { vgeo_cut_feedback_layout } from "./cut/vgeo_cut_feedback_layout.js";
+import {
+    vgeo_cut_feedback_layout,
+    vgeo_feedback_slot_stats,
+    vgeo_feedback_slot_want_count,
+    vgeo_feedback_slot_wants
+} from "./cut/vgeo_cut_feedback_layout.js";
 
 /**
  * @typedef {import("./GPUVirtualGeometryPool.js").GPUVirtualGeometryPool} GPUVirtualGeometryPool
@@ -8,6 +13,15 @@ import { vgeo_cut_feedback_layout } from "./cut/vgeo_cut_feedback_layout.js";
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
  */
 
+/**
+ * What takes a slot of a frame's feedback ({@link GPUVirtualGeometryRuntime#slot_of}): a cut that writes its
+ * counters and its wants there, and reads its counters back when the reading lands.
+ *
+ * @typedef {Object} VGeoFeedbackConsumer
+ * @property {function(Uint32Array, number, boolean, GPUVirtualGeometryRuntime): void} read_feedback the reading,
+ *   where its slot's counters start in it, whether another consumer shared the slot, and the runtime
+ */
+
 /**
  * The most views one frame's feedback is laid out for. A view past it shares the last slot, which
  * merges its counters and its want slice with that view's and loses nothing else; the bound exists
@@ -37,7 +51,8 @@ const SLOT_CEILING = 64;
  *
  * **Every view that cuts takes a slot** (§2.4): its own counters, its own want slice and its own
  * stamp tag, so one view's list running out cannot silence another's, and a reading can say which
- * view needed more wavefronts. The view the frame is opened for is slot 0.
+ * view needed more wavefronts. The view the frame is opened for is slot 0. A slot's taker is any
+ * {@link VGeoFeedbackConsumer}, a view's cut or a cut that is not a view's.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -119,14 +134,14 @@ export class GPUVirtualGeometryRuntime {
     #cleared = false;
 
     /**
-     * This frame's slot for each view that has cut in it.
-     * @type {Map<VGeoViewCut, number>}
+     * This frame's slot for each consumer that has cut in it.
+     * @type {Map<VGeoFeedbackConsumer, number>}
      */
     #slot_of = new Map();
 
     /**
-     * This frame's views, by slot; a slot shared past the layout holds more than one.
-     * @type {VGeoViewCut[][]}
+     * This frame's consumers, by slot; a slot shared past the layout holds more than one.
+     * @type {VGeoFeedbackConsumer[][]}
      */
     #slots = [];
 
@@ -444,14 +459,14 @@ export class GPUVirtualGeometryRuntime {
     }
 
     /**
-     * This frame's slot for a view, taking the next one the first time the view cuts in the frame.
+     * This frame's slot for a consumer, taking the next one the first time it cuts in the frame.
      *
-     * A view past the slots the frame was laid out for shares the last one — never slot 0, which is
-     * the frame's own view's — and the next frame is laid out with room for it. A shared slot's
-     * counters are the sum of its views', so its reading lands on each of them but escalates none
-     * (see `VGeoFeedbackLoop`).
+     * A consumer past the slots the frame was laid out for shares the last one — never slot 0, which
+     * is the frame's own view's — and the next frame is laid out with room for it. A shared slot's
+     * counters are the sum of its consumers', so its reading lands on each of them, told it was
+     * shared (see `VGeoFeedbackLoop`).
      *
-     * @param {VGeoViewCut} view
+     * @param {VGeoFeedbackConsumer} view
      * @returns {number}
      */
     slot_of(view) {
@@ -492,10 +507,36 @@ export class GPUVirtualGeometryRuntime {
     }
 
     /**
-     * This frame's views, by slot — what a reading of this frame's feedback is about. A copy, since
-     * the reading lands frames later and the table is rebuilt every frame.
+     * Fill the fields of a cut's `VGEO_CUT_PARAMS_STRUCT` that are the frame's and its slot's rather
+     * than the cut's own: the arena's stride, where the frame's touch bits and the slot's counters and
+     * wants are, and the slot's stamp tag.
+     *
+     * @param {Object} params written in place
+     * @param {number} slot this frame's, from {@link slot_of}
+     * @returns {Object} params
+     */
+    fill_slot_params(params, slot) {
+        const layout = this.#layout;
+
+        assert.defined(layout, 'feedback_layout — begin_frame must have run');
+        assert.lessThan(slot, layout.slot_count, 'slot');
+
+        params.page_slot_words = this.#pool.page_slot_words;
+        params.touch_bits_base = layout.touch_bits_base;
+        params.stats_base = vgeo_feedback_slot_stats(slot);
+        params.want_count_offset = vgeo_feedback_slot_want_count(slot);
+        params.want_base = vgeo_feedback_slot_wants(layout, slot);
+        params.want_capacity = layout.slot_want_capacity;
+        params.frame_tag = this.frame_tag_of(slot);
+
+        return params;
+    }
+
+    /**
+     * This frame's consumers, by slot — what a reading of this frame's feedback is about. A copy,
+     * since the reading lands frames later and the table is rebuilt every frame.
      *
-     * @returns {VGeoViewCut[][]}
+     * @returns {VGeoFeedbackConsumer[][]}
      */
     frame_slots() {
         return this.#slots.map(views => views.slice());

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

@@ -1,6 +1,6 @@
 /**
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
- * @typedef {import("./VGeoViewCut.js").VGeoViewCut} VGeoViewCut
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer} VGeoFeedbackConsumer
  * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
  * @typedef {import("./VGeoResidency.js").VGeoResidency} VGeoResidency
  * @typedef {import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout} vgeo_cut_feedback_layout
@@ -96,7 +96,7 @@ export class VGeoFeedbackLoop {
     #private;
 }
 export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-export type VGeoViewCut = import("./VGeoViewCut.js").VGeoViewCut;
+export type VGeoFeedbackConsumer = import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer;
 export type GPUVirtualGeometryRuntime = import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime;
 export type VGeoResidency = import("./VGeoResidency.js").VGeoResidency;
 export type vgeo_cut_feedback_layout = typeof import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout;

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoFeedbackLoop.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoFeedbackLoop.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA4CI;;;;;;OAMG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACF,SAAS,EAAhC,aAAa;QACI,aAAa,GAA9B,MAAM;OAUhB;IAED;;OAEG;IACH,4DAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;OAKG;IACH,YAHW,UAAU,GACR,OAAO,CAwEnB;IA4CD;;;;OAIG;IACH,SAFa,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,WAFa,IAAI,CAMhB;;CACJ;yBA3RY,OAAO,iEAAiE,EAAE,UAAU;0BACpF,OAAO,kBAAkB,EAAE,WAAW;wCACtC,OAAO,gCAAgC,EAAE,yBAAyB;4BAClE,OAAO,oBAAoB,EAAE,aAAa"}
+{"version":3,"file":"VGeoFeedbackLoop.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoFeedbackLoop.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA4CI;;;;;;OAMG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACF,SAAS,EAAhC,aAAa;QACI,aAAa,GAA9B,MAAM;OAUhB;IAED;;OAEG;IACH,4DAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;OAKG;IACH,YAHW,UAAU,GACR,OAAO,CAwEnB;IAgCD;;;;OAIG;IACH,SAFa,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,WAFa,IAAI,CAMhB;;CACJ;yBA/QY,OAAO,iEAAiE,EAAE,UAAU;mCACpF,OAAO,gCAAgC,EAAE,oBAAoB;wCAC7D,OAAO,gCAAgC,EAAE,yBAAyB;4BAClE,OAAO,oBAAoB,EAAE,aAAa"}

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

@@ -1,12 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { graph_read_buffer } from "../../../buffer/graph_read_buffer.js";
-import { VGEO_CUT_STAT } from "./layout/VGEO_CUT_STAT.js";
 import { VGEO_CUT_STAT_COUNT } from "./layout/VGEO_CUT_STAT_COUNT.js";
 import { vgeo_feedback_slot_stats } from "./cut/vgeo_cut_feedback_layout.js";
 
 /**
  * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
- * @typedef {import("./VGeoViewCut.js").VGeoViewCut} VGeoViewCut
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").VGeoFeedbackConsumer} VGeoFeedbackConsumer
  * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
  * @typedef {import("./VGeoResidency.js").VGeoResidency} VGeoResidency
  * @typedef {import("./cut/vgeo_cut_feedback_layout.js").vgeo_cut_feedback_layout} vgeo_cut_feedback_layout
@@ -181,9 +180,9 @@ export class VGeoFeedbackLoop {
         const reading_frame = this.#runtime.pool.frame;
 
         /*
-         And which views it is about, by slot. The table is rebuilt every frame and the set of views
-         changes — a point light's faces are in the shadow budget one frame and out the next — so a
-         reading that asked for "the" table when it landed would hand one view's counters to another.
+         And which consumers it is about, by slot. The table is rebuilt every frame and the set of
+         views changes — a point light's faces are in the shadow budget one frame and out the next — so
+         a reading that asked for "the" table when it landed would hand one view's counters to another.
         */
         const slots = this.#runtime.frame_slots();
 
@@ -226,34 +225,22 @@ export class VGeoFeedbackLoop {
      * @param {Uint32Array} words
      * @param {ReturnType<vgeo_cut_feedback_layout>} layout the frame's own, not the current one
      * @param {number} reading_frame the frame this reading is about
-     * @param {VGeoViewCut[][]} slots the frame's views, by slot
+     * @param {VGeoFeedbackConsumer[][]} slots the frame's consumers, by slot
      */
     #apply(words, layout, reading_frame, slots) {
         for (let slot = 0; slot < slots.length; slot++) {
-            const base = vgeo_feedback_slot_stats(slot);
+            const consumers = slots[slot];
 
             /*
-             A slot two views shared — they were past the frame's layout — holds the sum of their
-             counters, so a remainder in it says one of them ran out and not which. Escalating both
-             would raise a bound that was never binding, for good; each has a slot of its own next
-             frame, and escalates from that.
+             The consumer owns what its counters mean; the loop's job here is the same as with a
+             want, which is to carry the reading to whoever it is about. A slot two consumers shared
+             — they were past the frame's layout — holds the sum of their counters, which each is
+             told.
             */
-            const remaining = slots[slot].length === 1 ? words[base + VGEO_CUT_STAT.QUEUE_REMAINING] : 0;
+            const shared = consumers.length > 1;
 
-            for (const view of slots[slot]) {
-                for (let i = 0; i < VGEO_CUT_STAT_COUNT; i++) {
-                    view.stats[i] = words[base + i];
-                }
-
-                /*
-                 One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero
-                 exactly when the descent ran out of wavefronts and abandoned subtrees it had not
-                 expanded — a hole in the picture rather than a coarser surface — and this is the only
-                 moment anything on the host learns it. The view owns what to do about it; the loop's
-                 job here is the same as with a want, which is to carry the reading to whoever it is
-                 about.
-                */
-                view.note_incomplete_descent(remaining, this.#runtime);
+            for (const consumer of consumers) {
+                consumer.read_feedback(words, vgeo_feedback_slot_stats(slot), shared, this.#runtime);
             }
         }
 

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

@@ -173,23 +173,46 @@ export class VGeoViewCut {
      * @returns {boolean} whether the bound moved
      */
     note_incomplete_descent(remaining: number, runtime: GPUVirtualGeometryRuntime): boolean;
+    /**
+     * Take this view's slot of a reading: its counters, and what they say about its descent.
+     *
+     * One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero exactly
+     * when the descent ran out of wavefronts and abandoned subtrees it had not expanded — a hole in
+     * the picture rather than a coarser surface — and this is the only moment anything on the host
+     * learns it.
+     *
+     * A slot two views shared — they were past the frame's layout — holds the sum of their counters,
+     * so a remainder in it says one of them ran out and not which. Escalating both would raise a
+     * bound that was never binding, for good; each has a slot of its own next frame, and escalates
+     * from that.
+     *
+     * @param {Uint32Array} words the reading
+     * @param {number} base where this slot's counters start in it
+     * @param {boolean} shared whether another consumer shared the slot
+     * @param {GPUVirtualGeometryRuntime} runtime
+     */
+    read_feedback(words: Uint32Array, base: number, shared: boolean, runtime: GPUVirtualGeometryRuntime): void;
     /**
      * Publish the frame's shared settings and this view's own, as one uniform.
      *
      * Everything but the projection, the threshold's scale, the slot and `flags` is a property of the
      * runtime or the frame, so it is read from the runtime at write time rather than mirrored here —
-     * a second copy of `tau` is a second thing to forget to update.
+     * a second copy of `tau` is a second thing to forget to update. The slot's own fields are the
+     * runtime's to fill ({@link GPUVirtualGeometryRuntime#fill_slot_params}).
      *
      * @param {Object} options
      * @param {GPUVirtualGeometryRuntime} options.runtime inside an open frame
      * @param {number} options.slot this view's slot in the frame's feedback
      * @param {boolean} [options.coarsen] whether this view's cut may walk up
+     * @param {number} [options.tau] the threshold, for a cut whose records carry an error scale of their own rather
+     *   than a view's pixels; `runtime.tau × tau_scale` otherwise
      * @returns {void}
      */
-    write_params({ runtime, slot, coarsen }: {
+    write_params({ runtime, slot, coarsen, tau }: {
         runtime: GPUVirtualGeometryRuntime;
         slot: number;
         coarsen?: boolean;
+        tau?: number;
     }): void;
     destroy(): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAsBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA6EI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAhDD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEF;IAed;;;;OAIG;IACH,OAFU,WAAW,CAEwB;IAsB7C;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAFa,IAAI,CAchB;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAL2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACqB,iBAAiB,EAA5C,UAAU,MAAM,CAAC;QACf,IAAI,CAmBhB;IAED;;;;;;OAMG;IACH,0BAHW,yBAAyB,GACvB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mCAJW,MAAM,WACN,yBAAyB,GACvB,OAAO,CAgBnB;IAED;;;;;;;;;;;;OAYG;IACH;QAL8C,OAAO,EAA1C,yBAAyB;QACT,IAAI,EAApB,MAAM;QACY,OAAO,GAAzB,OAAO;QACL,IAAI,CAmChB;IAED,gBAIC;;CACJ;wCA5XY,OAAO,gCAAgC,EAAE,yBAAyB"}
+{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAoFI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAvDD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEF;IAed;;;;OAIG;IACH,OAFU,WAAW,CAEwB;IA6B7C;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAFa,IAAI,CAchB;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAL2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACqB,iBAAiB,EAA5C,UAAU,MAAM,CAAC;QACf,IAAI,CAmBhB;IAED;;;;;;OAMG;IACH,0BAHW,yBAAyB,GACvB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mCAJW,MAAM,WACN,yBAAyB,GACvB,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,qBALW,WAAW,QACX,MAAM,UACN,OAAO,WACP,yBAAyB,QAQnC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QAP8C,OAAO,EAA1C,yBAAyB;QACT,IAAI,EAApB,MAAM;QACY,OAAO,GAAzB,OAAO;QACU,GAAG,GAApB,MAAM;QAEJ,IAAI,CAyBhB;IAED,gBAIC;;CACJ;wCAtZY,OAAO,gCAAgC,EAAE,yBAAyB"}

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

@@ -2,11 +2,7 @@ import { assert } from "../../../../../core/assert.js";
 import { VGEO_CUT_FLAG_COARSEN } from "./cut/VGEO_CUT_FLAG_COARSEN.js";
 import { VGEO_CUT_FLAG_CULL } from "./cut/VGEO_CUT_FLAG_CULL.js";
 import { VGEO_CUT_PARAMS_STRUCT } from "./cut/VGEO_CUT_PARAMS_STRUCT.js";
-import {
-    vgeo_feedback_slot_stats,
-    vgeo_feedback_slot_want_count,
-    vgeo_feedback_slot_wants
-} from "./cut/vgeo_cut_feedback_layout.js";
+import { VGEO_CUT_STAT } from "./layout/VGEO_CUT_STAT.js";
 import { VGEO_CUT_STAT_COUNT } from "./layout/VGEO_CUT_STAT_COUNT.js";
 import { vgeo_frontier_words } from "./vgeo_frontier_words.js";
 import { write_gpu_typed_buffer } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
@@ -124,6 +120,13 @@ export class VGeoViewCut {
      */
     stats = new Uint32Array(VGEO_CUT_STAT_COUNT);
 
+    /**
+     * The params' fields as {@link write_params} last wrote them, kept so writing them allocates nothing.
+     *
+     * @type {Object}
+     */
+    #params_fields = {};
+
     /**
      * @param {Object} options
      * @param {GPUDevice} options.device
@@ -348,48 +351,67 @@ export class VGeoViewCut {
         return true;
     }
 
+    /**
+     * Take this view's slot of a reading: its counters, and what they say about its descent.
+     *
+     * One counter is not a statistic, it is an instruction. `QUEUE_REMAINING` is non-zero exactly
+     * when the descent ran out of wavefronts and abandoned subtrees it had not expanded — a hole in
+     * the picture rather than a coarser surface — and this is the only moment anything on the host
+     * learns it.
+     *
+     * A slot two views shared — they were past the frame's layout — holds the sum of their counters,
+     * so a remainder in it says one of them ran out and not which. Escalating both would raise a
+     * bound that was never binding, for good; each has a slot of its own next frame, and escalates
+     * from that.
+     *
+     * @param {Uint32Array} words the reading
+     * @param {number} base where this slot's counters start in it
+     * @param {boolean} shared whether another consumer shared the slot
+     * @param {GPUVirtualGeometryRuntime} runtime
+     */
+    read_feedback(words, base, shared, runtime) {
+        for (let i = 0; i < VGEO_CUT_STAT_COUNT; i++) {
+            this.stats[i] = words[base + i];
+        }
+
+        this.note_incomplete_descent(shared ? 0 : words[base + VGEO_CUT_STAT.QUEUE_REMAINING], runtime);
+    }
+
     /**
      * Publish the frame's shared settings and this view's own, as one uniform.
      *
      * Everything but the projection, the threshold's scale, the slot and `flags` is a property of the
      * runtime or the frame, so it is read from the runtime at write time rather than mirrored here —
-     * a second copy of `tau` is a second thing to forget to update.
+     * a second copy of `tau` is a second thing to forget to update. The slot's own fields are the
+     * runtime's to fill ({@link GPUVirtualGeometryRuntime#fill_slot_params}).
      *
      * @param {Object} options
      * @param {GPUVirtualGeometryRuntime} options.runtime inside an open frame
      * @param {number} options.slot this view's slot in the frame's feedback
      * @param {boolean} [options.coarsen] whether this view's cut may walk up
+     * @param {number} [options.tau] the threshold, for a cut whose records carry an error scale of their own rather
+     *   than a view's pixels; `runtime.tau × tau_scale` otherwise
      * @returns {void}
      */
-    write_params({ runtime, slot, coarsen = false }) {
+    write_params({ runtime, slot, coarsen = false, tau = undefined }) {
         assert.defined(runtime, 'runtime');
         assert.isNonNegativeInteger(slot, 'slot');
 
-        const layout = runtime.feedback_layout;
-
-        assert.defined(layout, 'runtime.feedback_layout — begin_frame must have run');
-        assert.lessThan(slot, layout.slot_count, 'slot');
-
-        write_gpu_typed_buffer({
-            tau: runtime.tau * this.tau_scale,
-            projection_k: this.#projection_k,
-            distance_weight: this.#distance_weight,
-            queue_capacity: runtime.queue_capacity,
-            claim_word_count: runtime.claim_word_capacity,
-            descent_steps: runtime.descent_steps,
-            page_slot_words: runtime.pool.page_slot_words,
-            touch_bits_base: layout.touch_bits_base,
-            stats_base: vgeo_feedback_slot_stats(slot),
-            want_count_offset: vgeo_feedback_slot_want_count(slot),
-            want_base: vgeo_feedback_slot_wants(layout, slot),
-            want_capacity: layout.slot_want_capacity,
-            frontier_word_count: this.#frontier_word_count,
-            frame_tag: runtime.frame_tag_of(slot),
-            instance_capacity: runtime.instance_capacity,
-            meshlet_capacity: runtime.meshlet_capacity,
-            flags: (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)
-                | (coarsen ? VGEO_CUT_FLAG_COARSEN : 0),
-        }, VGEO_CUT_PARAMS_STRUCT, this.#scratch, 0);
+        const params = runtime.fill_slot_params(this.#params_fields, slot);
+
+        params.tau = tau ?? runtime.tau * this.tau_scale;
+        params.projection_k = this.#projection_k;
+        params.distance_weight = this.#distance_weight;
+        params.queue_capacity = runtime.queue_capacity;
+        params.claim_word_count = runtime.claim_word_capacity;
+        params.descent_steps = runtime.descent_steps;
+        params.frontier_word_count = this.#frontier_word_count;
+        params.instance_capacity = runtime.instance_capacity;
+        params.meshlet_capacity = runtime.meshlet_capacity;
+        params.flags = (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)
+            | (coarsen ? VGEO_CUT_FLAG_COARSEN : 0);
+
+        write_gpu_typed_buffer(params, VGEO_CUT_PARAMS_STRUCT, this.#scratch, 0);
 
         this.#device.queue.writeBuffer(
             this.#params, 0, this.#scratch, 0, VGEO_CUT_PARAMS_STRUCT.aligned_size

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

@@ -0,0 +1,14 @@
+/**
+ * What the cut's rule says about one cluster ({@link chunk_vgeo_cut_rule }'s `vg_cut_cluster`). A traversal acts on
+ * it: the camera's draws, wants and claims, a box cut takes the cluster's triangles.
+ */
+export type VGEO_CUT_VERDICT = number;
+export namespace VGEO_CUT_VERDICT {
+    let NONE: number;
+    let BELOW: number;
+    let TAKE: number;
+    let CLAMP: number;
+    let HELD: number;
+    let REFINE: number;
+}
+//# sourceMappingURL=VGEO_CUT_VERDICT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_CUT_VERDICT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_VERDICT.js"],"names":[],"mappings":";;;;+BAMU,MAAM"}

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

@@ -0,0 +1,37 @@
+/**
+ * What the cut's rule says about one cluster ({@link chunk_vgeo_cut_rule}'s `vg_cut_cluster`). A traversal acts on
+ * it: the camera's draws, wants and claims, a box cut takes the cluster's triangles.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @enum {number}
+ */
+export const VGEO_CUT_VERDICT = {
+    /**
+     * Nothing: its own group is not selectable, or the cluster's subtree is culled.
+     */
+    NONE: 0,
+    /**
+     * Below the cut: its parent is already fine enough, so something coarser covers this surface. A descent
+     * never arrives here; a cut walking up does.
+     */
+    BELOW: 1,
+    /**
+     * In the cut: fine enough, or a leaf.
+     */
+    TAKE: 2,
+    /**
+     * In the cut as a stand-in: it would refine, but its child page is not resident, so it covers the region the
+     * missing page would have refined and the page is wanted.
+     */
+    CLAMP: 3,
+    /**
+     * In the cut as a stand-in: it would refine, its child page is here, but the child group still waits on a page
+     * holding one of its other parents. Nothing to fetch from this cluster.
+     */
+    HELD: 4,
+    /**
+     * Refine: descend into the child page, which is resident with its group selectable.
+     */
+    REFINE: 5,
+};

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

@@ -1 +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"}
+{"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":"AAaA;;;;;;;;;;;;;;;GAeG;AACH,mCAFU,SAAS,CAwGZ;0BAnImB,0CAA0C"}

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

@@ -1,6 +1,8 @@
 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_FLAG_SELECTABLE } from "../layout/VGEO_GROUP_FLAG_SELECTABLE.js";
+import { VGEO_GROUP_ROW_OFFSET } from "../layout/VGEO_GROUP_ROW_OFFSET.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";
@@ -38,6 +40,7 @@ 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;
+const VG_GROUP_SELECTABLE = ${VGEO_GROUP_FLAG_SELECTABLE}u;
 
 /**
  * A page's slot: its header, then its node, group and cluster rows.
@@ -65,6 +68,19 @@ fn vg_group_base(page_row: u32) -> u32 {
         + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.NODE_COUNT}u) * VG_NODE_ROW_WORDS;
 }
 
+fn vg_group_row(page_row: u32, group: u32) -> u32 {
+    return vg_group_base(page_row) + group * VG_GROUP_ROW_WORDS;
+}
+
+/**
+ * Whether a group may be drawn from: every page holding one of its parents is resident (format §10). A group that
+ * is resident and not selectable is held, its coarser selectable ancestors covering its surface.
+ */
+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;
+}
+
 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;

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

@@ -1 +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":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mCAFU,SAAS,CAkEQ;0BAlGD,0CAA0C"}
+{"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,CA6D6B;0BA9FtB,0CAA0C"}

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

@@ -3,6 +3,7 @@ import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.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";
+import { chunk_vgeo_cut_stat } from "./chunk_vgeo_cut_stat.js";
 
 /**
  * One page, claimed once per instance, and touched when the claim is won.
@@ -35,11 +36,6 @@ import { chunk_vgeo_cut_arena } from "./chunk_vgeo_cut_arena.js";
 export const chunk_vgeo_cut_claim = CodeChunk.from(
     //language=WGSL
     `
-fn vg_stat(slot: u32, amount: u32) {
-    // this view's counters: every view of a frame has its own, so a reading says what its cut did
-    atomicAdd(&feedback[params.stats_base + slot], amount);
-}
-
 /**
  * Record that this page was selected from this frame — design §6's eviction key.
  */
@@ -96,4 +92,4 @@ fn vg_claim_page(instance_base: u32, page_row: u32) -> bool {
         page_row
     );
 }
-`, [chunk_vgeo_cut_arena]);
+`, [chunk_vgeo_cut_arena, chunk_vgeo_cut_stat]);