@woosh/meep-engine 3.25.0 → 3.27.0

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

@@ -18,7 +18,7 @@
  * is on screen, which is the fallback-chain bug `VTPhysicalCache` already keys on touch to avoid.
  *
  * **Two budgets, and both of them bind.** Slots are fixed and finite, so a full table is as real a
- * reason to evict as a full byte budget; `#make_room` loops on whichever of the two is short.
+ * reason to evict as a full byte budget; `VGeoResidency` makes room on whichever of the two is short.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -29,19 +29,13 @@ export class GPUVirtualGeometryPool {
      * @param {GPUDevice} options.device
      * @param {GPUMeshletManager} options.meshlets the pool VG shares with static geometry, so a VG
      *     draw record is read downstream by the same shader that reads a static one
-     * @param {number} [options.budget_bytes] decoded page bytes this tier may hold; defaults to
-     *     what its slots hold at the page size it was built for, so the two agree by construction
-     * @param {number} [options.protect_window] frames a touched page is safe for; no shorter than
-     *     feedback latency, which is at least one frame of `mapAsync` and in practice several
      * @param {Object} [options.table_options] passed to {@link VGeoRuntimeTables}
      * @param {number} [options.page_size] the page size every container registered here must have
      *     been built at, and the one this tier's slots are sized from
      */
-    constructor({ device, meshlets, budget_bytes, protect_window, table_options, page_size, }: {
+    constructor({ device, meshlets, table_options, page_size, }: {
         device: GPUDevice;
         meshlets: GPUMeshletManager;
-        budget_bytes?: number;
-        protect_window?: number;
         table_options?: any;
         page_size?: number;
     });
@@ -58,6 +52,11 @@ export class GPUVirtualGeometryPool {
      * @returns {GPUBuffer}
      */
     get buffer_geometries(): GPUBuffer;
+    /**
+     * The persistent, frame-tagged want stamps, one per lookup word.
+     * @returns {GPUBuffer}
+     */
+    get buffer_want_stamps(): GPUBuffer;
     /**
      * @returns {VGeoRuntimeTables}
      */
@@ -66,10 +65,6 @@ export class GPUVirtualGeometryPool {
      * @returns {number}
      */
     get resident_bytes(): number;
-    /**
-     * @returns {number}
-     */
-    get budget_bytes(): number;
     /**
      * The page size every container registered here is required to have been built at.
      * @returns {number}
@@ -88,14 +83,28 @@ export class GPUVirtualGeometryPool {
      */
     get evicted_page_count(): number;
     /**
-     * Installs that could not be made — no slot could be freed, or the page did not fit one.
+     * The decoded bytes a resident row was charged for, out of its own slot.
+     *
+     * @param {number} page_row
      * @returns {number}
      */
-    get refused_install_count(): number;
+    bytes_of(page_row: number): number;
+    /**
+     * @param {number} page_row
+     * @returns {number} the container page index a resident row holds
+     */
+    page_index_of(page_row: number): number;
     /**
      * @returns {number}
      */
     get frame(): number;
+    /**
+     * The frame whose flush publishes this row's current occupant, or `0xFFFFFFFF` for none.
+     *
+     * @param {number} page_row
+     * @returns {number}
+     */
+    visible_from(page_row: number): number;
     /**
      * One past the highest page row handed out — what sizes the feedback buffer's touch stamps.
      * @returns {number}
@@ -106,11 +115,13 @@ export class GPUVirtualGeometryPool {
      */
     get lookup_word_count(): number;
     /**
-     * Give a container a geometry row, and make its root page resident and pinned.
+     * Give a container a geometry row and a block of the lookup, with every page absent.
      *
-     * The root is not an optimization: every traversal is seeded with it, invariant §11.7 puts
-     * exactly one root cluster in the file, and a measured root page is one cluster of under two
-     * kilobytes. A geometry whose root is not here draws nothing.
+     * Nothing resident, not even the root: which pages are here is `VGeoResidency`'s decision and it
+     * installs the root through the same door as every other page, pinned in its own tables. A
+     * geometry whose root is not here draws nothing — every traversal is seeded with it, invariant
+     * §11.7 puts exactly one root cluster in the file — and the residency throws on a registration
+     * that cannot make it resident, rolling this back.
      *
      * This is also the door the page-size guarantee is checked at, because it is the last moment a
      * refusal is still cheap: past it, this container's pages are laid into the tier's storage on
@@ -188,28 +199,12 @@ export class GPUVirtualGeometryPool {
         row: number;
     } | undefined;
     /**
-     * A page the cut reported drawing from, this frame.
+     * The runtime calls this at `begin_frame`, before the flush; see {@link visible_from} for why
+     * the order matters.
      *
-     * @param {number} page_row
-     * @returns {void}
-     */
-    touch(page_row: number): void;
-    /**
      * @returns {void}
      */
     advance_frame(): void;
-    /**
-     * Whether a page may go: not pinned, not touched inside the protect window, and with no VRAM
-     * child.
-     *
-     * The child rule is this tier's own, out of this tier's tables. Dropping a parent while its
-     * children stay leaves those children unreachable — nothing refines into them any more — so
-     * they would sit in VRAM, selectable, and never drawn.
-     *
-     * @param {number} page_row
-     * @returns {boolean}
-     */
-    evictable(page_row: number): boolean;
     /**
      * Push everything that changed since the last call to the device.
      *
@@ -224,5 +219,7 @@ export class GPUVirtualGeometryPool {
     destroy(): void;
     #private;
 }
+export type GPUMeshletManager = import("../../meshlet/GPUMeshletManager.js").GPUMeshletManager;
+export type VGeoContainerReader = import("../format/read/VGeoContainerReader.js").VGeoContainerReader;
 import { VGeoRuntimeTables } from "./VGeoRuntimeTables.js";
 //# sourceMappingURL=GPUVirtualGeometryPool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryPool.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryPool.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA4FI;;;;;;;;;;;;OAYG;IACH;QAX8B,MAAM;QACE,QAAQ;QAElB,YAAY,GAA7B,MAAM;QAEW,cAAc,GAA/B,MAAM;QAEW,aAAa;QACb,SAAS,GAA1B,MAAM;OAsChB;IAkCD;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;OAGG;IACH,oCAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,uCAJa,MAAM,CAkDlB;IAED;;;;;;;;;OASG;IACH,yCAFa,OAAO,CAuCnB;IAqCD;;;OAGG;IACH,8CAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,qDAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,yDAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,iDAHW,MAAM,GACJ,MAAM,CAsElB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CA8CnB;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAHW,MAAM,GACJ;QAAC,MAAM,sBAAsB;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAIhE;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;OAEG;IACH,iBAFa,IAAI,CAIhB;IAED;;;;;;;;;;OAUG;IACH,oBAHW,MAAM,GACJ,OAAO,CAgBnB;IAkID;;;;;;;;;OASG;IACH,SAFa,IAAI,CAMhB;IAwDD,gBAcC;;CACJ;kCA55BiC,wBAAwB"}
+{"version":3,"file":"GPUVirtualGeometryPool.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryPool.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAoFI;;;;;;;;OAQG;IACH;QAP8B,MAAM;QACE,QAAQ,EAAnC,iBAAiB;QAEA,aAAa;QACb,SAAS,GAA1B,MAAM;OAyChB;IAkCD;;OAEG;IACH,+BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;;OAGG;IACH,oCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,6BAEC;IAGD;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;OAEG;IACH,oBAEC;IAED;;;;;OAKG;IACH,uBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,gCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBALW,mBAAmB,GACjB,MAAM,CAmClB;IAED;;;;;;;;;OASG;IACH,mBAHW,mBAAmB,GACjB,OAAO,CA+CnB;IAqCD;;;OAGG;IACH,wBAHW,mBAAmB,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAJW,mBAAmB,cACnB,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,wBAJW,mBAAmB,cACnB,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAJW,mBAAmB,cACnB,MAAM,GACJ,MAAM,CAgElB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAHW,MAAM,GACJ;QAAC,MAAM,EAAE,mBAAmB,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAIhE;IAED;;;;;OAKG;IACH,iBAFa,IAAI,CAIhB;IA2ED;;;;;;;;;OASG;IACH,SAFa,IAAI,CAMhB;IAwDD,gBAcC;;CACJ;gCAp0BY,OAAO,oCAAoC,EAAE,iBAAiB;kCAC9D,OAAO,uCAAuC,EAAE,mBAAmB;kCAL9C,wBAAwB"}

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

@@ -8,6 +8,11 @@ import { VGEO_PAGE_ROW_WORDS } from "./layout/VGEO_PAGE_ROW_WORDS.js";
 import { VGeoRuntimeTables } from "./VGeoRuntimeTables.js";
 import { vgeo_runtime_meshlet_batch } from "./vgeo_runtime_meshlet_batch.js";
 
+/**
+ * @typedef {import("../../meshlet/GPUMeshletManager.js").GPUMeshletManager} GPUMeshletManager
+ * @typedef {import("../format/read/VGeoContainerReader.js").VGeoContainerReader} VGeoContainerReader
+ */
+
 /**
  * One resident geometry's bookkeeping above the tables.
  */
@@ -64,7 +69,7 @@ class VGeoPoolGeometry {
  * is on screen, which is the fallback-chain bug `VTPhysicalCache` already keys on touch to avoid.
  *
  * **Two budgets, and both of them bind.** Slots are fixed and finite, so a full table is as real a
- * reason to evict as a full byte budget; `#make_room` loops on whichever of the two is short.
+ * reason to evict as a full byte budget; `VGeoResidency` makes room on whichever of the two is short.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -96,18 +101,6 @@ export class GPUVirtualGeometryPool {
      */
     #owner = new Map();
 
-    /**
-     * Page row to the frame it was last selected from.
-     * @type {Map<number, number>}
-     */
-    #touched = new Map();
-
-    /**
-     * Page rows that may never go: the root page of every registered geometry, which is where every
-     * traversal starts and without which a geometry draws nothing at all.
-     * @type {Set<number>}
-     */
-    #pinned = new Set();
 
     /**
      * Per page row, the unsubscribe for that page's meshlet batch relocation signal.
@@ -116,24 +109,32 @@ export class GPUVirtualGeometryPool {
     #batch_listeners = new Map();
 
     /**
+     * Advanced by the runtime at `begin_frame`, before the flush — so it is the number of the
+     * flush that publishes whatever is installed before it, and the flush after that publishes
+     * what lands later in the frame.
      * @type {number}
      */
     #frame = 0;
 
     /**
-     * @type {number}
+     * Per page row, the frame whose flush publishes the row's current occupant, or
+     * `0xFFFFFFFF` for a row with none.
+     *
+     * What a reading compares against, per record, instead of a snapshot of every row's generation
+     * per readback: a record from the cut of frame F naming row r is about r's occupant iff
+     * `visible_from[r] <= F`. An install stamps `frame + 1` — this frame's flush has already run
+     * — so a row refilled after the cut, in the same frame or later, is rejected by that cut's
+     * reading, and a freed row is rejected by every reading (RUNTIME_PLAN_2026_09_14 §2.4).
+     *
+     * @type {Uint32Array}
      */
-    #resident_bytes = 0;
+    #visible_from;
 
     /**
      * @type {number}
      */
-    #budget_bytes;
+    #resident_bytes = 0;
 
-    /**
-     * @type {number}
-     */
-    #protect_window;
 
     /**
      * @type {number}
@@ -156,20 +157,12 @@ export class GPUVirtualGeometryPool {
      */
     #evicted_page_count = 0;
 
-    /**
-     * @type {number}
-     */
-    #refused_install_count = 0;
 
     /**
      * @param {Object} options
      * @param {GPUDevice} options.device
      * @param {GPUMeshletManager} options.meshlets the pool VG shares with static geometry, so a VG
      *     draw record is read downstream by the same shader that reads a static one
-     * @param {number} [options.budget_bytes] decoded page bytes this tier may hold; defaults to
-     *     what its slots hold at the page size it was built for, so the two agree by construction
-     * @param {number} [options.protect_window] frames a touched page is safe for; no shorter than
-     *     feedback latency, which is at least one frame of `mapAsync` and in practice several
      * @param {Object} [options.table_options] passed to {@link VGeoRuntimeTables}
      * @param {number} [options.page_size] the page size every container registered here must have
      *     been built at, and the one this tier's slots are sized from
@@ -177,33 +170,36 @@ export class GPUVirtualGeometryPool {
     constructor({
                     device,
                     meshlets,
-                    budget_bytes = undefined,
-                    protect_window = 4,
                     table_options = undefined,
                     page_size = VGEO_DEFAULT_PAGE_SIZE,
                 }) {
         assert.defined(device, 'device');
         assert.defined(meshlets, 'meshlets');
-        assert.isNonNegativeInteger(protect_window, 'protect_window');
         assert.isPositiveInteger(page_size, 'page_size');
 
         this.#device = device;
         this.#meshlets = meshlets;
-        this.#protect_window = protect_window;
         this.#page_size = page_size;
 
         this.#tables = new VGeoRuntimeTables({ page_size, ...table_options });
 
-        this.#budget_bytes = budget_bytes ?? this.#tables.page_capacity * page_size;
-
-        assert.isNonNegativeInteger(this.#budget_bytes, 'budget_bytes');
 
         this.#buffers = {
             lookup: this.#create('lookup', this.#tables.lookup_words.byteLength),
             arena: this.#create('arena', this.#tables.arena_words.byteLength),
             geometries: this.#create('geometries', this.#tables.geometry_words.byteLength),
+            /*
+             One want stamp per lookup word, persistent. The cut dedups a want by exchanging the
+             frame's tag into it, so this is never cleared and never read back — where it used to
+             be a region of the per-frame feedback transient, cleared and mapped every frame at the
+             size of the lookup, which is one word per page of every registered geometry
+             (RUNTIME_PLAN_2026_09_14 §2.3).
+             */
+            want_stamps: this.#create('want stamps', this.#tables.lookup_words.byteLength),
         };
 
+        this.#visible_from = new Uint32Array(this.#tables.page_capacity).fill(0xFFFFFFFF);
+
         // everything starts absent, and "absent" is a sentinel rather than a zero — the lookup has
         // to reach the device before any cut reads it
         this.#dirty.lookup = [0, this.#tables.lookup_words.length];
@@ -265,6 +261,14 @@ export class GPUVirtualGeometryPool {
         return this.#buffers.geometries;
     }
 
+    /**
+     * The persistent, frame-tagged want stamps, one per lookup word.
+     * @returns {GPUBuffer}
+     */
+    get buffer_want_stamps() {
+        return this.#buffers.want_stamps;
+    }
+
     /**
      * @returns {VGeoRuntimeTables}
      */
@@ -279,12 +283,6 @@ export class GPUVirtualGeometryPool {
         return this.#resident_bytes;
     }
 
-    /**
-     * @returns {number}
-     */
-    get budget_bytes() {
-        return this.#budget_bytes;
-    }
 
     /**
      * The page size every container registered here is required to have been built at.
@@ -316,11 +314,21 @@ export class GPUVirtualGeometryPool {
     }
 
     /**
-     * Installs that could not be made — no slot could be freed, or the page did not fit one.
+     * The decoded bytes a resident row was charged for, out of its own slot.
+     *
+     * @param {number} page_row
      * @returns {number}
      */
-    get refused_install_count() {
-        return this.#refused_install_count;
+    bytes_of(page_row) {
+        return this.#decoded_bytes_of(page_row);
+    }
+
+    /**
+     * @param {number} page_row
+     * @returns {number} the container page index a resident row holds
+     */
+    page_index_of(page_row) {
+        return this.#tables.page_field(page_row, VGEO_PAGE_ROW_OFFSET.PAGE_INDEX);
     }
 
     /**
@@ -330,6 +338,20 @@ export class GPUVirtualGeometryPool {
         return this.#frame;
     }
 
+    /**
+     * The frame whose flush publishes this row's current occupant, or `0xFFFFFFFF` for none.
+     *
+     * @param {number} page_row
+     * @returns {number}
+     */
+    visible_from(page_row) {
+        if (page_row >= this.#visible_from.length) {
+            return 0xFFFFFFFF;
+        }
+
+        return this.#visible_from[page_row];
+    }
+
     /**
      * One past the highest page row handed out — what sizes the feedback buffer's touch stamps.
      * @returns {number}
@@ -346,11 +368,13 @@ export class GPUVirtualGeometryPool {
     }
 
     /**
-     * Give a container a geometry row, and make its root page resident and pinned.
+     * Give a container a geometry row and a block of the lookup, with every page absent.
      *
-     * The root is not an optimization: every traversal is seeded with it, invariant §11.7 puts
-     * exactly one root cluster in the file, and a measured root page is one cluster of under two
-     * kilobytes. A geometry whose root is not here draws nothing.
+     * Nothing resident, not even the root: which pages are here is `VGeoResidency`'s decision and it
+     * installs the root through the same door as every other page, pinned in its own tables. A
+     * geometry whose root is not here draws nothing — every traversal is seeded with it, invariant
+     * §11.7 puts exactly one root cluster in the file — and the residency throws on a registration
+     * that cannot make it resident, rolling this back.
      *
      * This is also the door the page-size guarantee is checked at, because it is the last moment a
      * refusal is still cheap: past it, this container's pages are laid into the tier's storage on
@@ -381,32 +405,17 @@ export class GPUVirtualGeometryPool {
 
         this.#mark('geometries', row * VGEO_GEOMETRY_ROW_WORDS, VGEO_GEOMETRY_ROW_WORDS);
 
-        const page_row = this.install(reader, 0);
-
-        if (page_row === -1) {
-            /*
-             A thrown error rather than a stripped assert. `assert.*` is removed from the shipped
-             build by the consumer, so the check that used to stand here was a development-only
-             one — and what it was guarding is the seed kernel reading VGEO_PAGE_ROW_NONE out of the
-             geometry row as a u32 index and multiplying it into a live stat word (REVIEW_LEDGER
-             C7). The geometry is rolled back rather than left half-registered.
-             */
-            this.#geometries.delete(reader);
-
-            this.#tables.unregister_geometry(row);
-
-            this.#mark('geometries', row * VGEO_GEOMETRY_ROW_WORDS, VGEO_GEOMETRY_ROW_WORDS);
-
-            throw new Error(
-                `virtual geometry: the root page of this container could not be made resident, so`
-                + ` it would draw nothing and every cut seeded from it would read an absent row.`
-                + ` The tier holds ${this.#tables.page_capacity} slots and`
-                + ` ${this.#tables.resident_page_count} are taken, of a ${this.#budget_bytes}-byte`
-                + ` budget with ${this.#resident_bytes} spent.`
-            );
-        }
-
-        this.#pinned.add(page_row);
+        /*
+         The block of NONE the tables just wrote has to reach the device too. The first flush
+         uploads the lookup whole, so the first container's block rode along; a container
+         registered after that flush was leaving zeros behind, and zero is row 0 — every one of
+         its pages resolved to another geometry's root and the cut never wanted anything.
+         */
+        this.#mark(
+            'lookup',
+            this.#tables.geometry_field(row, VGEO_GEOMETRY_ROW_OFFSET.LOOKUP_WORD_OFFSET),
+            reader.header.total_pages
+        );
 
         return row;
     }
@@ -428,8 +437,15 @@ export class GPUVirtualGeometryPool {
             return false;
         }
 
+        // read before the tables forget the row
+        const lookup_offset = this.#tables.geometry_field(
+            geometry.row, VGEO_GEOMETRY_ROW_OFFSET.LOOKUP_WORD_OFFSET
+        );
+        const page_count = this.#tables.geometry_field(
+            geometry.row, VGEO_GEOMETRY_ROW_OFFSET.PAGE_COUNT
+        );
+
         for (const page_row of geometry.rows.values()) {
-            this.#pinned.delete(page_row);
             this.#unwatch_batch(page_row);
 
             // before the eviction, which zeroes the slot header this number lives in
@@ -445,14 +461,15 @@ export class GPUVirtualGeometryPool {
 
         for (const page_row of this.#tables.unregister_geometry(geometry.row)) {
             this.#owner.delete(page_row);
-            this.#touched.delete(page_row);
+            this.#visible_from[page_row] = 0xFFFFFFFF;
 
             this.#mark('arena', page_row * this.#tables.slot_words, VGEO_PAGE_ROW_WORDS);
         }
 
         this.#geometries.delete(reader);
 
-        this.#mark('lookup', 0, this.#tables.lookup_words.length);
+        // this geometry's words and not the whole lookup, which is every registered geometry's
+        this.#mark('lookup', lookup_offset, page_count);
         this.#mark(
             'geometries', geometry.row * VGEO_GEOMETRY_ROW_WORDS, VGEO_GEOMETRY_ROW_WORDS
         );
@@ -551,14 +568,11 @@ export class GPUVirtualGeometryPool {
 
         if (this.#tables.slot_words_for(page) > this.#tables.slot_words) {
             // nothing to evict for: no slot in this tier is ever bigger than another
-            this.#refused_install_count++;
-
             return -1;
         }
 
-        if (!this.#make_room(page.decoded_size)) {
-            this.#refused_install_count++;
-
+        if (!this.#tables.has_free_page_row) {
+            // room is the residency's business; a full table here is a refusal, not a cue
             return -1;
         }
 
@@ -571,8 +585,6 @@ export class GPUVirtualGeometryPool {
         } catch (error) {
             this.#meshlets.remove_batch(batch);
 
-            this.#refused_install_count++;
-
             return -1;
         }
 
@@ -580,7 +592,8 @@ export class GPUVirtualGeometryPool {
         geometry.rows.set(page_index, page_row);
 
         this.#owner.set(page_row, geometry);
-        this.#touched.set(page_row, this.#frame);
+        // this frame's flush has run; the next one is what publishes this row
+        this.#visible_from[page_row] = this.#frame + 1;
         this.#watch_batch(page_row, batch);
 
         this.#resident_bytes += page.decoded_size;
@@ -591,12 +604,10 @@ export class GPUVirtualGeometryPool {
         ) + page_index, 1);
         this.#mark('geometries', geometry.row * VGEO_GEOMETRY_ROW_WORDS, VGEO_GEOMETRY_ROW_WORDS);
 
-        /*
-         Activation reaches further than the page that arrived: a group becomes selectable when the
-         last of its parents' pages installs, and those parents can be anywhere already resident. So
-         the whole geometry's answer is recomputed rather than just this page's.
-         */
-        this.#refresh_selectable(geometry);
+        // activation reaches further than the page that arrived — a group becomes selectable when
+        // the last of its parents' pages installs, and the tables cascade that — so the rows whose
+        // flags flipped are whatever they say, not this page's alone
+        this.#mark_activated();
 
         return page_row;
     }
@@ -606,10 +617,6 @@ export class GPUVirtualGeometryPool {
      * @returns {boolean}
      */
     evict(page_row) {
-        if (this.#pinned.has(page_row)) {
-            return false;
-        }
-
         const geometry = this.#owner.get(page_row);
 
         if (geometry === undefined) {
@@ -639,14 +646,14 @@ export class GPUVirtualGeometryPool {
         geometry.rows.delete(page_index);
 
         this.#owner.delete(page_row);
-        this.#touched.delete(page_row);
+        this.#visible_from[page_row] = 0xFFFFFFFF;
 
         this.#evicted_page_count++;
 
         this.#mark_slot(page_row);
         this.#mark('lookup', lookup_word, 1);
 
-        this.#refresh_selectable(geometry);
+        this.#mark_activated();
 
         return true;
     }
@@ -671,106 +678,15 @@ export class GPUVirtualGeometryPool {
     }
 
     /**
-     * A page the cut reported drawing from, this frame.
+     * The runtime calls this at `begin_frame`, before the flush; see {@link visible_from} for why
+     * the order matters.
      *
-     * @param {number} page_row
-     * @returns {void}
-     */
-    touch(page_row) {
-        if (this.#owner.has(page_row)) {
-            this.#touched.set(page_row, this.#frame);
-        }
-    }
-
-    /**
      * @returns {void}
      */
     advance_frame() {
         this.#frame++;
     }
 
-    /**
-     * Whether a page may go: not pinned, not touched inside the protect window, and with no VRAM
-     * child.
-     *
-     * The child rule is this tier's own, out of this tier's tables. Dropping a parent while its
-     * children stay leaves those children unreachable — nothing refines into them any more — so
-     * they would sit in VRAM, selectable, and never drawn.
-     *
-     * @param {number} page_row
-     * @returns {boolean}
-     */
-    evictable(page_row) {
-        if (this.#pinned.has(page_row)) {
-            return false;
-        }
-
-        if (!this.#owner.has(page_row)) {
-            return false;
-        }
-
-        if (this.#frame - (this.#touched.get(page_row) ?? 0) < this.#protect_window) {
-            return false;
-        }
-
-        return !this.#tables.has_resident_child(page_row);
-    }
-
-    /**
-     * Drop coldest-first until a slot is free and `bytes` fit.
-     *
-     * Both budgets bind. Slots are fixed and finite now, so a full table is a reason to evict in its
-     * own right — where it used to be a permanent cliff independent of the byte budget
-     * (REVIEW_LEDGER M17).
-     *
-     * @param {number} bytes
-     * @returns {boolean}
-     */
-    #make_room(bytes) {
-        let guard = this.#tables.resident_page_count + 1;
-
-        while (guard-- > 0) {
-            const short = this.#resident_bytes + bytes > this.#budget_bytes
-                || !this.#tables.has_free_page_row;
-
-            if (!short) {
-                return true;
-            }
-
-            const coldest = this.#coldest();
-
-            if (coldest === -1) {
-                // nothing may go — every page is pinned, hot, or a parent. Refusing the install is
-                // the right answer: the cut clamps and draws coarser, which is what it is for.
-                return false;
-            }
-
-            this.evict(coldest);
-        }
-
-        return this.#resident_bytes + bytes <= this.#budget_bytes
-            && this.#tables.has_free_page_row;
-    }
-
-    /**
-     * @returns {number} page row, or -1
-     */
-    #coldest() {
-        let best = -1;
-        let best_stamp = Number.POSITIVE_INFINITY;
-
-        for (const [page_row, stamp] of this.#touched) {
-            if (stamp >= best_stamp || !this.evictable(page_row)) {
-                continue;
-            }
-
-            best = page_row;
-            best_stamp = stamp;
-        }
-
-        return best;
-    }
-
     /**
      * @param {number} page_row
      * @returns {number}
@@ -816,10 +732,10 @@ export class GPUVirtualGeometryPool {
     }
 
     /**
-     * @param {VGeoPoolGeometry} geometry
+     * Upload the group rows whose flags the tables flipped.
      */
-    #refresh_selectable(geometry) {
-        for (const page_row of this.#tables.refresh_selectable(geometry.row)) {
+    #mark_activated() {
+        for (const page_row of this.#tables.take_activated_rows()) {
             const [start, count] = this.#tables.group_range(page_row);
 
             this.#mark('arena', start, count);