@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js

@@ -22,13 +22,14 @@ import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
 const PAIR_KEY_MATERIAL_SPAN = 2 ** 20;
 
 /**
- * Rows the row → card set table starts with room for; it doubles past that.
+ * Rows a row table starts with room for; it doubles past that.
  * @type {number}
  */
 const INITIAL_ROW_CAPACITY = 256;
 
 /**
- * A (geometry, material) pair some row in the SDF world draws, and the card set capturing it.
+ * A (geometry, material) pair some row in the SDF world draws, and the Model Surface Cache of it the
+ * holds keep.
  */
 class Pair {
     /** @type {number} */
@@ -38,7 +39,7 @@ class Pair {
     material = undefined;
 
     /** @type {number} */
-    card_set = 0;
+    cache = 0;
 
     /**
      * Whether its rows hold the geometry's cache as drawing both sides: the material's side, as it was
@@ -54,30 +55,164 @@ class Pair {
     rows = new Set();
 }
 
+/**
+ * A row → cache table: a word a `meshes` row, mirrored on the host and put on the device by changed
+ * range. A row with nothing is `GPU_DATABASE_NULL`.
+ */
+class RowTable {
+    #mirror = new Uint32Array(0);
+    /** @type {GPUBuffer|null} */
+    #buffer = null;
+    #dirty_low = Infinity;
+    #dirty_high = -1;
+    #label;
+
+    /**
+     * @param {string} label
+     */
+    constructor(label) {
+        this.#label = label;
+    }
+
+    /**
+     * @param {number} row
+     * @param {number} value
+     */
+    write(row, value) {
+        if (row >= this.#mirror.length) {
+            this.#grow_mirror(row + 1);
+        }
+
+        if (this.#mirror[row] === value) {
+            return;
+        }
+
+        this.#mirror[row] = value;
+
+        this.#dirty_low = Math.min(this.#dirty_low, row);
+        this.#dirty_high = Math.max(this.#dirty_high, row);
+    }
+
+    /**
+     * @param {GPUDevice} device
+     * @returns {GPUBuffer}
+     */
+    buffer(device) {
+        this.#ensure(device, 1);
+
+        return this.#buffer;
+    }
+
+    /**
+     * @param {GPUDevice} device
+     */
+    flush(device) {
+        const low = this.#dirty_low;
+        const high = this.#dirty_high;
+
+        if (high < low) {
+            return;
+        }
+
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+
+        if (this.#ensure(device, high + 1)) {
+            // a new table took the whole mirror
+            return;
+        }
+
+        device.queue.writeBuffer(this.#buffer, 4 * low, this.#mirror, low, high + 1 - low);
+    }
+
+    clear() {
+        this.#buffer?.destroy();
+        this.#buffer = null;
+        this.#mirror = new Uint32Array(0);
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+    }
+
+    /**
+     * @param {number} length
+     */
+    #grow_mirror(length) {
+        let capacity = Math.max(INITIAL_ROW_CAPACITY, this.#mirror.length);
+
+        while (capacity < length) {
+            capacity *= 2;
+        }
+
+        const grown = new Uint32Array(capacity).fill(GPU_DATABASE_NULL);
+
+        grown.set(this.#mirror);
+
+        this.#mirror = grown;
+    }
+
+    /**
+     * A table buffer for at least `rows` rows; a new one gets the whole mirror.
+     *
+     * @param {GPUDevice} device
+     * @param {number} rows
+     * @returns {boolean} whether the buffer is new
+     */
+    #ensure(device, rows) {
+        if (rows > this.#mirror.length) {
+            this.#grow_mirror(rows);
+        }
+
+        if (this.#buffer !== null && this.#buffer.size >= 4 * this.#mirror.length) {
+            return false;
+        }
+
+        this.#buffer?.destroy();
+
+        this.#buffer = device.createBuffer(BufferDescriptor.fromJSON({
+            label: this.#label,
+            size: 4 * this.#mirror.length,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        }));
+
+        device.queue.writeBuffer(this.#buffer, 0, this.#mirror);
+
+        this.#dirty_low = Infinity;
+        this.#dirty_high = -1;
+
+        return true;
+    }
+}
+
 /**
  * What the probe clipmap GI holds of one scene's geometry caches (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
- * §6.1, §6.5), kept by entity and moved as the rows' events say, O(changes):
+ * §6.1), kept by entity and moved as the rows' events say, O(changes):
  *
  * - a hold on the cache of the geometry each mesh row in the SDF world draws, drawing both sides
  *   when the row's material does;
- * - one card set per (geometry, material) pair those rows draw, with the rows drawing each pair;
- * - the row → card set table readers find a row's card set in: the pair's once it is resident,
+ * - one Model Surface Cache per (geometry, material) pair those rows draw, with the rows drawing each
+ *   pair, which the brick material is gathered from;
+ * - the row → surface cache table readers find a row's cache in: the pair's once it is resident,
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
  * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
- * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
+ * hold and its side move to the proxy, and the pair's cache follows the proxy's field.
  * A skinned row draws a clone: the hold and the pair are its source's,
- * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
- * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
- * drawing is never let go in between.
+ * whose unskinned field and caches the clone's header is aliased to (§6.3). A row written again moves
+ * its hold and its pair, the new ones taken before the old ones go, so a cache a row keeps drawing is
+ * never let go in between.
+ *
+ * Rows the world's bricks must be built again over are kept until drained: a row whose geometry's field
+ * turned resident, one that joined or left the SDF world (§6.4, §7.4), and each row of a pair whose
+ * surface cache a bake completed, the first and every one after, since the bricks hold the materials
+ * their caches held when each was gathered.
  *
  * When the material manager restages a material whose version moved, each of that material's pairs
- * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * is baked again, and the holds of its rows move to the side it draws now.
  *
- * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
- * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
- * the caches for the next time (D28). Card sets go with their last row, and are captured again.
+ * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and cache
+ * back. Neither trims: a field with no holder stays until its user trims, so leaving the mode keeps
+ * the fields for the next time (D28). Caches go with their last row, and are made again.
  */
 export class ProbeClipmapSceneHolds {
 
@@ -126,34 +261,27 @@ export class ProbeClipmapSceneHolds {
     #pairs_of_geometry = new Map();
 
     /**
-     * Rows the world's bricks must be built again over, since they were last drained: a row whose
-     * geometry's field turned resident, and one that joined or left the SDF world (§6.4, §7.4). Rows
-     * as the GPU's tables address them (`row_of_entity`), not entities.
+     * Rows the world's bricks must be built again over, since they were last drained. Rows as the GPU's
+     * tables address them (`row_of_entity`), not entities.
      * @type {number[]}
      */
     #invalidated = [];
 
     /**
-     * Each card set's pair, by card set id.
+     * Each cache's pair, by cache id.
      * @type {(Pair|undefined)[]}
      */
-    #pair_of_card_set = [];
+    #pair_of_cache = [];
 
     #recaptures_requested = 0;
 
-    // ---- the row → card set table ----
-
-    #rows_mirror = new Uint32Array(0);
-    /** @type {GPUBuffer|null} */
-    #rows_buffer = null;
-    #rows_dirty_low = Infinity;
-    #rows_dirty_high = -1;
+    #surface_rows = new RowTable("ProbeClipmapSceneHolds/surface rows");
 
     #attached = false;
 
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages bake the pairs of the material again
      */
     constructor(scene, graphics) {
         assert.defined(scene, 'scene');
@@ -180,7 +308,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * (geometry, material) pairs the rows draw, a card set each.
+     * (geometry, material) pairs the rows draw, a cache each.
      * @returns {number}
      */
     get pair_count() {
@@ -188,7 +316,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * Recaptures asked for, a pair each time its material was restaged.
+     * Bakes again asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested() {
@@ -208,25 +336,24 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * The card set of the pair `material` makes with a geometry, or undefined when no row draws it.
+     * The Model Surface Cache of the pair `material` makes with a geometry, or undefined when no row
+     * draws it.
      *
      * @param {GPUGeometryMetadata} record
      * @param {ShadeMaterial} material
      * @returns {number|undefined}
      */
-    card_set_of(record, material) {
-        return this.#pairs.get(record.index * PAIR_KEY_MATERIAL_SPAN + material.id)?.card_set;
+    surface_cache_of(record, material) {
+        return this.#pairs.get(record.index * PAIR_KEY_MATERIAL_SPAN + material.id)?.cache;
     }
 
     /**
-     * The row → card set table: a word a `meshes` row. Made on first use, replaced when it grows; take it
-     * each frame, after {@link flush}.
+     * The row → Model Surface Cache table: a word a `meshes` row. Made on first use, replaced when it
+     * grows; take it each frame, after {@link flush}.
      * @returns {GPUBuffer}
      */
-    get rows_buffer() {
-        this.#ensure_rows(1);
-
-        return this.#rows_buffer;
+    get surface_rows_buffer() {
+        return this.#surface_rows.buffer(this.#device);
     }
 
     attach() {
@@ -235,13 +362,15 @@ export class ProbeClipmapSceneHolds {
         this.#attached = true;
 
         const rows = this.#scene.rows;
-        const cards = this.#scene.geometries.sdf.cards;
+        const sdf = this.#scene.geometries.sdf;
 
         rows.onMeshWritten.add(this.#written, this);
         rows.onMeshReleased.add(this.#released, this);
-        this.#scene.geometries.sdf.onBaked.add(this.#baked, this);
-        cards.onResident.add(this.#card_set_resident, this);
-        cards.onWithdrawn.add(this.#card_set_withdrawn, this);
+        sdf.onBaked.add(this.#baked, this);
+
+        sdf.surfaces.onBaked.add(this.#surface_baked, this);
+        sdf.surfaces.onWithdrawn.add(this.#cache_withdrawn, this);
+
         this.#materials.onMaterialRestaged.add(this.#restaged, this);
 
         // a row not yet written is taken now, and moved when it is
@@ -257,13 +386,14 @@ export class ProbeClipmapSceneHolds {
 
         const rows = this.#scene.rows;
         const sdf = this.#scene.geometries.sdf;
-        const cards = sdf.cards;
 
         rows.onMeshWritten.remove(this.#written, this);
         rows.onMeshReleased.remove(this.#released, this);
         sdf.onBaked.remove(this.#baked, this);
-        cards.onResident.remove(this.#card_set_resident, this);
-        cards.onWithdrawn.remove(this.#card_set_withdrawn, this);
+
+        sdf.surfaces.onBaked.remove(this.#surface_baked, this);
+        sdf.surfaces.onWithdrawn.remove(this.#cache_withdrawn, this);
+
         this.#materials.onMaterialRestaged.remove(this.#restaged, this);
 
         for (const [entity, record] of this.#held) {
@@ -271,7 +401,7 @@ export class ProbeClipmapSceneHolds {
         }
 
         for (const pair of this.#pairs.values()) {
-            cards.release(pair.card_set);
+            this.#release_cache(pair.cache);
         }
 
         this.#held.clear();
@@ -279,36 +409,17 @@ export class ProbeClipmapSceneHolds {
         this.#pairs.clear();
         this.#pairs_of_material.clear();
         this.#pairs_of_geometry.clear();
-        this.#pair_of_card_set.length = 0;
+        this.#pair_of_cache.length = 0;
         this.#invalidated.length = 0;
 
-        this.#rows_buffer?.destroy();
-        this.#rows_buffer = null;
-        this.#rows_mirror = new Uint32Array(0);
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
+        this.#surface_rows.clear();
     }
 
     /**
      * Put the table's changed rows on the device, ahead of the frame's commands.
      */
     flush() {
-        const low = this.#rows_dirty_low;
-        const high = this.#rows_dirty_high;
-
-        if (high < low) {
-            return;
-        }
-
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
-
-        if (this.#ensure_rows(high + 1)) {
-            // a new table took the whole mirror
-            return;
-        }
-
-        this.#device.queue.writeBuffer(this.#rows_buffer, 4 * low, this.#rows_mirror, low, high + 1 - low);
+        this.#surface_rows.flush(this.#device);
     }
 
     /**
@@ -359,7 +470,7 @@ export class ProbeClipmapSceneHolds {
             }
         }
 
-        this.#write_row(entity, pair !== undefined && sdf.cards.is_resident(pair.card_set) ? pair.card_set : GPU_DATABASE_NULL);
+        this.#write_row(entity, pair !== undefined && this.#is_resident(pair.cache) ? pair.cache : GPU_DATABASE_NULL);
 
         // in the SDF world or out of it now: the bricks its box reaches are built again
         if ((previous === undefined) !== (record === undefined)) {
@@ -384,9 +495,7 @@ export class ProbeClipmapSceneHolds {
         }
 
         for (const pair of pairs) {
-            for (const entity of pair.rows) {
-                this.#invalidated.push(row_of_entity(entity));
-            }
+            this.#invalidate_pair(pair);
         }
     }
 
@@ -427,15 +536,17 @@ export class ProbeClipmapSceneHolds {
             return pair;
         }
 
+        const sdf = this.#scene.geometries.sdf;
+
         pair = new Pair();
 
         pair.key = key;
         pair.material = material;
         pair.two_sided = material.draw_side === ShadeDrawSide.Double;
-        pair.card_set = this.#scene.geometries.sdf.cards.acquire(record.index, material);
+        pair.cache = sdf.surfaces.acquire(record.index, material);
 
         this.#pairs.set(key, pair);
-        this.#pair_of_card_set[pair.card_set] = pair;
+        this.#pair_of_cache[pair.cache] = pair;
 
         let of_material = this.#pairs_of_material.get(material.id);
 
@@ -469,10 +580,10 @@ export class ProbeClipmapSceneHolds {
             return;
         }
 
-        this.#scene.geometries.sdf.cards.release(pair.card_set);
+        this.#release_cache(pair.cache);
 
         this.#pairs.delete(pair.key);
-        this.#pair_of_card_set[pair.card_set] = undefined;
+        this.#pair_of_cache[pair.cache] = undefined;
 
         const of_material = this.#pairs_of_material.get(pair.material.id);
 
@@ -493,25 +604,54 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * @param {number} card_set
+     * @param {number} cache
      */
-    #card_set_resident(card_set) {
-        const pair = this.#pair_of_card_set[card_set];
+    #release_cache(cache) {
+        this.#scene.geometries.sdf.surfaces.release(cache);
+    }
+
+    /**
+     * @param {number} cache
+     * @returns {boolean}
+     */
+    #is_resident(cache) {
+        return this.#scene.geometries.sdf.surfaces.is_resident(cache);
+    }
+
+    /**
+     * @param {Pair} pair
+     */
+    #invalidate_pair(pair) {
+        for (const entity of pair.rows) {
+            this.#invalidated.push(row_of_entity(entity));
+        }
+    }
+
+    /**
+     * A bake of a surface cache is recorded in full: its rows find it, and the bricks they reach gather
+     * what it holds now.
+     *
+     * @param {number} cache
+     */
+    #surface_baked(cache) {
+        const pair = this.#pair_of_cache[cache];
 
         if (pair === undefined) {
             return;
         }
 
         for (const entity of pair.rows) {
-            this.#write_row(entity, card_set);
+            this.#write_row(entity, cache);
         }
+
+        this.#invalidate_pair(pair);
     }
 
     /**
-     * @param {number} card_set
+     * @param {number} cache
      */
-    #card_set_withdrawn(card_set) {
-        const pair = this.#pair_of_card_set[card_set];
+    #cache_withdrawn(cache) {
+        const pair = this.#pair_of_cache[cache];
 
         if (pair === undefined) {
             return;
@@ -536,7 +676,8 @@ export class ProbeClipmapSceneHolds {
         const two_sided = material.draw_side === ShadeDrawSide.Double;
 
         for (const pair of of_material) {
-            sdf.cards.recapture(pair.card_set);
+            sdf.surfaces.recapture(pair.cache);
+
             this.#recaptures_requested++;
 
             if (pair.two_sided === two_sided) {
@@ -560,69 +701,6 @@ export class ProbeClipmapSceneHolds {
      * @param {number} value
      */
     #write_row(entity, value) {
-        const row = row_of_entity(entity);
-
-        if (row >= this.#rows_mirror.length) {
-            this.#grow_mirror(row + 1);
-        }
-
-        if (this.#rows_mirror[row] === value) {
-            return;
-        }
-
-        this.#rows_mirror[row] = value;
-
-        this.#rows_dirty_low = Math.min(this.#rows_dirty_low, row);
-        this.#rows_dirty_high = Math.max(this.#rows_dirty_high, row);
-    }
-
-    /**
-     * @param {number} length
-     */
-    #grow_mirror(length) {
-        let capacity = Math.max(INITIAL_ROW_CAPACITY, this.#rows_mirror.length);
-
-        while (capacity < length) {
-            capacity *= 2;
-        }
-
-        const grown = new Uint32Array(capacity).fill(GPU_DATABASE_NULL);
-
-        grown.set(this.#rows_mirror);
-
-        this.#rows_mirror = grown;
-    }
-
-    /**
-     * A table buffer for at least `rows` rows; a new one gets the whole mirror.
-     *
-     * @param {number} rows
-     * @returns {boolean} whether the buffer is new
-     */
-    #ensure_rows(rows) {
-        if (rows > this.#rows_mirror.length) {
-            this.#grow_mirror(rows);
-        }
-
-        if (this.#rows_buffer !== null && this.#rows_buffer.size >= 4 * this.#rows_mirror.length) {
-            return false;
-        }
-
-        this.#rows_buffer?.destroy();
-
-        const device = this.#device;
-
-        this.#rows_buffer = device.createBuffer(BufferDescriptor.fromJSON({
-            label: "ProbeClipmapSceneHolds/rows",
-            size: 4 * this.#rows_mirror.length,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-        }));
-
-        device.queue.writeBuffer(this.#rows_buffer, 0, this.#rows_mirror);
-
-        this.#rows_dirty_low = Infinity;
-        this.#rows_dirty_high = -1;
-
-        return true;
+        this.#surface_rows.write(row_of_entity(entity), value);
     }
 }

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts

@@ -3,9 +3,9 @@
  * read every frame the mode runs (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §10).
  *
  * Three kinds of field, by what a change costs:
- * - **structure**: the cascade counts and resolutions, the brick voxel, the probe spacing, and the
- *   radiance and depth resolutions. A change destroys the GI and builds it again at the next frame,
- *   so its bricks and probes warm up from nothing.
+ * - **structure**: the cascade counts and resolutions, the brick voxel, the probe spacing, the
+ *   radiance and depth resolutions, and where hits take their material. A change destroys the GI and
+ *   builds it again at the next frame, so its bricks and probes warm up from nothing.
  * - **the mesh caches**: {@link mesh_sdf_voxel_size} and {@link mesh_sdf_max_bricks}. A change bakes
  *   every cached geometry again.
  * - **budgets and times**: they size a frame's work and set uniforms, and take effect the next frame
@@ -97,7 +97,9 @@ export class ProbeClipmapSettings {
      * §6.4). Over Sponza's fill, its 103 geometries all coarsened by the cap, with the budgets
      * interleaved in one process, evaluate costs 798 µs plus 8.6 µs a brick at the median, which
      * reaches 1 ms at 23. At 23 the fill's evaluate costs 840 µs a frame at the median and 5.3 ms at
-     * worst, and every geometry is resident after 5,712 frames of baking.
+     * worst, and every geometry is resident after 5,712 frames of baking. Finding the slots that hold a
+     * frame's bricks already and comparing their bytes (the key and resolve passes) adds 29 µs at the
+     * median.
      *
      * On the AMD iGPU (RDNA2) the same 23 bricks cost 26 ms a frame at the median and 79 ms at worst,
      * and no budget fits 1 ms: one brick costs 2.3 ms there.
@@ -105,59 +107,30 @@ export class ProbeClipmapSettings {
      */
     get mesh_sdf_bake_budget(): number;
     /**
-     * @param {number} v a positive integer, at most {@link MESH_CARD_CAPTURE_BUDGET_MAX}: a workgroup a
-     *        page in one dispatch row
+     * @param {number} v a positive integer: a frame lists every texel of its bricks in one storage
+     *        binding, which the bake checks against the device
      */
-    set card_capture_budget(v: number);
+    set surface_bake_budget(v: number);
     /**
-     * Card pages captured a frame at most: new (geometry, material) pairs first, then recaptures of
-     * materials that changed (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5). A time knob. A page is 64
-     * texels, a thread each, and a texel is a ray through its card's slab, up to four alpha draws, and
-     * a material sample. A frame with nothing to capture spends nothing.
+     * Model Surface Cache bricks surveyed and baked a frame at most: fields' surveys first, then new
+     * (geometry, material) pairs, then bakes again of materials that changed. A time knob. A brick is a
+     * thread a texel to find which hold surface, a workgroup of 64 rays for each that does, each ray up
+     * to four alpha draws and a material sample, against the pair's geometry alone, and a workgroup for
+     * each of its blocks to code them; a survey's brick is its first pass alone. A frame with nothing to
+     * do spends nothing. A cache is held for each pair the SDF world draws: for every 4³ block of its
+     * geometry's field's bricks that can hold surface, a block of each plane that varies over the pair's
+     * surface (48 B of albedo, 20 B of metalness and roughness, 256 B of emissive) and 8 B of presence; a
+     * pair that varies in no plane is neither surveyed nor baked.
      *
-     * The default is derived against 1 ms a frame on the RTX 4090, as {@link mesh_sdf_bake_budget}
-     * is. Over Sponza's 103 card sets (154,138 pages), recaptured with the budgets interleaved frame by
-     * frame in one process, 16,384 pages cost 0.33, 0.43 and 0.87 ms at the median in three runs and
-     * 32,768 went past 1 ms in all three; the cost turns steeply between the two. The runs shared the
-     * GPU with another load of 40–73%, which is in the medians: the least loaded frames cost 0.11 ms at
-     * 16,384. At the default Sponza's cards are captured in 10 frames.
-     *
-     * Re-derived once the material reads became trilinear at a texel's footprint (2026-10-30), which
-     * costs 1.30× at the median, timed on the same pages in the same frame: 16,384 pages cost 0.54 and
-     * 0.55 ms at the median in two runs (the old capture 0.54 ms beside them), 32,768 cost 1.48 and
-     * 1.52 ms, and the least loaded frames 0.15 ms at 16,384.
-     *
-     * On the AMD iGPU (RDNA2), measured before that, a page costs 0.78 µs: 16,384 pages cost 33.5 ms at
-     * the median, and about 1,290 fit 1 ms (1,024 cost 0.80 ms).
-     *
-     * Derived for {@link MeshCardCaptureMode.Trace}. A rastered card set is taken whole, the frame's
-     * last past the budget, and a frame also stops at what its scratch holds: at the largest budget
-     * Sponza's recapture took 13 frames on the iGPU, 2.5 ms of capture a frame on average.
+     * The default is derived against 1 ms a frame on the RTX 4090, as {@link mesh_sdf_bake_budget} is.
+     * Over Sponza's 103 caches (115,978 bricks), baked again with the budgets interleaved frame by frame
+     * in one process, 512 bricks cost 0.77 to 0.95 ms at the median in four runs (1.9 to 2.5 ms at the
+     * 90th percentile), and 256 cost 0.38 to 0.42 ms, before the blocks are coded, which adds 0.08 ms at
+     * 512. Runs sharing the GPU with another load of 38-73% read 0.95 to 1.34 ms at 512. At the default
+     * Sponza's caches are baked in 227 frames.
      * @returns {number}
      */
-    get card_capture_budget(): number;
-    /**
-     * @param {MeshCardCaptureMode} v
-     */
-    set card_capture_mode(v: number);
-    /**
-     * How card pages are captured: each card drawn through its material's own template and textures,
-     * or a ray a texel against the geometry's BLAS with the path tracer's material sampling. A change
-     * captures every card set again.
-     *
-     * Raster is the default. The trace took one level-0 tap of the material's 64² resident copy a
-     * texel and kept it, which aliased: on Sponza's outer wall the brick texture's dark band, every
-     * 12.8 card texels, landed on a row of texels once and between rows at its other repeats, a seam
-     * across the wall. The raster samples the texture's mips at the card texel's footprint, as UE's
-     * card capture does, and since 2026-10-30 the trace reads the resident copy's mips there too,
-     * trilinearly, at 1.30× its cost (see {@link card_capture_budget}). Against the one-tap trace, the
-     * cards' colours agreed with the raster's to 3 codes on average over Sponza's wall, floor, ceiling
-     * and banners, and recapturing all of Sponza (154,138 pages) at the largest budget, the two
-     * interleaved in one process, cost the trace 9.1–12.7 ms and the raster 0.6 ms on the RTX 4090,
-     * and 335 ms against 33 ms on the AMD iGPU (RDNA2).
-     * @returns {MeshCardCaptureMode}
-     */
-    get card_capture_mode(): number;
+    get surface_bake_budget(): number;
     /**
      * @param {number} v a positive integer; the probe clipmap checks it against what its layout and the
      *        device hold when it is built