@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js

@@ -12,38 +12,63 @@ import {
 } from "../../gpu_primitive/slot_stack/shader_slot_stack_push_range.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
+import { meshlet_batch_colored } from "../meshlet/meshlet_batch_colored.js";
 import {
     MESH_SDF_BAKE_WORKGROUP_SIZE,
     MESH_SDF_COUNTER_SLOTS,
     MESH_SDF_COUNTER_WORDS,
+    MESH_SDF_LOG_COLLIDED,
     MESH_SDF_LOG_COMPLETIONS,
     MESH_SDF_LOG_HEADER_WORDS,
-    MESH_SDF_LOG_PLACED,
     MESH_SDF_LOG_QUEUED,
     MESH_SDF_LOG_RECORD_WORDS,
     MESH_SDF_LOG_FREE_SLOTS,
+    MESH_SDF_LOG_SHARED,
     MESH_SDF_LOG_STARVED,
+    MESH_SDF_LOG_STORED,
     MESH_SDF_LOG_TAKEN,
     MESH_SDF_STAGING_VEC4S,
     MESH_SDF_GROUPS_PER_BRICK,
     MESH_SDF_TAKE_DISPATCH,
-    MESH_SDF_TAKE_PLACE_DISPATCH,
-    MESH_SDF_TAKE_WORDS
+    MESH_SDF_TAKE_WORDS,
+    MESH_SDF_TAKEN_WORDS,
+    mesh_sdf_claim_size
 } from "./bake/MESH_SDF_BAKE.js";
+import { MESH_SDF_CONTENT_WORDS, mesh_sdf_content_table_size } from "./bake/chunk_mesh_sdf_contents.js";
 import { shader_mesh_sdf_classify } from "./bake/shader_mesh_sdf_classify.js";
+import { shader_mesh_sdf_content_rehash } from "./bake/shader_mesh_sdf_content_rehash.js";
 import { shader_mesh_sdf_evaluate } from "./bake/shader_mesh_sdf_evaluate.js";
 import { shader_mesh_sdf_free } from "./bake/shader_mesh_sdf_free.js";
+import { shader_mesh_sdf_count } from "./bake/shader_mesh_sdf_count.js";
+import { shader_mesh_sdf_key } from "./bake/shader_mesh_sdf_key.js";
+import {
+    shader_mesh_sdf_resolve_compare,
+    shader_mesh_sdf_resolve_find,
+    shader_mesh_sdf_resolve_fresh,
+    shader_mesh_sdf_resolve_hold
+} from "./bake/shader_mesh_sdf_resolve.js";
 import { shader_mesh_sdf_store } from "./bake/shader_mesh_sdf_store.js";
 import { shader_mesh_sdf_take } from "./bake/shader_mesh_sdf_take.js";
-import { GPUMeshCardSets, MESH_CARD_CAPTURE_BUDGET_MAX } from "./cards/GPUMeshCardSets.js";
-import { mesh_card_layout_words, mesh_card_placement_of } from "./cards/MESH_CARDS.js";
-import { shader_mesh_cards_compact } from "./cards/shader_mesh_cards_compact.js";
-import { shader_mesh_cards_histogram } from "./cards/shader_mesh_cards_histogram.js";
-import { shader_mesh_cards_log } from "./cards/shader_mesh_cards_log.js";
-import { shader_mesh_cards_merge } from "./cards/shader_mesh_cards_merge.js";
-import { shader_mesh_cards_pages } from "./cards/shader_mesh_cards_pages.js";
-import { shader_mesh_cards_split } from "./cards/shader_mesh_cards_split.js";
-import { MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_VOXELS, MeshSDFState } from "./MESH_SDF.js";
+import {
+    MESH_SDF_UPLOAD_BRICK_WORDS,
+    shader_mesh_sdf_upload_compare,
+    shader_mesh_sdf_upload_find,
+    shader_mesh_sdf_upload_fresh,
+    shader_mesh_sdf_upload_key,
+    shader_mesh_sdf_upload_link,
+    shader_mesh_sdf_upload_store
+} from "./bake/shader_mesh_sdf_upload.js";
+import { ModelCacheBundle, ModelCacheBundleCache, ModelCacheBundleField } from "./bundle/ModelCacheBundle.js";
+import { download_texture_data } from "../../texture/download_texture_data.js";
+import { GPUMeshSurfaceCaches } from "./surface/GPUMeshSurfaceCaches.js";
+import {
+    MESH_SDF_BRICK_TEXEL_COUNT,
+    MESH_SDF_BRICK_TEXELS,
+    MESH_SDF_EMPTY,
+    MESH_SDF_UNNUMBERED,
+    MeshSDFState
+} from "./MESH_SDF.js";
+import { mesh_sdf_brick_key } from "./MESH_SDF_BRICK_KEY.js";
 import { MESH_SDF_SAMPLER } from "./MESH_SDF_RESOURCES.js";
 import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
 import { MeshSDFLayout } from "./MeshSDFLayout.js";
@@ -54,7 +79,7 @@ import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTw
  * @typedef {import("../GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
  * @typedef {import("../GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
- * @typedef {import("../../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
+ * @typedef {import("../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
  */
 
 /*
@@ -66,16 +91,45 @@ const HOST_QUEUED = 1;
 const HOST_BAKING = 2;
 const HOST_RESIDENT = 3;
 const HOST_ALIAS = 4;
+/** Its field taken from a bundle, its bricks placed by the next bake; resident from the bake after. */
+const HOST_UPLOADING = 5;
 
-/*
- Where a resident geometry's cards are (§6.5): waiting for placement; being placed, in a range sized
- for any layout of its grid; placed, waiting to be moved into a range of their own size; placed.
+/**
+ * A buffer's words, read back.
+ *
+ * @param {GPUDevice} device
+ * @param {GPUBuffer} buffer COPY_SRC
+ * @returns {Promise<Uint32Array>}
  */
-const CARDS_NONE = 0;
-const CARDS_QUEUED = 1;
-const CARDS_PLACING = 2;
-const CARDS_COMPACTING = 3;
-const CARDS_PLACED = 4;
+async function read_back(device, buffer) {
+    const target = device.createBuffer({ size: buffer.size, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
+    const encoder = device.createCommandEncoder({ label: "GPUGeometrySDFManager/export" });
+
+    encoder.copyBufferToBuffer(buffer, 0, target, 0, buffer.size);
+    device.queue.submit([encoder.finish()]);
+
+    await target.mapAsync(GPUMapMode.READ);
+
+    const words = new Uint32Array(target.getMappedRange().slice(0));
+
+    target.unmap();
+    target.destroy();
+
+    return words;
+}
+
+/**
+ * Whether two bricks hold the same bytes.
+ */
+function same_brick(a, a_offset, b, b_offset) {
+    for (let i = 0; i < MESH_SDF_BRICK_TEXEL_COUNT; i++) {
+        if (a[a_offset + i] !== b[b_offset + i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
 
 const HEADER_BYTES = MESH_SDF_STRUCT.size;
 const HEADER_ORIGIN = MESH_SDF_STRUCT.get("origin").offset;
@@ -83,7 +137,6 @@ const HEADER_VOXEL = MESH_SDF_STRUCT.get("voxel").offset;
 const HEADER_BRICKS = MESH_SDF_STRUCT.get("bricks").offset;
 const HEADER_LEVEL_COUNT = MESH_SDF_STRUCT.get("level_count").offset;
 const HEADER_INDIRECTION = MESH_SDF_STRUCT.get("indirection").offset;
-const HEADER_CARDS = MESH_SDF_STRUCT.get("cards").offset;
 const HEADER_STATE = MESH_SDF_STRUCT.get("state").offset;
 const HEADER_SOURCE = MESH_SDF_STRUCT.get("source").offset;
 const HEADER_GENERATION = MESH_SDF_STRUCT.get("generation").offset;
@@ -124,15 +177,6 @@ const INITIAL_LOG_CAPACITY = 64;
  */
 const INITIAL_ARENA_WORDS = 4096;
 
-/**
- * Geometries whose cards one frame places, at most: a safety net for a frame in which many complete.
- * A placement's five passes cost 140 µs a geometry at the median over Sponza's fill on the RTX 4090
- * (220 µs on the AMD iGPU), its split pass most of it, so ⌊1 ms / 140 µs⌋ of them fit the bake's
- * basis of 1 ms a frame there.
- * @type {number}
- */
-const MESH_CARD_PLACEMENTS_PER_FRAME = 7;
-
 /**
  * Most bricks a frame's take may hand out: evaluate and store run {@link MESH_SDF_GROUPS_PER_BRICK}
  * workgroups a brick in one dispatch row.
@@ -140,6 +184,26 @@ const MESH_CARD_PLACEMENTS_PER_FRAME = 7;
  */
 export const MESH_SDF_BAKE_BUDGET_MAX = Math.floor(WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION / MESH_SDF_GROUPS_PER_BRICK);
 
+/**
+ * Whether a bundle's field is laid out as `layout` lays its geometry out: the header's words, origin
+ * and voxel as the header's f32 hold them.
+ *
+ * @param {ModelCacheBundleField} field
+ * @param {MeshSDFLayout} layout
+ * @returns {boolean}
+ */
+function field_has_layout(field, layout) {
+    for (let axis = 0; axis < 3; axis++) {
+        if (field.origin[axis] !== Math.fround(layout.origin[axis]) || field.bricks[axis] !== layout.bricks[axis]) {
+            return false;
+        }
+    }
+
+    return field.voxel === Math.fround(layout.voxel)
+        && field.level_count === layout.level_count
+        && field.entries.length === layout.brick_count;
+}
+
 /**
  * The most bricks one geometry can have under `max_bricks`: every level of a cube of that many.
  *
@@ -196,8 +260,8 @@ function grow_typed(array, length) {
  * queues a bake; the last one going leaves the cache in place until {@link trim}, which only a user of
  * the caches calls, so a cache outlives a mode that stops using it and is there when the mode comes
  * back (D28). {@link forget} drops a geometry the geometry manager has let go of, whatever holds it.
- * {@link alias} points a geometry's id at another's cache, which readers follow, and whose holders and card sets
- * the aliased geometry's become: a skinned clone's at its source's, a virtual geometry's at its proxy's.
+ * {@link alias} points a geometry's id at another's cache, which readers follow, and whose holders and surface
+ * caches the aliased geometry's become: a skinned clone's at its source's, a virtual geometry's at its proxy's.
  *
  * **Side.** A holder says whether it draws both sides of the geometry. A field is baked two-sided
  * while any of its holders does: its vote then counts no back face, so nothing is inside it.
@@ -207,21 +271,29 @@ function grow_typed(array, length) {
  *
  * **The bake** ({@link graph_bake}, once a frame) admits queued geometries in request order whose
  * trees are resident, while the ring has room for every brick they could queue, and runs free,
- * classify, take, evaluate and store (`bake/`). At most `budget` bricks are evaluated a frame. The
- * device logs each geometry it completes; the log is read back, and the host turns the header
- * resident and sends {@link onBaked}. A take held back by the free slots is logged too, and the atlas
- * and its slot stack double.
+ * classify, take, evaluate, key, resolve and store (`bake/`). At most `budget` bricks are evaluated a
+ * frame. The device logs each geometry it completes; the log is read back, and the host turns the
+ * header resident and sends {@link onBaked}. A take held back by the free slots is logged too, and the
+ * atlas and its slot stack double.
+ *
+ * **Shared bricks.** Bricks of the same bytes, of one geometry or of many, share one slot: a slot
+ * counts the entries holding it and is given back with the last. A content table lists slots by the
+ * content keys of their bytes (`chunk_mesh_sdf_contents`, `MESH_SDF_BRICK_KEY.js`), and a brick takes
+ * a slot it finds there only once their bytes compare equal: a key that two bytes share costs a share,
+ * never a brick its bytes.
+ *
+ * **Bundles.** {@link export_bundle} reads resident fields and surface caches out as a
+ * `ModelCacheBundle`, each brick once; {@link upload_bundle} takes one back as the fields of geometries
+ * that have none, its bricks placed by the next bake, with or without sharing them with what is
+ * resident, and its caches offered to the surface caches.
  *
- * **Cards** (§6.5): a geometry turned resident has its cards placed by the next bake that has room
- * (`cards/`), in a range sized for any layout of its grid. The placement is logged with the columns
- * and pages it took; on that readback the geometry gets a range of exactly that size, and the next bake
- * moves the layout into it and gives the placement's range back. The layout then reaches
- * {@link cards}, whose card sets — one per (geometry, material) pair — are captured after the bake,
- * `capture_budget` pages a frame.
+ * **Surface caches**: a geometry turned resident reaches {@link surfaces} with the bricks its field
+ * stored, whose Model Surface Caches, one per (geometry, material) pair, are baked after the bake,
+ * `surface_budget` bricks a frame.
  *
  * **A geometry with no tree of its own** to bake from, a virtual geometry's, waits queued, as one whose
  * tree is not resident yet does, until it is pointed at a stand-in ({@link alias}): an ordinary geometry
- * in the same local space, baked, placed and captured here as any is. Whoever makes stand-ins hears of
+ * in the same local space, baked here as any is. Whoever makes stand-ins hears of
  * each geometry queued ({@link onRequested}) and let go ({@link onForgotten}), and aliases between
  * frames, its stand-in added to the geometry manager as any geometry is.
  *
@@ -277,50 +349,14 @@ export class GPUGeometrySDFManager {
     #state = new Uint8Array(64);
     #generation = new Uint32Array(64);
     #brick_count = new Uint32Array(64);
-
-    #card_state = new Uint8Array(64);
-    /** Words of the range the geometry's cards are placed in. */
-    #placement_words = new Uint32Array(64);
-    /** Where the placement's scratch starts in it. */
-    #placement_scratch = new Uint32Array(64);
-    /** Columns over the six directions of the geometry's level-0 grid: the histogram's threads. */
-    #placement_columns = new Uint32Array(64);
-    /** Pages the placed layout has. */
-    #card_pages = new Uint32Array(64);
-    /** Words the placed layout keeps. */
-    #card_words = new Uint32Array(64);
-    /** Texels a side of the layout's largest card: the grid's longest axis in voxels, plus one. */
-    #card_side = new Uint32Array(64);
-
-    /**
-     * The range each geometry's cards are being placed in.
-     * @type {(import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null)[]}
-     */
-    #card_scratch = [];
-
-    /**
-     * The range each geometry's placed layout keeps.
-     * @type {(import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null)[]}
-     */
-    #card_ranges = [];
-
-    /**
-     * Resident geometries whose cards wait for placement, in the order they turned resident.
-     * @type {number[]}
-     */
-    #place_queue = [];
+    /** Bricks given a slot, numbered 0 up, as the resident cache's completion reported them. */
+    #stored_bricks = new Uint32Array(64);
 
     /**
-     * Geometries whose placed layout waits to be moved into its own range.
-     * @type {number[]}
+     * The (geometry, material) pairs' surface material texels on the fields.
+     * @type {GPUMeshSurfaceCaches}
      */
-    #compact_queue = [];
-
-    /**
-     * The (geometry, material) pairs' captures of the layouts.
-     * @type {GPUMeshCardSets}
-     */
-    #cards;
+    #surfaces;
 
     /**
      * @type {(import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null)[]}
@@ -407,12 +443,56 @@ export class GPUGeometrySDFManager {
      */
     #pushes = [];
 
+    /**
+     * What each slot holds: the entries holding it, and the content key it is listed under
+     * (`chunk_mesh_sdf_contents`), MESH_SDF_CONTENT_WORDS a slot.
+     * @type {GPUBuffer|null}
+     */
+    #contents = null;
+
+    /**
+     * The slots by content key: a device-kept hash table of twice the slot capacity in records
+     * (`mesh_sdf_content_table_size`).
+     * @type {GPUBuffer|null}
+     */
+    #content_table = null;
+
+    /**
+     * The content table of the atlas before it last grew, whose records the next bake moves into the
+     * grown one, and its records; null when none is left to move.
+     * @type {GPUBuffer|null}
+     */
+    #rehash_from = null;
+    #rehash_records = 0;
+
+    /**
+     * Uploads of bundles' bricks the next bake records: its buffers, its counts, and the fields it
+     * completes.
+     * @type {{bytes: GPUBuffer, bricks: GPUBuffer, ranges: GPUBuffer, brick_count: number, range_count: number, entry_count: number, deduplicate: boolean, fields: Object[]}[]}
+     */
+    #uploads = [];
+
+    /**
+     * Fields whose upload a bake has recorded, resident from the next: (id, generation, and what their
+     * surface caches are laid out by).
+     * @type {{id: number, generation: number, blocks: number, table: Uint32Array, provisions: Object[]}[]}
+     */
+    #uploaded = [];
+
+    /**
+     * Buffers only the last bake's commands read, its uploads' and the content table it rehashed from,
+     * destroyed by the next {@link graph_bake}, once those commands are submitted.
+     * @type {GPUBuffer[]}
+     */
+    #garbage = [];
+
     /** @type {GPUBuffer|null} */
     #take = null;
 
     /**
-     * The frame's words in the arena: its log, room for {@link #log_capacity} completions, then its
-     * tallies, a word for each of {@link #staging_bricks} bricks taken.
+     * The frame's words in the arena: its log, room for {@link #log_capacity} completions, then a
+     * record of MESH_SDF_TAKEN_WORDS for each of {@link #staging_bricks} bricks taken, then the claims
+     * of that many bricks (`mesh_sdf_claim_size`).
      * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null}
      */
     #frame_range = null;
@@ -447,29 +527,24 @@ export class GPUGeometrySDFManager {
     #frame_log_offset = 0;
     #frame_log_bytes = 0;
     #frame_tally_offset = 0;
+    #frame_claim_offset = 0;
+    #frame_claim_size = 0;
     #frame_bytes = 0;
 
     #log_data = { arena: -1 };
 
-    /** The frame's placements, as geometry, the range's first word, and where its scratch starts. */
-    #frame_placements = [];
-    /** The frame's layout moves, as source, destination and words. */
-    #frame_compactions = [];
-
-    #histogram_settings = { geometry: 0, columns: 0 };
-    #split_settings = { geometry: 0 };
-    #merge_settings = { geometry: 0, dispatch: MESH_SDF_TAKE_PLACE_DISPATCH };
-    #pages_settings = { geometry: 0 };
-    #place_log_settings = { geometry: 0, log_offset: 0, log_capacity: 0 };
-    #compact_settings = { source: 0, destination: 0, count: 0, groups_x: 0 };
-
     #blas_bindings = { blas_lookup: null, blas_data: null, geometries: null, meshlet_metadata: null, meshlet_data: null };
 
     #classify_settings = { range_count: 0, brick_count: 0, groups_x: 0, ring_capacity: 0, log_offset: 0, log_capacity: 0 };
     #free_settings = { range_count: 0, entry_count: 0, groups_x: 0 };
     #take_settings = { budget: 0, log_offset: 0 };
-    #evaluate_settings = { ring_capacity: 0, slot_capacity: 0, log_offset: 0, log_capacity: 0, tally_offset: 0 };
-    #store_settings = { ring_capacity: 0 };
+    #evaluate_settings = { ring_capacity: 0, log_offset: 0, log_capacity: 0, tally_offset: 0 };
+    #key_settings = { ring_capacity: 0, tally_offset: 0 };
+    #resolve_settings = { ring_capacity: 0, slot_capacity: 0, log_offset: 0, tally_offset: 0, claim_offset: 0, claim_size: 0 };
+    #store_settings = { ring_capacity: 0, tally_offset: 0 };
+    #rehash_settings = { groups_x: 0 };
+    #upload_settings = { brick_count: 0, deduplicate: 0, slot_capacity: 0, range_count: 0, entry_count: 0, groups_x: 0 };
+    #count_settings = { log_offset: 0, log_capacity: 0 };
     #push_settings = { first: 0, count: 0, counter: MESH_SDF_COUNTER_SLOTS };
     #bindings = {};
 
@@ -492,6 +567,8 @@ export class GPUGeometrySDFManager {
     #resident_count = 0;
     #starved_frames = 0;
     #bricks_evaluated = 0;
+    #bricks_shared = 0;
+    #bricks_collided = 0;
     #free_slots = 0;
 
     #destroyed = false;
@@ -506,16 +583,17 @@ export class GPUGeometrySDFManager {
 
         this.#device = device;
         this.#geometries = geometries;
-        this.#cards = new GPUMeshCardSets(device);
+        this.#surfaces = new GPUMeshSurfaceCaches(device);
     }
 
     /**
-     * The card sets: one capture of a geometry's layout per (geometry, material) pair, which their
-     * user acquires and releases. Layouts reach it as they are placed.
-     * @returns {GPUMeshCardSets}
+     * The Model Surface Caches: one (geometry, material) pair's surface material texels on its
+     * geometry's field, which their user acquires and releases. Fields reach it as they turn resident,
+     * with the bricks they stored.
+     * @returns {GPUMeshSurfaceCaches}
      */
-    get cards() {
-        return this.#cards;
+    get surfaces() {
+        return this.#surfaces;
     }
 
     /**
@@ -696,9 +774,9 @@ export class GPUGeometrySDFManager {
      * follows the source through its bake.
      *
      * Whatever held `clone`'s own cache holds `source`'s from here on, its side included, as does every holder of
-     * `clone` after; and `clone`'s card sets capture `source`'s layout through `source`'s meshlets
-     * ({@link GPUMeshCardSets#alias}). So a source whose stand-in arrives after `clone` was asked for needs
-     * nothing moved by its holders.
+     * `clone` after; and `clone`'s surface caches follow `source`'s field and are baked from `source`'s
+     * triangles ({@link GPUMeshSurfaceCaches#alias}). So a source whose stand-in arrives after `clone` was
+     * asked for needs nothing moved by its holders.
      *
      * @param {GPUGeometryMetadata} clone
      * @param {GPUGeometryMetadata} source
@@ -751,7 +829,7 @@ export class GPUGeometrySDFManager {
 
         clones.push(id);
 
-        this.#cards.alias(id, source.index);
+        this.#surfaces.alias(id, source.index);
 
         if (this.#state[source.index] === HOST_RESIDENT) {
             // its readers read a resident cache from here on
@@ -780,6 +858,7 @@ export class GPUGeometrySDFManager {
     state_of(record) {
         switch (this.#state[record.index] ?? HOST_NONE) {
             case HOST_BAKING:
+            case HOST_UPLOADING:
                 return MeshSDFState.Baking;
             case HOST_RESIDENT:
                 return MeshSDFState.Resident;
@@ -866,6 +945,23 @@ export class GPUGeometrySDFManager {
         return this.#bricks_evaluated;
     }
 
+    /**
+     * Bricks the bake gave a slot already holding their bytes, as read back.
+     * @returns {number}
+     */
+    get bricks_shared() {
+        return this.#bricks_shared;
+    }
+
+    /**
+     * Bricks the bake gave a slot of their own because the slot their content key found, or the
+     * frame's first brick of that key, holds other bytes, as read back.
+     * @returns {number}
+     */
+    get bricks_collided() {
+        return this.#bricks_collided;
+    }
+
     /**
      * Free slots of the atlas before the last take read back.
      * @returns {number}
@@ -942,7 +1038,7 @@ export class GPUGeometrySDFManager {
     get gpu_memory_usage() {
         let bytes = 0;
 
-        for (const buffer of [this.#headers, this.#indirection, this.#slots, this.#take, this.#ring, this.#classify_ranges, this.#free_ranges]) {
+        for (const buffer of [this.#headers, this.#indirection, this.#slots, this.#contents, this.#content_table, this.#rehash_from, this.#take, this.#ring, this.#classify_ranges, this.#free_ranges]) {
             if (buffer !== null) {
                 bytes += buffer.size;
             }
@@ -952,32 +1048,387 @@ export class GPUGeometrySDFManager {
             bytes += this.#atlas.capacity * MESH_SDF_BRICK_TEXELS ** 3;
         }
 
-        return bytes + this.#cards.gpu_memory_usage;
+        return bytes + this.#surfaces.gpu_memory_usage;
+    }
+
+    /**
+     * Take a bundle's fields (`ModelCacheBundle`) as the caches of the geometries `records` names, in
+     * place of baking them, and offer its surface caches to the caches of the materials `materials`
+     * names. A field is taken by a geometry that has no cache and no bake under way, whose layout at this
+     * manager's voxel size and cap is the field's; any other is left to bake as it would. The next bake
+     * places the bundle's bricks and links the fields' entries to them, and the fields are resident from
+     * the bake after, their surface caches laid out by the bundle's tables (`GPUMeshSurfaceCaches.adopt_layout`).
+     *
+     * A bundle keeps each brick once however many fields hold it. Deduplicating, a brick whose bytes a
+     * slot already holds takes that slot, and the rest are listed for bricks baked later to share; not
+     * deduplicating, each takes a slot of its own, never shared, which suits a bundle of a whole scene
+     * loaded alone. The atlas grows ahead of the bake for every brick, so none waits for a slot.
+     *
+     * A field taken is the geometry's like a baked one: held, released and trimmed alike.
+     *
+     * @param {ModelCacheBundle} bundle baked at this manager's `configure`
+     * @param {(GPUGeometryMetadata|null)[]} records the geometry of each of the bundle's fields; null takes none
+     * @param {(ShadeMaterial|null)[]} materials the material of each of the bundle's caches; null offers none
+     * @param {boolean} deduplicate whether its bricks share slots with those resident, and are shared
+     * @returns {number} the fields taken
+     */
+    upload_bundle(bundle, records, materials, deduplicate) {
+        assert.equal(bundle.voxel_size, Math.fround(this.#voxel_size), 'bundle.voxel_size: baked at another voxel');
+        assert.equal(bundle.max_bricks, this.#max_bricks, 'bundle.max_bricks: baked under another cap');
+        assert.equal(records.length, bundle.fields.length, 'records: one for each field');
+        assert.equal(materials.length, bundle.caches.length, 'materials: one for each cache');
+        assert.isBoolean(deduplicate, 'deduplicate');
+
+        this.#ensure_device();
+        this.#ensure_headers(this.#geometries.__last_geometry_index);
+
+        const layout = this.#layout;
+        /** the bundle's bricks the upload carries, by their place in it */
+        const place_of = new Map();
+        const runs = [];
+        const fields = [];
+
+        let entries = 0;
+
+        for (let f = 0; f < bundle.fields.length; f++) {
+            const record = records[f];
+
+            if (record === null) {
+                continue;
+            }
+
+            const id = record.index;
+
+            this.#ensure_id(id);
+
+            if (this.#state[id] !== HOST_NONE && this.#state[id] !== HOST_QUEUED) {
+                continue;
+            }
+
+            const field = bundle.fields[f];
+
+            layout.compute(record.geometry.bounding_box, this.#voxel_size, this.#max_bricks);
+
+            if (!field_has_layout(field, layout)) {
+                continue;
+            }
+
+            const count = layout.brick_count;
+            const stored = field.numbered.length;
+
+            // its stored count and pending word, then its entries, its bricks' numbers and its bricks by number
+            const words = 3 * count + 2;
+
+            this.#ensure_indirection(words);
+
+            const range = this.#indirection_allocator.allocate(words);
+
+            assert.notEqual(range.offset, ALLOCATOR_NO_SPACE, 'indirection allocation after growth');
+
+            const scratch = new Uint32Array(words);
+
+            scratch[0] = stored;
+
+            for (let e = 0; e < count; e++) {
+                const entry = field.entries[e];
+
+                if (entry < MESH_SDF_EMPTY) {
+                    let place = place_of.get(entry);
+
+                    if (place === undefined) {
+                        place = place_of.size;
+                        place_of.set(entry, place);
+                    }
+
+                    // its place in the upload, which link turns into its slot
+                    scratch[2 + e] = place;
+                } else {
+                    scratch[2 + e] = entry;
+                }
+
+                scratch[2 + count + e] = MESH_SDF_UNNUMBERED;
+            }
+
+            for (let n = 0; n < stored; n++) {
+                scratch[2 + count + field.numbered[n]] = n;
+                scratch[2 + 2 * count + n] = field.numbered[n];
+            }
+
+            this.#device.queue.writeBuffer(this.#indirection, 4 * range.offset, scratch);
+
+            this.#records[id] = record;
+            this.#ranges[id] = range;
+            this.#brick_count[id] = count;
+            this.#stored_bricks[id] = stored;
+            this.#generation[id]++;
+            this.#two_sided[id] = field.two_sided;
+            this.#state[id] = HOST_UPLOADING;
+
+            this.#write_header(id, layout, range.offset + 2, MeshSDFState.Baking);
+
+            const provisions = [];
+
+            for (let c = 0; c < bundle.caches.length; c++) {
+                if (bundle.caches[c].field === f && materials[c] !== null) {
+                    provisions.push({ material: materials[c], cache: bundle.caches[c] });
+                }
+            }
+
+            fields.push({ id, generation: this.#generation[id], blocks: field.blocks, table: field.table, provisions });
+
+            runs.push(entries, range.offset + 2);
+            entries += count;
+        }
+
+        if (fields.length === 0) {
+            return 0;
+        }
+
+        const brick_count = place_of.size;
+        const bytes = new Uint8Array(Math.max(4, brick_count * MESH_SDF_BRICK_TEXEL_COUNT));
+
+        for (const [brick, place] of place_of) {
+            bytes.set(bundle.bricks.subarray(brick * MESH_SDF_BRICK_TEXEL_COUNT, (brick + 1) * MESH_SDF_BRICK_TEXEL_COUNT), place * MESH_SDF_BRICK_TEXEL_COUNT);
+        }
+
+        // room on the stack for every brick, whatever is free there now: no pop of the upload's is refused
+        const target = this.#slot_capacity + brick_count;
+
+        while (this.#slot_capacity < target) {
+            const before = this.#slot_capacity;
+
+            this.#grow_slots();
+
+            assert.greaterThan(this.#slot_capacity, before, 'the atlas is at its limit: the bundle\'s bricks do not fit');
+
+            // a log from before this growth asked for what it gives
+            this.#grown_frame = this.#frame;
+        }
+
+        const device = this.#device;
+        const upload_bytes = this.#create_buffer("upload bytes", bytes.length, GPUBufferUsage.COPY_DST);
+        const upload_bricks = this.#create_buffer("upload bricks", 4 * Math.max(1, brick_count * MESH_SDF_UPLOAD_BRICK_WORDS), GPUBufferUsage.COPY_DST);
+        const upload_ranges = this.#create_buffer("upload ranges", 4 * runs.length, GPUBufferUsage.COPY_DST);
+
+        device.queue.writeBuffer(upload_bytes, 0, bytes);
+        device.queue.writeBuffer(upload_ranges, 0, Uint32Array.from(runs));
+
+        this.#uploads.push({
+            bytes: upload_bytes,
+            bricks: upload_bricks,
+            ranges: upload_ranges,
+            brick_count,
+            range_count: runs.length / 2,
+            entry_count: entries,
+            deduplicate,
+            fields,
+        });
+
+        return fields.length;
+    }
+
+    /**
+     * The fields taken from bundles whose bricks the last bake placed are resident.
+     */
+    #complete_uploads() {
+        const uploaded = this.#uploaded;
+
+        for (let i = 0; i < uploaded.length; i++) {
+            const { id, generation, blocks, table, provisions } = uploaded[i];
+
+            if (this.#state[id] !== HOST_UPLOADING || this.#generation[id] !== generation) {
+                // dropped since, or taken again
+                continue;
+            }
+
+            this.#state[id] = HOST_RESIDENT;
+            this.#resident_count++;
+
+            const meshlets = this.#records[id].geometry?.meshlets;
+
+            this.#surfaces.adopt_layout(id, this.#stored_bricks[id], meshlets === undefined ? true : meshlet_batch_colored(meshlets), blocks, table, provisions);
+
+            this.#word_scratch[0] = MeshSDFState.Resident;
+            this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES + HEADER_STATE, this.#word_scratch, 0, 1);
+
+            // its side, against its holders', as for a bake done
+            this.#holders_changed.push(id);
+
+            this.onBaked.send1(id);
+
+            const clones = this.#clones_of.get(id);
+
+            if (clones !== undefined) {
+                for (let c = 0; c < clones.length; c++) {
+                    this.onBaked.send1(clones[c]);
+                }
+            }
+        }
+
+        uploaded.length = 0;
+    }
+
+    /**
+     * A bundle (`ModelCacheBundle`) of the resident fields of `records` and the resident surface caches
+     * `caches`, as the device holds them when the readbacks land: each brick once, however many fields
+     * hold it, and each cache naming its field. Read while nothing bakes, it is what was baked.
+     *
+     * @param {GPUGeometryMetadata[]} records
+     * @param {number[]} caches surface cache ids, each of a geometry of `records`
+     * @returns {Promise<ModelCacheBundle>}
+     */
+    async export_bundle(records, caches) {
+        this.#ensure_device();
+
+        for (let i = 0; i < records.length; i++) {
+            assert.equal(this.#state[records[i].index], HOST_RESIDENT, `geometry ${records[i].index} has no resident cache`);
+        }
+
+        const device = this.#device;
+        const atlas = this.#atlas;
+        const [arena, texels, data] = await Promise.all([
+            read_back(device, this.#indirection),
+            download_texture_data({ device, source: atlas.texture.gpu_texture }),
+            read_back(device, this.#surfaces.data),
+        ]);
+
+        const bundle = new ModelCacheBundle();
+
+        bundle.voxel_size = Math.fround(this.#voxel_size);
+        bundle.max_bricks = this.#max_bricks;
+
+        const t = MESH_SDF_BRICK_TEXELS;
+        const width = atlas.slots_x * t;
+        const height = atlas.slots_y * t;
+        const bricks = [];
+        const brick_of_slot = new Map();
+        const bricks_by_key = new Map();
+        const scratch = new Uint8Array(MESH_SDF_BRICK_TEXEL_COUNT);
+
+        // a slot's bytes, as one of the bundle's bricks: the first brick of the same bytes
+        const brick_of = slot => {
+            let brick = brick_of_slot.get(slot);
+
+            if (brick !== undefined) {
+                return brick;
+            }
+
+            const x = (slot % atlas.slots_x) * t;
+            const y = (Math.floor(slot / atlas.slots_x) % atlas.slots_y) * t;
+            const z = Math.floor(slot / (atlas.slots_x * atlas.slots_y)) * t;
+
+            for (let tz = 0; tz < t; tz++) {
+                for (let ty = 0; ty < t; ty++) {
+                    const row = (x) + width * ((y + ty) + height * (z + tz));
+
+                    scratch.set(texels.subarray(row, row + t), t * (ty + t * tz));
+                }
+            }
+
+            // the key groups the bricks whose bytes may agree, and the bytes say which do
+            const key = mesh_sdf_brick_key(scratch, 0);
+            const candidates = bricks_by_key.get(key);
+
+            if (candidates !== undefined) {
+                for (let i = 0; i < candidates.length; i++) {
+                    if (same_brick(bricks[candidates[i]], 0, scratch, 0)) {
+                        brick = candidates[i];
+                        break;
+                    }
+                }
+            }
+
+            if (brick === undefined) {
+                brick = bricks.length;
+                bricks.push(scratch.slice());
+
+                if (candidates === undefined) {
+                    bricks_by_key.set(key, [brick]);
+                } else {
+                    candidates.push(brick);
+                }
+            }
+
+            brick_of_slot.set(slot, brick);
+
+            return brick;
+        };
+
+        const layout = this.#layout;
+        const field_of = new Map();
+
+        for (let i = 0; i < records.length; i++) {
+            const id = records[i].index;
+            const count = this.#brick_count[id];
+            const stored = this.#stored_bricks[id];
+            const base = this.#ranges[id].offset + 2;
+            const field = new ModelCacheBundleField();
+
+            layout.compute(records[i].geometry.bounding_box, this.#voxel_size, this.#max_bricks);
+
+            for (let axis = 0; axis < 3; axis++) {
+                field.origin[axis] = layout.origin[axis];
+                field.bricks[axis] = layout.bricks[axis];
+            }
+
+            field.voxel = Math.fround(layout.voxel);
+            field.level_count = layout.level_count;
+            field.two_sided = this.#two_sided[id];
+            field.entries = new Uint32Array(count);
+
+            for (let e = 0; e < count; e++) {
+                const entry = arena[base + e];
+
+                field.entries[e] = entry < MESH_SDF_EMPTY ? brick_of(entry) : entry;
+            }
+
+            field.numbered = arena.slice(base + 2 * count, base + 2 * count + stored);
+
+            const { blocks, table } = this.#surfaces.export_table(id, data);
+
+            field.blocks = blocks;
+            field.table = table;
+
+            field_of.set(id, bundle.fields.length);
+            bundle.fields.push(field);
+        }
+
+        bundle.bricks = new Uint8Array(bricks.length * MESH_SDF_BRICK_TEXEL_COUNT);
+
+        for (let i = 0; i < bricks.length; i++) {
+            bundle.bricks.set(bricks[i], i * MESH_SDF_BRICK_TEXEL_COUNT);
+        }
+
+        for (let i = 0; i < caches.length; i++) {
+            const field = field_of.get(this.#surfaces.geometry_of(caches[i]));
+
+            assert.defined(field, `surface cache ${caches[i]}'s geometry is not among the records`);
+
+            bundle.caches.push(this.#surfaces.export_cache(caches[i], field, data, new ModelCacheBundleCache()));
+        }
+
+        return bundle;
     }
 
     /**
      * Record the frame's bake: queue again what is held for the other side than it was baked for, free
-     * what was given back, classify what is admitted, take, evaluate and store up to `budget` bricks,
-     * place the cards of what turned resident and move placed layouts into their ranges. Then, with a
-     * `capture_budget`, capture up to that many pages of card sets. Records nothing when there is
-     * nothing to do.
+     * what was given back, classify what is admitted, and take, evaluate and store up to `budget`
+     * bricks. Then, with a `surface_budget`, bake up to that many bricks of surface caches. Records
+     * nothing when there is nothing to do.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.budget bricks evaluated at most, `mesh_sdf_bake_budget`
-     * @param {number} [options.capture_budget] card pages captured at most, `card_capture_budget`; 0
-     *        captures nothing
-     * @param {GPUResidentMaterialContext|null} [options.materials] what a traced capture shades with,
-     *        which makes what it traces resident; needed with a `capture_budget`
-     * @param {GPUMaterialManager|null} [options.material_contexts] what a raster capture draws with
-     *        ({@link GPUMeshCardSets#capture_mode}); needed with a `capture_budget` in that mode
-     */
-    graph_bake({ graph, budget, capture_budget = 0, materials = null, material_contexts = null }) {
+     * @param {number} [options.surface_budget] surface cache bricks baked at most,
+     *        `surface_bake_budget`; 0 bakes nothing
+     * @param {GPUResidentMaterialContext|null} [options.materials] what the surface bake shades with,
+     *        which makes what it traces resident; needed with a `surface_budget`
+     */
+    graph_bake({ graph, budget, surface_budget = 0, materials = null }) {
         assert.defined(graph, 'graph');
         assert.isPositiveInteger(budget, 'budget');
         assert.lessThanOrEqual(budget, MESH_SDF_BAKE_BUDGET_MAX, 'budget');
-        assert.isNonNegativeInteger(capture_budget, 'capture_budget');
-        assert.lessThanOrEqual(capture_budget, MESH_CARD_CAPTURE_BUDGET_MAX, 'capture_budget');
+        assert.isNonNegativeInteger(surface_budget, 'surface_budget');
 
         this.#frame++;
 
@@ -992,15 +1443,24 @@ export class GPUGeometrySDFManager {
 
         release_next.length = 0;
 
+        const garbage = this.#garbage;
+
+        for (let i = 0; i < garbage.length; i++) {
+            garbage[i].destroy();
+        }
+
+        garbage.length = 0;
+
+        this.#complete_uploads();
+
         const queued_bound = this.#read_queued + (this.#admitted_total - this.#read_admitted);
 
         const has_work = this.#admittable()
             || queued_bound > 0
             || this.#freed.length > 0
             || this.#pushes.length > 0
-            || this.#fill_pending
-            || this.#placeable()
-            || this.#compact_queue.length > 0;
+            || this.#uploads.length > 0
+            || this.#fill_pending;
 
         let arena = -1;
 
@@ -1012,7 +1472,7 @@ export class GPUGeometrySDFManager {
             }
         }
 
-        if (capture_budget > 0 && this.#cards.has_pending_capture) {
+        if (surface_budget > 0 && this.#surfaces.has_pending_bake) {
             assert.notNull(materials, 'materials');
 
             this.#ensure_device();
@@ -1030,13 +1490,13 @@ export class GPUGeometrySDFManager {
             blas.meshlet_metadata = geometries.meshlets.buffer_metadata;
             blas.meshlet_data = geometries.meshlets.buffer_data;
 
-            this.#cards.graph_capture({
+            this.#surfaces.graph_bake({
                 graph,
-                budget: capture_budget,
+                budget: surface_budget,
                 arena,
                 headers: this.#headers,
+                field_atlas: this.#atlas.texture.obtainView(),
                 materials,
-                material_contexts,
                 blas,
             });
         }
@@ -1054,12 +1514,10 @@ export class GPUGeometrySDFManager {
 
         this.#admit(queued_bound);
         this.#upload_free_ranges();
-        this.#take_placements();
-        this.#take_compactions();
 
-        // room for a completion of every geometry in flight and a record of every placement, and a tally
-        // and staging for every brick the budget takes
-        this.#ensure_frame(Math.max(1, this.#baking + this.#frame_placements.length / 3), budget);
+        // room for a completion of every geometry in flight, and a record and staging for every brick the
+        // budget takes
+        this.#ensure_frame(Math.max(1, this.#baking), budget);
 
         const log_words = MESH_SDF_LOG_HEADER_WORDS + MESH_SDF_LOG_RECORD_WORDS * this.#log_capacity;
 
@@ -1068,7 +1526,9 @@ export class GPUGeometrySDFManager {
         this.#frame_log_offset = this.#frame_range.offset;
         this.#frame_log_bytes = 4 * log_words;
         this.#frame_tally_offset = this.#frame_range.offset + log_words;
-        this.#frame_bytes = 4 * (log_words + this.#staging_bricks);
+        this.#frame_claim_offset = this.#frame_tally_offset + MESH_SDF_TAKEN_WORDS * this.#staging_bricks;
+        this.#frame_claim_size = mesh_sdf_claim_size(this.#staging_bricks);
+        this.#frame_bytes = 4 * (log_words + MESH_SDF_TAKEN_WORDS * this.#staging_bricks + this.#frame_claim_size);
 
         const data = this.#log_data;
 
@@ -1136,80 +1596,6 @@ export class GPUGeometrySDFManager {
         changed.length = 0;
     }
 
-    /**
-     * Give the frame's placements their ranges, in the order the geometries turned resident.
-     */
-    #take_placements() {
-        const queue = this.#place_queue;
-        const placements = this.#frame_placements;
-
-        placements.length = 0;
-
-        let taken = 0;
-
-        while (taken < queue.length && placements.length < 3 * MESH_CARD_PLACEMENTS_PER_FRAME) {
-            const id = queue[taken++];
-
-            if (this.#state[id] !== HOST_RESIDENT || this.#card_state[id] !== CARDS_QUEUED) {
-                // dropped since it was queued
-                continue;
-            }
-
-            const words = this.#placement_words[id];
-
-            this.#ensure_indirection(words);
-
-            const range = this.#indirection_allocator.allocate(words);
-
-            assert.notEqual(range.offset, ALLOCATOR_NO_SPACE, 'card placement allocation after growth');
-
-            this.#card_scratch[id] = range;
-            this.#card_state[id] = CARDS_PLACING;
-            this.#write_header_cards(id, range.offset);
-
-            placements.push(id, range.offset, this.#placement_scratch[id]);
-        }
-
-        queue.copyWithin(0, taken);
-        queue.length -= taken;
-    }
-
-    /**
-     * Move the layouts whose placement has been read back into their own ranges, this frame; their
-     * card sets can be captured from here.
-     */
-    #take_compactions() {
-        const queue = this.#compact_queue;
-        const moves = this.#frame_compactions;
-
-        moves.length = 0;
-
-        for (let i = 0; i < queue.length; i++) {
-            const id = queue[i];
-
-            if (this.#card_state[id] !== CARDS_COMPACTING) {
-                // dropped since
-                continue;
-            }
-
-            const source = this.#card_scratch[id];
-            const target = this.#card_ranges[id];
-
-            moves.push(source.offset, target.offset, this.#card_words[id]);
-
-            // the copy reads it this frame
-            this.#release_next.push(source);
-            this.#card_scratch[id] = null;
-
-            this.#card_state[id] = CARDS_PLACED;
-            this.#write_header_cards(id, target.offset);
-
-            this.#cards.set_layout(id, this.#card_pages[id], this.#card_side[id]);
-        }
-
-        queue.length = 0;
-    }
-
     /**
      * Whether a queued geometry's tree is traceable, so that a bake could admit it. A geometry that
      * waits for its tree, or for a source's cache, records no bake while it waits. Drops from the queue
@@ -1243,30 +1629,6 @@ export class GPUGeometrySDFManager {
         return admittable;
     }
 
-    /**
-     * Whether a resident geometry's cards wait for placement. Drops from the queue what was dropped
-     * since it was queued.
-     *
-     * @returns {boolean}
-     */
-    #placeable() {
-        const queue = this.#place_queue;
-
-        let kept = 0;
-
-        for (let i = 0; i < queue.length; i++) {
-            const id = queue[i];
-
-            if (this.#state[id] === HOST_RESIDENT && this.#card_state[id] === CARDS_QUEUED) {
-                queue[kept++] = id;
-            }
-        }
-
-        queue.length = kept;
-
-        return kept > 0;
-    }
-
     /**
      * Admit queued geometries in request order: those whose tree is resident, while every brick they
      * could queue fits on the ring beside what may be on it already.
@@ -1312,10 +1674,12 @@ export class GPUGeometrySDFManager {
                 continue;
             }
 
-            // the geometry's pending word, then its entries
-            this.#ensure_indirection(count + 1);
+            // its stored count and pending word, then its entries, its bricks' numbers and its bricks by number
+            const words = 3 * count + 2;
 
-            const range = this.#indirection_allocator.allocate(count + 1);
+            this.#ensure_indirection(words);
+
+            const range = this.#indirection_allocator.allocate(words);
 
             assert.notEqual(range.offset, ALLOCATOR_NO_SPACE, 'indirection allocation after growth');
 
@@ -1330,19 +1694,12 @@ export class GPUGeometrySDFManager {
                 this.#coarsened_count++;
             }
 
-            this.#write_header(id, layout, range.offset + 1, MeshSDFState.Baking);
-
-            // level 0's grid, which the cards are placed over
-            const grid = layout.bricks;
-            const placement = mesh_card_placement_of(grid);
+            this.#write_header(id, layout, range.offset + 2, MeshSDFState.Baking);
 
-            this.#placement_words[id] = placement.words;
-            this.#placement_scratch[id] = placement.histograms;
-            this.#placement_columns[id] = 2 * (grid[0] * grid[1] + grid[1] * grid[2] + grid[0] * grid[2]);
-            this.#card_side[id] = Math.max(grid[0], grid[1], grid[2]) * MESH_SDF_BRICK_VOXELS + 1;
-
-            this.#word_scratch[0] = count;
-            this.#device.queue.writeBuffer(this.#indirection, range.offset * 4, this.#word_scratch, 0, 1);
+            // nothing stored yet, every brick pending
+            this.#word_scratch[0] = 0;
+            this.#word_scratch[1] = count;
+            this.#device.queue.writeBuffer(this.#indirection, range.offset * 4, this.#word_scratch, 0, 2);
 
             this.#classify_scratch = grow_typed(this.#classify_scratch, 2 * (runs + 1));
             this.#classify_scratch[2 * runs] = bricks;
@@ -1406,6 +1763,68 @@ export class GPUGeometrySDFManager {
      */
     #execute = (data, resources, context) => this.#execute_bake(data, resources, context);
 
+    /**
+     * Each upload's passes (`shader_mesh_sdf_upload`), after the content table's rehash and before free:
+     * deduplicating, its bricks' keys, the slots listed under them and their bytes compared with the
+     * bricks'; then fresh slots for the rest, their bytes stored, and the fields' entries linked.
+     *
+     * @param {GPUCommandEncoder} encoder
+     * @param {GPUBuffer} arena
+     */
+    #execute_uploads(encoder, arena) {
+        const b = this.#bindings;
+        const settings = this.#upload_settings;
+
+        b.mesh_sdf_indirection = arena;
+        b.mesh_sdf_slots = this.#slots;
+        b.mesh_sdf_atlas = this.#atlas.texture.obtainView();
+        b.mesh_sdf_atlas_store = this.#atlas.texture.obtainView();
+        b.settings = settings;
+
+        const fold = threads => {
+            const groups = Math.max(1, Math.ceil(threads / MESH_SDF_BAKE_WORKGROUP_SIZE));
+            const groups_x = Math.min(groups, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION);
+
+            settings.groups_x = groups_x;
+
+            return { group_count_x: groups_x, group_count_y: Math.ceil(groups / groups_x) };
+        };
+
+        for (const upload of this.#uploads) {
+            settings.brick_count = upload.brick_count;
+            settings.deduplicate = upload.deduplicate ? 1 : 0;
+            settings.slot_capacity = this.#slot_capacity;
+            settings.range_count = upload.range_count;
+            settings.entry_count = upload.entry_count;
+
+            b.mesh_sdf_upload_bytes = upload.bytes;
+            b.mesh_sdf_upload_bricks = upload.bricks;
+            b.mesh_sdf_ranges = upload.ranges;
+
+            const texels = upload.brick_count * MESH_SDF_BRICK_TEXEL_COUNT;
+
+            if (upload.brick_count > 0) {
+                if (upload.deduplicate) {
+                    shader_mesh_sdf_upload_key.dispatch({ encoder, ...fold(texels), bindings: b });
+                    shader_mesh_sdf_upload_find.dispatch({ encoder, ...fold(upload.brick_count), bindings: b });
+                    shader_mesh_sdf_upload_compare.dispatch({ encoder, ...fold(texels), bindings: b });
+                }
+
+                shader_mesh_sdf_upload_fresh.dispatch({ encoder, ...fold(upload.brick_count), bindings: b });
+                shader_mesh_sdf_upload_store.dispatch({ encoder, ...fold(texels), bindings: b });
+                shader_mesh_sdf_upload_link.dispatch({ encoder, ...fold(upload.entry_count), bindings: b });
+            }
+
+            for (let i = 0; i < upload.fields.length; i++) {
+                this.#uploaded.push(upload.fields[i]);
+            }
+
+            this.#garbage.push(upload.bytes, upload.bricks, upload.ranges);
+        }
+
+        this.#uploads.length = 0;
+    }
+
     /**
      * @param {Object} data
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
@@ -1446,6 +1865,35 @@ export class GPUGeometrySDFManager {
 
         pushes.length = 0;
 
+        b.mesh_sdf_contents = this.#contents;
+        b.mesh_sdf_content_table = this.#content_table;
+
+        if (this.#rehash_from !== null) {
+            const groups = Math.ceil(this.#rehash_records / MESH_SDF_BAKE_WORKGROUP_SIZE);
+            const groups_x = Math.min(groups, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION);
+            const settings = this.#rehash_settings;
+
+            settings.groups_x = groups_x;
+
+            b.settings = settings;
+            b.mesh_sdf_content_table_before = this.#rehash_from;
+
+            shader_mesh_sdf_content_rehash.dispatch({
+                encoder,
+                group_count_x: groups_x,
+                group_count_y: Math.ceil(groups / groups_x),
+                bindings: b,
+            });
+
+            this.#garbage.push(this.#rehash_from);
+            this.#rehash_from = null;
+            b.mesh_sdf_content_table_before = null;
+        }
+
+        if (this.#uploads.length > 0) {
+            this.#execute_uploads(encoder, arena);
+        }
+
         const geometries = this.#geometries;
 
         b.blas_lookup = geometries.blas.buffer_metadata;
@@ -1511,7 +1959,6 @@ export class GPUGeometrySDFManager {
         const evaluate_settings = this.#evaluate_settings;
 
         evaluate_settings.ring_capacity = this.#ring_capacity;
-        evaluate_settings.slot_capacity = this.#slot_capacity;
         evaluate_settings.log_offset = this.#frame_log_offset;
         evaluate_settings.log_capacity = this.#frame_log_capacity;
         evaluate_settings.tally_offset = this.#frame_tally_offset;
@@ -1525,91 +1972,70 @@ export class GPUGeometrySDFManager {
             command_offset: MESH_SDF_TAKE_DISPATCH * 4,
         });
 
-        this.#store_settings.ring_capacity = this.#ring_capacity;
-        b.settings = this.#store_settings;
-        b.mesh_sdf_atlas_store = this.#atlas.texture.obtainView();
+        const key_settings = this.#key_settings;
 
-        shader_mesh_sdf_store.dispatchIndirect({
+        key_settings.ring_capacity = this.#ring_capacity;
+        key_settings.tally_offset = this.#frame_tally_offset;
+        b.settings = key_settings;
+
+        shader_mesh_sdf_key.dispatchIndirect({
             encoder,
             bindings: b,
             command: this.#take,
             command_offset: MESH_SDF_TAKE_DISPATCH * 4,
         });
 
-        // card placement, a geometry at a time over its level-0 entries: the scratch cleared, then
-        // histogram, split, merge, pages and log
-        const placements = this.#frame_placements;
+        const resolve_settings = this.#resolve_settings;
 
-        for (let i = 0; i < placements.length; i += 3) {
-            const id = placements[i];
-            const first = placements[i + 1];
-            const scratch = placements[i + 2];
+        resolve_settings.ring_capacity = this.#ring_capacity;
+        resolve_settings.slot_capacity = this.#slot_capacity;
+        resolve_settings.log_offset = this.#frame_log_offset;
+        resolve_settings.tally_offset = this.#frame_tally_offset;
+        resolve_settings.claim_offset = this.#frame_claim_offset;
+        resolve_settings.claim_size = this.#frame_claim_size;
+        b.settings = resolve_settings;
 
-            encoder.clearBuffer(arena, 4 * (first + scratch), 4 * (this.#placement_words[id] - scratch));
+        // a thread a brick the budget can take
+        const resolve_groups = Math.ceil(this.#frame_budget / MESH_SDF_BAKE_WORKGROUP_SIZE);
 
-            const histogram = this.#histogram_settings;
+        shader_mesh_sdf_resolve_find.dispatch({ encoder, group_count_x: resolve_groups, bindings: b });
 
-            histogram.geometry = id;
-            histogram.columns = this.#placement_columns[id];
-            b.settings = histogram;
+        b.mesh_sdf_atlas = this.#atlas.texture.obtainView();
 
-            shader_mesh_cards_histogram.dispatch({
-                encoder,
-                group_count_x: Math.ceil(histogram.columns / MESH_SDF_BAKE_WORKGROUP_SIZE),
-                bindings: b,
-            });
-
-            this.#split_settings.geometry = id;
-            b.settings = this.#split_settings;
-
-            shader_mesh_cards_split.dispatch({ encoder, bindings: b });
-
-            this.#merge_settings.geometry = id;
-            b.settings = this.#merge_settings;
-
-            shader_mesh_cards_merge.dispatch({ encoder, bindings: b });
-
-            this.#pages_settings.geometry = id;
-            b.settings = this.#pages_settings;
-
-            shader_mesh_cards_pages.dispatchIndirect({
-                encoder,
-                bindings: b,
-                command: this.#take,
-                command_offset: MESH_SDF_TAKE_PLACE_DISPATCH * 4,
-            });
-
-            const log = this.#place_log_settings;
+        shader_mesh_sdf_resolve_compare.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#take,
+            command_offset: MESH_SDF_TAKE_DISPATCH * 4,
+        });
 
-            log.geometry = id;
-            log.log_offset = this.#frame_log_offset;
-            log.log_capacity = this.#frame_log_capacity;
-            b.settings = log;
+        shader_mesh_sdf_resolve_fresh.dispatch({ encoder, group_count_x: resolve_groups, bindings: b });
+        shader_mesh_sdf_resolve_hold.dispatch({ encoder, group_count_x: resolve_groups, bindings: b });
 
-            shader_mesh_cards_log.dispatch({ encoder, bindings: b });
-        }
+        this.#store_settings.ring_capacity = this.#ring_capacity;
+        this.#store_settings.tally_offset = this.#frame_tally_offset;
+        b.settings = this.#store_settings;
+        b.mesh_sdf_atlas_store = this.#atlas.texture.obtainView();
 
-        // placed layouts into ranges of their own size
-        const moves = this.#frame_compactions;
+        shader_mesh_sdf_store.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#take,
+            command_offset: MESH_SDF_TAKE_DISPATCH * 4,
+        });
 
-        for (let i = 0; i < moves.length; i += 3) {
-            const settings = this.#compact_settings;
-            const groups = Math.ceil(moves[i + 2] / MESH_SDF_BAKE_WORKGROUP_SIZE);
-            const groups_x = Math.min(groups, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION);
+        // the frame's completions get their stored bricks
+        const count_settings = this.#count_settings;
 
-            settings.source = moves[i];
-            settings.destination = moves[i + 1];
-            settings.count = moves[i + 2];
-            settings.groups_x = groups_x;
-            b.settings = settings;
+        count_settings.log_offset = this.#frame_log_offset;
+        count_settings.log_capacity = this.#frame_log_capacity;
+        b.settings = count_settings;
 
-            shader_mesh_cards_compact.dispatch({
-                encoder,
-                group_count_x: groups_x,
-                group_count_y: Math.ceil(groups / groups_x),
-                bindings: b,
-            });
-        }
+        shader_mesh_sdf_count.dispatch({
+            encoder,
+            group_count_x: Math.ceil(this.#frame_log_capacity / MESH_SDF_BAKE_WORKGROUP_SIZE),
+            bindings: b,
+        });
     }
 
     /**
@@ -1627,6 +2053,8 @@ export class GPUGeometrySDFManager {
         }
 
         this.#bricks_evaluated += words[MESH_SDF_LOG_TAKEN];
+        this.#bricks_shared += words[MESH_SDF_LOG_SHARED];
+        this.#bricks_collided += words[MESH_SDF_LOG_COLLIDED];
 
         if (frame === this.#read_frame) {
             this.#free_slots = words[MESH_SDF_LOG_FREE_SLOTS];
@@ -1648,14 +2076,7 @@ export class GPUGeometrySDFManager {
 
         for (let i = 0; i < count; i++) {
             const word = MESH_SDF_LOG_HEADER_WORDS + i * MESH_SDF_LOG_RECORD_WORDS;
-            const marked = words[word];
-
-            if ((marked & MESH_SDF_LOG_PLACED) !== 0) {
-                this.#apply_placed((marked & ~MESH_SDF_LOG_PLACED) >>> 0, words[word + 1], words[word + 2], words[word + 3]);
-                continue;
-            }
-
-            const id = marked;
+            const id = words[word];
 
             if (this.#state[id] !== HOST_BAKING || this.#generation[id] !== words[word + 1]) {
                 // of a bake dropped since
@@ -1665,13 +2086,16 @@ export class GPUGeometrySDFManager {
             this.#state[id] = HOST_RESIDENT;
             this.#baking--;
             this.#resident_count++;
+            this.#stored_bricks[id] = words[word + MESH_SDF_LOG_STORED];
+
+            // a geometry with no meshlets on the host to look at counts as colored: its albedo keeps texels
+            const meshlets = this.#records[id].geometry?.meshlets;
+
+            this.#surfaces.set_layout(id, this.#stored_bricks[id], meshlets === undefined ? true : meshlet_batch_colored(meshlets));
 
             this.#word_scratch[0] = MeshSDFState.Resident;
             this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES + HEADER_STATE, this.#word_scratch, 0, 1);
 
-            this.#card_state[id] = CARDS_QUEUED;
-            this.#place_queue.push(id);
-
             this.onBaked.send1(id);
 
             const clones = this.#clones_of.get(id);
@@ -1684,70 +2108,6 @@ export class GPUGeometrySDFManager {
         }
     }
 
-    /**
-     * A geometry's cards are placed, with `columns` over every card and `pages` pages: a range of that
-     * size for the layout, which the next bake moves it into.
-     *
-     * @param {number} id
-     * @param {number} generation the bake's the placement read
-     * @param {number} columns
-     * @param {number} pages
-     */
-    #apply_placed(id, generation, columns, pages) {
-        if (this.#state[id] !== HOST_RESIDENT || this.#generation[id] !== generation || this.#card_state[id] !== CARDS_PLACING) {
-            // of a placement whose geometry was dropped since
-            return;
-        }
-
-        const words = mesh_card_layout_words(columns, pages);
-
-        this.#ensure_indirection(words);
-
-        const range = this.#indirection_allocator.allocate(words);
-
-        assert.notEqual(range.offset, ALLOCATOR_NO_SPACE, 'card layout allocation after growth');
-
-        this.#card_ranges[id] = range;
-        this.#card_pages[id] = pages;
-        this.#card_words[id] = words;
-        this.#card_state[id] = CARDS_COMPACTING;
-        this.#compact_queue.push(id);
-    }
-
-    /**
-     * @param {number} id
-     * @param {number} offset the layout's first word in the arena
-     */
-    #write_header_cards(id, offset) {
-        this.#word_scratch[0] = offset;
-        this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES + HEADER_CARDS, this.#word_scratch, 0, 1);
-    }
-
-    /**
-     * Give back a geometry's cards: its ranges once the passes reading them are submitted, its card
-     * sets back to waiting.
-     *
-     * @param {number} id
-     */
-    #drop_cards(id) {
-        if (this.#card_state[id] === CARDS_NONE) {
-            return;
-        }
-
-        this.#card_state[id] = CARDS_NONE;
-
-        for (const ranges of [this.#card_scratch, this.#card_ranges]) {
-            const range = ranges[id];
-
-            if (range !== null && range !== undefined) {
-                this.#release_next.push(range);
-                ranges[id] = null;
-            }
-        }
-
-        this.#cards.drop_layout(id);
-    }
-
     /**
      * Drop whatever the id holds: a place in the queue, a bake, a resident cache, an alias.
      *
@@ -1772,21 +2132,21 @@ export class GPUGeometrySDFManager {
             clones.splice(clones.indexOf(id), 1);
 
             this.#aliases.delete(id);
-            this.#cards.unalias(id);
+            this.#surfaces.unalias(id);
         } else {
             if (state === HOST_BAKING) {
                 this.#baking--;
-            } else {
+            } else if (state === HOST_RESIDENT) {
                 this.#resident_count--;
             }
 
             const range = this.#ranges[id];
 
-            this.#freed.push(range.offset + 1, this.#brick_count[id]);
+            this.#freed.push(range.offset + 2, this.#brick_count[id]);
             this.#freeing.push(range);
             this.#ranges[id] = null;
 
-            this.#drop_cards(id);
+            this.#surfaces.drop_layout(id);
         }
 
         // bricks of this id still on the ring are stale from here on, by the state
@@ -1825,7 +2185,6 @@ export class GPUGeometrySDFManager {
         view.setFloat32(HEADER_VOXEL, layout.voxel, true);
         view.setUint32(HEADER_LEVEL_COUNT, layout.level_count, true);
         view.setUint32(HEADER_INDIRECTION, indirection, true);
-        view.setUint32(HEADER_CARDS, GPU_DATABASE_NULL, true);
         view.setUint32(HEADER_STATE, state, true);
         view.setUint32(HEADER_SOURCE, GPU_DATABASE_NULL, true);
         view.setUint32(HEADER_GENERATION, this.#generation[id], true);
@@ -1843,7 +2202,6 @@ export class GPUGeometrySDFManager {
 
         new Uint8Array(view.buffer).fill(0);
 
-        view.setUint32(HEADER_CARDS, GPU_DATABASE_NULL, true);
         view.setUint32(HEADER_STATE, MeshSDFState.Alias, true);
         view.setUint32(HEADER_SOURCE, source, true);
         view.setUint32(HEADER_GENERATION, this.#generation[id], true);
@@ -1863,13 +2221,7 @@ export class GPUGeometrySDFManager {
         this.#state = grow_typed(this.#state, length);
         this.#generation = grow_typed(this.#generation, length);
         this.#brick_count = grow_typed(this.#brick_count, length);
-        this.#card_state = grow_typed(this.#card_state, length);
-        this.#placement_words = grow_typed(this.#placement_words, length);
-        this.#placement_scratch = grow_typed(this.#placement_scratch, length);
-        this.#placement_columns = grow_typed(this.#placement_columns, length);
-        this.#card_pages = grow_typed(this.#card_pages, length);
-        this.#card_words = grow_typed(this.#card_words, length);
-        this.#card_side = grow_typed(this.#card_side, length);
+        this.#stored_bricks = grow_typed(this.#stored_bricks, length);
     }
 
     #ensure_device() {
@@ -1910,6 +2262,9 @@ export class GPUGeometrySDFManager {
         this.#slots = this.#create_buffer("slots", 4 * this.#slot_capacity, GPUBufferUsage.COPY_SRC);
         this.#fill_pending = true;
 
+        this.#contents = this.#create_buffer("contents", 4 * MESH_SDF_CONTENT_WORDS * this.#slot_capacity, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+        this.#content_table = this.#create_content_table(this.#slot_capacity);
+
         this.#take = this.#create_buffer("take", 4 * MESH_SDF_TAKE_WORDS, GPUBufferUsage.INDIRECT);
 
         this.#word_scratch[0] = this.#slot_capacity;
@@ -1994,7 +2349,7 @@ export class GPUGeometrySDFManager {
             this.#indirection_allocator.free(this.#frame_range);
         }
 
-        const words = MESH_SDF_LOG_HEADER_WORDS + MESH_SDF_LOG_RECORD_WORDS * log_capacity + staging;
+        const words = MESH_SDF_LOG_HEADER_WORDS + MESH_SDF_LOG_RECORD_WORDS * log_capacity + MESH_SDF_TAKEN_WORDS * staging + mesh_sdf_claim_size(staging);
 
         this.#ensure_indirection(words);
 
@@ -2049,8 +2404,38 @@ export class GPUGeometrySDFManager {
         atlas.reserve(capacity);
 
         this.#slots = this.#regrow(this.#slots, "slots", 4 * capacity, GPUBufferUsage.COPY_SRC);
+        this.#contents = this.#regrow(this.#contents, "contents", 4 * MESH_SDF_CONTENT_WORDS * capacity, 0);
         this.#slot_capacity = capacity;
         this.#pushes.push(old_capacity, capacity - old_capacity);
+
+        // a table of the grown size, which the next bake gives the records of the one it replaces before
+        // anything reads it
+        if (this.#rehash_from === null) {
+            this.#rehash_from = this.#content_table;
+            this.#rehash_records = mesh_sdf_content_table_size(old_capacity);
+        } else {
+            // grown again before a bake: the table it replaces was never bound
+            this.#content_table.destroy();
+        }
+
+        this.#content_table = this.#create_content_table(capacity);
+    }
+
+    /**
+     * An empty content table for `slot_capacity` slots: its header written, every record empty.
+     *
+     * @param {number} slot_capacity
+     * @returns {GPUBuffer}
+     */
+    #create_content_table(slot_capacity) {
+        const size = mesh_sdf_content_table_size(slot_capacity);
+        const buffer = this.#create_buffer("content table", 4 * (2 + 2 * size), GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+
+        this.#word_scratch[0] = 0;
+        this.#word_scratch[1] = size;
+        this.#device.queue.writeBuffer(buffer, 0, this.#word_scratch, 0, 2);
+
+        return buffer;
     }
 
     /**
@@ -2123,16 +2508,32 @@ export class GPUGeometrySDFManager {
 
         this.#destroyed = true;
 
-        for (const buffer of [this.#headers, this.#indirection, this.#slots, this.#take, this.#ring, this.#classify_ranges, this.#free_ranges]) {
+        for (const buffer of [this.#headers, this.#indirection, this.#slots, this.#contents, this.#content_table, this.#rehash_from, this.#take, this.#ring, this.#classify_ranges, this.#free_ranges]) {
             buffer?.destroy();
         }
 
+        for (const upload of this.#uploads) {
+            upload.bytes.destroy();
+            upload.bricks.destroy();
+            upload.ranges.destroy();
+        }
+
+        for (const buffer of this.#garbage) {
+            buffer.destroy();
+        }
+
+        this.#uploads.length = 0;
+        this.#garbage.length = 0;
+
         this.#atlas?.destroy();
-        this.#cards.destroy();
+        this.#surfaces.destroy();
 
         this.#headers = null;
         this.#indirection = null;
         this.#slots = null;
+        this.#contents = null;
+        this.#content_table = null;
+        this.#rehash_from = null;
         this.#take = null;
         this.#ring = null;
         this.#classify_ranges = null;