@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -1,229 +1,1938 @@
 import { assert } from "../../../../core/assert.js";
-import { array_compute_max } from "../../../../core/collection/array/array_compute_max.js";
+import { ALLOCATOR_NO_SPACE, OffsetAllocator } from "../../../../core/binary/allocator/OffsetAllocator.js";
+import Signal from "../../../../core/events/signal/Signal.js";
+import { BufferDescriptor } from "../../../descriptor/buffer/BufferDescriptor.js";
+import { graph_read_buffer } from "../../buffer/graph_read_buffer.js";
+import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
+import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { shader_slot_stack_fill, SLOT_STACK_FILL_WORKGROUP_SIZE } from "../../gpu_primitive/slot_stack/shader_slot_stack_fill.js";
+import {
+    shader_slot_stack_push_range,
+    SLOT_STACK_PUSH_RANGE_WORKGROUP_SIZE
+} 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 { SFD_BUILD_WORKGROUP_SIZE } from "./SFD_BUILD_WORKGROUP_SIZE.js";
-import { shader_build_sdf } from "./shader_build_sdf.js";
+import {
+    MESH_SDF_BAKE_WORKGROUP_SIZE,
+    MESH_SDF_COUNTER_SLOTS,
+    MESH_SDF_COUNTER_WORDS,
+    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_STARVED,
+    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
+} from "./bake/MESH_SDF_BAKE.js";
+import { shader_mesh_sdf_classify } from "./bake/shader_mesh_sdf_classify.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_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, MeshSDFState } from "./MESH_SDF.js";
+import { MESH_SDF_SAMPLER } from "./MESH_SDF_RESOURCES.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+import { MeshSDFLayout } from "./MeshSDFLayout.js";
 
 /**
- * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
  * @typedef {import("../GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
- * @typedef {import("../bvh/GPUGeometryBVHManager.js").GPUGeometryBVHManager} GPUGeometryBVHManager
+ * @typedef {import("../GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
+ * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
  */
 
+/*
+ What the host knows of a geometry id. `Queued` is the host's alone: the header reads None until the
+ bake is admitted and the indirection range is the geometry's.
+ */
+const HOST_NONE = 0;
+const HOST_QUEUED = 1;
+const HOST_BAKING = 2;
+const HOST_RESIDENT = 3;
+const HOST_ALIAS = 4;
+
+/*
+ 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.
+ */
+const CARDS_NONE = 0;
+const CARDS_QUEUED = 1;
+const CARDS_PLACING = 2;
+const CARDS_COMPACTING = 3;
+const CARDS_PLACED = 4;
+
+const HEADER_BYTES = MESH_SDF_STRUCT.size;
+const HEADER_ORIGIN = MESH_SDF_STRUCT.get("origin").offset;
+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;
+const HEADER_TWO_SIDED = MESH_SDF_STRUCT.get("two_sided").offset;
+
+/**
+ * Tiles across x and y of the brick atlas: a layer is 128² texels and holds 256 bricks, and the
+ * atlas grows in whole layers.
+ * @type {number}
+ */
+const ATLAS_SLOTS_XY = 16;
+
+/**
+ * Slots the atlas starts with: one layer. It doubles each time a frame's take is held back by the
+ * free slots, so a scene reaches what it needs in a few doublings and never holds much past it.
+ * @type {number}
+ */
+const INITIAL_SLOT_CAPACITY = ATLAS_SLOTS_XY * ATLAS_SLOTS_XY;
+
+/**
+ * Readbacks of the bake's log in flight before a frame's bake is skipped. A mapping normally lands a
+ * frame or two after its copy; past this the device is behind, and a frame that cannot be read back
+ * must not complete a geometry the host would never hear of.
+ * @type {number}
+ */
+const MAX_LOGS_IN_FLIGHT = 3;
+
+/**
+ * Completion records the log has room for to start with; it doubles when more geometries are in
+ * flight at once.
+ * @type {number}
+ */
+const INITIAL_LOG_CAPACITY = 64;
+
 /**
- * X*X*X voxels allocated in the atlas to represent SDF for an object
+ * Words the arena starts with. It doubles as allocations need, appending.
  * @type {number}
  */
-const DEFAULT_MESH_RESOLUTION = 50;
+const INITIAL_ARENA_WORDS = 4096;
 
 /**
- * Tiles across x and y to start with: the atlas grows a layer of 16 slots at a time along z, 16 being
- * what the manager started with and its smallest growth step before it moved onto the atlas. Under
- * a `maxTextureDimension3D` of 2048, z is full at 40 layers (640 slots, 320 MB of `r32float`), and
- * the atlas then widens to 8×4 with 21 layers, moving every tile; a slot keeps its index.
+ * 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 ATLAS_SLOTS_X = 4;
+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.
  * @type {number}
  */
-const ATLAS_SLOTS_Y = 4;
+export const MESH_SDF_BAKE_BUDGET_MAX = Math.floor(WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION / MESH_SDF_GROUPS_PER_BRICK);
+
+/**
+ * The most bricks one geometry can have under `max_bricks`: every level of a cube of that many.
+ *
+ * @param {number} max_bricks
+ * @returns {number}
+ */
+function max_bricks_of_a_geometry(max_bricks) {
+    let total = 0;
+
+    for (let level = 0; ; level++) {
+        const per_axis = Math.ceil(max_bricks / 2 ** level);
+
+        total += per_axis ** 3;
+
+        if (per_axis <= 1) {
+            return total;
+        }
+    }
+}
+
+/**
+ * Grow a typed array by doubling until it holds `length`, keeping its contents.
+ *
+ * @template {Uint8Array|Uint32Array} T
+ * @param {T} array
+ * @param {number} length
+ * @returns {T}
+ */
+function grow_typed(array, length) {
+    if (array.length >= length) {
+        return array;
+    }
+
+    let size = Math.max(1, array.length);
+
+    while (size < length) {
+        size *= 2;
+    }
+
+    const grown = new array.constructor(size);
+
+    grown.set(array);
+
+    return grown;
+}
 
 /**
- * Per-geometry signed distance fields, one {@link DEFAULT_MESH_RESOLUTION}³ `r32float` tile each, in
- * a {@link GPUTileAtlas3D}.
+ * Per-geometry sparse signed distance fields (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6): bricks of 8³
+ * `r8unorm` texels on 7³ voxels, in size classes with levels ({@link MeshSDFLayout}), baked on the
+ * device from the geometry's BLAS and kept by geometry id for as long as something holds the
+ * geometry.
+ *
+ * **Lifetime.** {@link acquire} and {@link release} count holders per geometry id. The first holder
+ * 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 skinned clone's id at its source's cache, which readers follow.
  *
- * **A slot is its geometry's id.** The build shader reads `blas_lookup[slot]` and every reader
- * addresses a geometry's tile by that id, so slots are claimed in order and never freed: the
- * atlas's n-th allocation is slot n.
+ * **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 (UE 5.4's
+ * rule, which takes the side from the material). A field whose holders' side has changed since its
+ * bake is baked again at the next bake, so holds moved within a frame bake nothing; a field no one
+ * holds keeps the side it has.
  *
- * **No border.** Every reader loads texels with `textureLoad` and clamps the far neighbour of its
- * trilinear tap to the tile's last texel (`sdf_texture_region_sample_linear_uv`), and the texture
- * is bound `unfilterable-float`, so no read leaves its tile. A skirt would be dead texels, and the
- * atlas's skirt is a wrap besides — the far side of a mesh is not the continuation of its near side.
+ * **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.
+ *
+ * **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.
+ *
+ * **Readers** bind {@link headers}, {@link indirection}, {@link texture} and {@link MESH_SDF_SAMPLER}
+ * (see {@link write_bindings}) and sample through `mesh_sdf_sample`, which only a resident header
+ * should be given to.
+ *
+ * Device storage is made on first use: a renderer that never asks for a cache allocates nothing.
  */
 export class GPUGeometrySDFManager {
 
     /**
-     * @type {GPUTileAtlas3D}
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * @type {GPUGeometryManager}
+     */
+    #geometries;
+
+    /**
+     * Sent with a geometry id when its cache turns resident, on the frame its completion is read back.
+     * @type {Signal<number>}
+     */
+    onBaked = new Signal();
+
+    #voxel_size = 0.125;
+    #max_bricks = 18;
+
+    // ---- per geometry id ----
+
+    #references = new Uint32Array(64);
+    /** Holders drawing both sides. */
+    #two_sided_references = new Uint32Array(64);
+    /** 1 when the bake under way, or the cache, is two-sided: what its header says. */
+    #two_sided = new Uint8Array(64);
+    #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);
+
+    /**
+     * The range each geometry's cards are being placed in.
+     * @type {(import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null)[]}
      */
-    #atlas;
+    #card_scratch = [];
 
     /**
-     * The atlas's grid in tiles, as the shaders take it; refreshed on read.
+     * 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[]}
      */
-    #atlas_resolution_in_tiles = [0, 0, 0];
+    #place_queue = [];
+
+    /**
+     * Geometries whose placed layout waits to be moved into its own range.
+     * @type {number[]}
+     */
+    #compact_queue = [];
+
+    /**
+     * The (geometry, material) pairs' captures of the layouts.
+     * @type {GPUMeshCardSets}
+     */
+    #cards;
+
+    /**
+     * @type {(import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null)[]}
+     */
+    #ranges = [];
+
+    /**
+     * @type {(GPUGeometryMetadata|undefined)[]}
+     */
+    #records = [];
+
+    /**
+     * Ids waiting for their bake, in request order. An id dropped while queued stays until the next
+     * admission walks past it.
+     * @type {number[]}
+     */
+    #queue = [];
+
+    /**
+     * Ids whose last holder went since the last {@link trim}.
+     * @type {number[]}
+     */
+    #unreferenced = [];
+
+    /**
+     * Ids whose holders changed since the last bake, which may draw a side other than their field's.
+     * @type {number[]}
+     */
+    #holders_changed = [];
+
+    /**
+     * Indirection ranges given back since the last bake, as offset then count, for the free pass.
+     * @type {number[]}
+     */
+    #freed = [];
+
+    /**
+     * The allocations of {@link #freed}, held from the allocator until their free pass is recorded.
+     * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation[]}
+     */
+    #freeing = [];
+
+    /**
+     * Allocations whose last reader was recorded in the last bake, given back to the allocator at the
+     * start of the next. A range handed out in the frame that reads it would take the new owner's host
+     * writes, which land before the frame's commands run.
+     * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation[]}
+     */
+    #release_next = [];
+
+    /**
+     * Geometries admitted and not yet complete.
+     * @type {number}
+     */
+    #baking = 0;
+
+    #layout = new MeshSDFLayout();
+
+    #header_scratch = new DataView(new ArrayBuffer(HEADER_BYTES));
+    #word_scratch = new Uint32Array(4);
+
+    // ---- device storage, made by #ensure_device ----
+
+    /** @type {GPUBuffer|null} */
+    #headers = null;
+    #header_capacity = 0;
+
+    /** @type {GPUBuffer|null} */
+    #indirection = null;
+    /** @type {OffsetAllocator|null} */
+    #indirection_allocator = null;
+    #indirection_capacity = 0;
+
+    /** @type {GPUTileAtlas3D|null} */
+    #atlas = null;
+    /** @type {GPUBuffer|null} */
+    #slots = null;
+    #slot_capacity = 0;
+    #fill_pending = false;
+
+    /**
+     * Ranges of slots the next bake pushes, as first then count: what the atlas gained.
+     * @type {number[]}
+     */
+    #pushes = [];
+
+    /** @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.
+     * @type {import("../../../../core/binary/allocator/OffsetAllocator.js").Allocation|null}
+     */
+    #frame_range = null;
+    #log_capacity = 0;
+
+    /**
+     * The ring's entries, then the staging of {@link #staging_bricks} bricks.
+     * @type {GPUBuffer|null}
+     */
+    #ring = null;
+    #ring_capacity = 0;
+    #staging_bricks = 0;
+
+    /** @type {GPUBuffer|null} */
+    #classify_ranges = null;
+    #classify_ranges_capacity = 0;
+    #classify_scratch = new Uint32Array(64);
+
+    /** @type {GPUBuffer|null} */
+    #free_ranges = null;
+    #free_ranges_capacity = 0;
+    #free_scratch = new Uint32Array(64);
+
+    // ---- the frame's bake, as graph_bake records it for #execute_bake ----
+
+    #frame_classify_runs = 0;
+    #frame_classify_bricks = 0;
+    #frame_free_runs = 0;
+    #frame_free_entries = 0;
+    #frame_budget = 0;
+    #frame_log_capacity = 1;
+    #frame_log_offset = 0;
+    #frame_log_bytes = 0;
+    #frame_tally_offset = 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 };
+    #push_settings = { first: 0, count: 0, counter: MESH_SDF_COUNTER_SLOTS };
+    #bindings = {};
+
+    // ---- what the log has told ----
+
+    #frame = 0;
+    #logs_in_flight = 0;
+    #skipped_frames = 0;
+
+    /** Bricks admitted since the device storage was made: an upper bound on what the ring has had. */
+    #admitted_total = 0;
+    #read_frame = -1;
+    #read_queued = 0;
+    #read_admitted = 0;
+    /** Bumped when the ring is emptied by hand, which voids every log recorded before it. */
+    #ring_epoch = 0;
+    #grown_frame = -1;
+
+    #coarsened_count = 0;
+    #resident_count = 0;
+    #starved_frames = 0;
+    #bricks_evaluated = 0;
+    #free_slots = 0;
+
+    #destroyed = false;
 
     /**
-     *
      * @param {GPUDevice} device
+     * @param {GPUGeometryManager} geometries whose ids the caches are kept by, and whose trees the bake reads
      */
-    constructor(device) {
+    constructor(device, geometries) {
         assert.defined(device, 'device');
+        assert.defined(geometries, 'geometries');
 
-        this.#atlas = new GPUTileAtlas3D({
-            device,
-            formats: ["r32float"],
-            // a cube: the build and every reader take one resolution for all three axes
-            content_size: [DEFAULT_MESH_RESOLUTION, DEFAULT_MESH_RESOLUTION, DEFAULT_MESH_RESOLUTION],
-            border: 0,
-            slots_x: ATLAS_SLOTS_X,
-            slots_y: ATLAS_SLOTS_Y,
-            capacity: ATLAS_SLOTS_X * ATLAS_SLOTS_Y,
-            // loaded by the readers, stored into by shader_build_sdf
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
-            label: "GPUGeometrySDFManager/atlas",
-        });
+        this.#device = device;
+        this.#geometries = geometries;
+        this.#cards = new GPUMeshCardSets(device);
     }
 
     /**
-     * Allocate slots through {@link ensureCapacity} and {@link build_slots}, never on the atlas
-     * directly: a slot handed out of order would no longer be its geometry's id.
-     * @return {GPUTileAtlas3D}
+     * 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}
      */
-    get atlas() {
-        return this.#atlas;
+    get cards() {
+        return this.#cards;
     }
 
     /**
-     * Individual SDF textures are written here. Replaced when the atlas grows, so take a view after
-     * {@link build_slots}, never across it.
-     * @return {import("../../texture/GPUTextureContext.js").GPUTextureContext}
+     * Level 0's voxel, in the geometry's local units, and the bricks per axis past which it grows. A
+     * change rebakes every cache.
+     *
+     * @param {number} voxel_size
+     * @param {number} max_bricks even, at least 2
      */
-    get texture() {
-        return this.#atlas.texture;
+    configure(voxel_size, max_bricks) {
+        assert.isFinite(voxel_size, 'voxel_size');
+        assert.greaterThan(voxel_size, 0, 'voxel_size');
+        assert.isPositiveInteger(max_bricks, 'max_bricks');
+        assert.equal(max_bricks % 2, 0, 'max_bricks must be even');
+
+        if (voxel_size === this.#voxel_size && max_bricks === this.#max_bricks) {
+            return;
+        }
+
+        this.#voxel_size = voxel_size;
+        this.#max_bricks = max_bricks;
+
+        const state = this.#state;
+
+        for (let id = 0; id < state.length; id++) {
+            const s = state[id];
+
+            if (s === HOST_BAKING || s === HOST_RESIDENT) {
+                this.#drop(id);
+            }
+
+            if (this.#references[id] > 0 && state[id] === HOST_NONE) {
+                state[id] = HOST_QUEUED;
+                this.#queue.push(id);
+            }
+        }
+
+        if (this.#ring !== null) {
+            // every bake was cancelled, so the ring holds stale bricks alone, and a ring sized for
+            // the new cap may be needed
+            this.#reset_ring();
+        }
     }
 
     /**
-     * Resolution in SDF texels for a single geometry along each axis — the tile is a cube — which is
-     * also the stride between tiles: the atlas holds them with no border.
-     * @return {number}
+     * @returns {number}
      */
-    get tile_resolution() {
-        return DEFAULT_MESH_RESOLUTION;
+    get voxel_size() {
+        return this.#voxel_size;
     }
 
     /**
-     * Tiles along x, y and z — x and y are what `tile_atlas_slot_origin` takes to place a slot. Read it
-     * after {@link build_slots}: when the atlas widens, x or y changes and every tile moves.
-     * @return {number[]}
+     * @returns {number}
      */
-    get atlas_resolution_in_tiles() {
-        const atlas = this.#atlas;
-        const out = this.#atlas_resolution_in_tiles;
-
-        out[0] = atlas.slots_x;
-        out[1] = atlas.slots_y;
-        out[2] = atlas.slots_z;
-
-        return out;
+    get max_bricks() {
+        return this.#max_bricks;
     }
 
     /**
-     * Slots the texture holds now.
-     * @return {number}
+     * One more holder of a geometry's cache; the first queues its bake.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @param {boolean} two_sided whether the holder draws both sides of the geometry
      */
-    get capacity() {
-        return this.#atlas.capacity;
+    acquire(record, two_sided) {
+        assert.defined(record, 'record');
+        assert.isBoolean(two_sided, 'two_sided');
+
+        const id = record.index;
+
+        this.#ensure_id(id);
+
+        this.#records[id] = record;
+
+        if (two_sided) {
+            this.#two_sided_references[id]++;
+        }
+
+        if (++this.#references[id] === 1 && this.#state[id] === HOST_NONE) {
+            this.#state[id] = HOST_QUEUED;
+            this.#queue.push(id);
+        }
+
+        this.#holders_changed.push(id);
     }
 
     /**
-     * Claim every slot below `min_capacity`, growing the atlas as it fills.
+     * One holder fewer. The cache stays until {@link trim}.
      *
-     * @param {number} min_capacity
+     * @param {GPUGeometryMetadata} record
+     * @param {boolean} two_sided as the holder acquired it
      */
-    ensureCapacity(min_capacity) {
-        assert.isNonNegativeInteger(min_capacity, 'min_capacity');
+    release(record, two_sided) {
+        assert.defined(record, 'record');
+        assert.isBoolean(two_sided, 'two_sided');
 
-        const atlas = this.#atlas;
+        const id = record.index;
+
+        assert.greaterThan(this.#references[id] ?? 0, 0, `geometry ${id} released more often than acquired`);
 
-        while (atlas.live_count < min_capacity) {
-            const slot = atlas.allocate();
+        if (two_sided) {
+            assert.greaterThan(this.#two_sided_references[id], 0, `geometry ${id} released two-sided more often than acquired so`);
+
+            this.#two_sided_references[id]--;
+        }
 
-            assert.equal(slot, atlas.live_count - 1, `slot ${slot} came out of order; a geometry SDF slot is its geometry's id, so the atlas must hand them out in sequence`);
+        if (--this.#references[id] === 0) {
+            this.#unreferenced.push(id);
         }
+
+        this.#holders_changed.push(id);
     }
 
-    destroy() {
-        this.#atlas.destroy();
+    /**
+     * Drop the cache of every geometry whose last holder went since the last trim, and is still gone.
+     */
+    trim() {
+        const unreferenced = this.#unreferenced;
+
+        for (let i = 0; i < unreferenced.length; i++) {
+            const id = unreferenced[i];
+
+            if (this.#references[id] === 0 && this.#state[id] !== HOST_ALIAS) {
+                this.#drop(id);
+            }
+        }
+
+        unreferenced.length = 0;
     }
 
+    /**
+     * The geometry manager has let a geometry go: its cache, or its alias, goes now, whatever holds
+     * it.
+     *
+     * @param {GPUGeometryMetadata} record
+     */
+    forget(record) {
+        assert.defined(record, 'record');
+
+        const id = record.index;
+
+        if (id >= this.#state.length) {
+            return;
+        }
+
+        this.#references[id] = 0;
+        this.#two_sided_references[id] = 0;
+        this.#drop(id);
+        this.#records[id] = undefined;
+    }
 
     /**
+     * Readers of `clone` read `source`'s cache: the hook for a skinned clone, whose unskinned shape is
+     * its source's (§6.3). Written once; it follows the source through its bake.
      *
-     * @param {ShadeGPUCommandContext} command_ctx
-     * @param {number[]} slot_indices
-     * @param {GPUGeometryManager} geometries
+     * @param {GPUGeometryMetadata} clone
+     * @param {GPUGeometryMetadata} source
      */
-    build_slots(
-        command_ctx,
-        slot_indices,
-        geometries
-    ) {
-        if (slot_indices.length <= 0) {
-            // nothing to do
+    alias(clone, source) {
+        assert.defined(clone, 'clone');
+        assert.defined(source, 'source');
+        assert.notEqual(clone.index, source.index, 'a geometry cannot alias itself');
+
+        const id = clone.index;
+
+        this.#ensure_id(Math.max(id, source.index));
+
+        if (this.#state[id] === HOST_ALIAS) {
             return;
         }
 
-        // claim every slot before the first dispatch: a grow replaces the texture, and submits its
-        // copy ahead of the command stream the dispatches are recorded into
-        const max_slot = array_compute_max(slot_indices);
-        this.ensureCapacity(max_slot + 1);
-
-        // TODO spread work over multiple frames
-
-        const slot_resolution = this.tile_resolution;
-        const atlas_resolution_in_slots = this.atlas_resolution_in_tiles;
-
-        for (let i = 0; i < slot_indices.length; i++) {
-            const slot_index = slot_indices[i];
-
-            const buffer_settings = {
-                slot_index,
-                slot_resolution,
-                atlas_resolution_in_slots,
-            };
-
-
-            const wgx = Math.ceil(slot_resolution / SFD_BUILD_WORKGROUP_SIZE[0]);
-            const wgy = Math.ceil(slot_resolution / SFD_BUILD_WORKGROUP_SIZE[1]);
-            const wgz = Math.ceil(slot_resolution / SFD_BUILD_WORKGROUP_SIZE[2]);
-
-            /**
-             *
-             * @type {GPUGeometryBVHManager}
-             */
-            const blas = geometries.blas;
-
-            shader_build_sdf.dispatch({
-                encoder: command_ctx,
-                bindings: {
-                    settings: buffer_settings,
-                    blas_lookup: blas.buffer_metadata,
-                    blas_data: blas.buffer_data,
-                    geometries: geometries.buffer_metadata,
-                    // the triangles the query reads, through their meshlets
-                    meshlet_metadata: geometries.meshlets.buffer_metadata,
-                    meshlet_data: geometries.meshlets.buffer_data,
-                    output_texture: this.#atlas.texture.obtainView(),
-                },
-                group_count_x: wgx,
-                group_count_y: wgy,
-                group_count_z: wgz,
-            });
+        this.#drop(id);
+
+        this.#state[id] = HOST_ALIAS;
+
+        if (this.#headers !== null) {
+            this.#ensure_headers(id + 1);
+            this.#write_header_alias(id, source.index);
         }
 
+        this.#records[id] = clone;
+        this.#aliases.set(id, source.index);
     }
 
     /**
-     * Downloads raw data for a given slot. Mainly for debugging.
-     * @param {number} slot
-     * @return {Promise<Float32Array>}
+     * Aliases by clone id, for the headers written when device storage is made.
+     * @type {Map<number, number>}
      */
-    async download_slot(slot) {
-        const atlas = this.#atlas;
-        return /** @type {Promise<Float32Array>} */ (atlas.texture.download_region(atlas.slot_origin(slot, [0, 0, 0]), atlas.tile_size));
+    #aliases = new Map();
+
+    /**
+     * What a reader finds in the geometry's header.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @returns {MeshSDFState}
+     */
+    state_of(record) {
+        switch (this.#state[record.index] ?? HOST_NONE) {
+            case HOST_BAKING:
+                return MeshSDFState.Baking;
+            case HOST_RESIDENT:
+                return MeshSDFState.Resident;
+            case HOST_ALIAS:
+                return MeshSDFState.Alias;
+            default:
+                return MeshSDFState.None;
+        }
+    }
+
+    /**
+     * Geometries whose layout was coarsened by the cap, of those baked: coarser than asked.
+     * @returns {number}
+     */
+    get coarsened_count() {
+        return this.#coarsened_count;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get resident_count() {
+        return this.#resident_count;
+    }
+
+    /**
+     * Geometries admitted and not yet complete.
+     * @returns {number}
+     */
+    get baking_count() {
+        return this.#baking;
+    }
+
+    /**
+     * Geometries requested and not yet admitted.
+     * @returns {number}
+     */
+    get queued_count() {
+        let count = 0;
+
+        for (const id of this.#queue) {
+            if (this.#state[id] === HOST_QUEUED) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * Frames whose take the free slots held back, as read back.
+     * @returns {number}
+     */
+    get starved_frames() {
+        return this.#starved_frames;
+    }
+
+    /**
+     * Bricks evaluate has been handed, as read back: classify's survivors, stale ones included.
+     * @returns {number}
+     */
+    get bricks_evaluated() {
+        return this.#bricks_evaluated;
+    }
+
+    /**
+     * Free slots of the atlas before the last take read back.
+     * @returns {number}
+     */
+    get free_slots() {
+        return this.#free_slots;
+    }
+
+    /**
+     * Frames whose bake was skipped because its log could not be read back.
+     * @returns {number}
+     */
+    get skipped_frames() {
+        return this.#skipped_frames;
+    }
+
+    /**
+     * Slots the brick atlas holds.
+     * @returns {number}
+     */
+    get slot_capacity() {
+        return this.#slot_capacity;
+    }
+
+    /**
+     * Every geometry's header, by geometry id. Replaced when it grows; take it each frame.
+     * @returns {GPUBuffer}
+     */
+    get headers() {
+        this.#ensure_device();
+
+        return this.#headers;
+    }
+
+    /**
+     * Every brick's entry: a slot or EMPTY. Replaced when it grows; take it each frame.
+     * @returns {GPUBuffer}
+     */
+    get indirection() {
+        this.#ensure_device();
+
+        return this.#indirection;
+    }
+
+    /**
+     * The brick atlas, `r8unorm`. Replaced when it grows; take a view each frame.
+     * @returns {import("../../texture/GPUTextureContext.js").GPUTextureContext}
+     */
+    get texture() {
+        this.#ensure_device();
+
+        return this.#atlas.texture;
+    }
+
+    /**
+     * Put what `mesh_sdf_sample` and `mesh_sdf_header` read into a reader's bindings, under the names
+     * they take.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_bindings(bindings) {
+        bindings.mesh_sdf_headers = this.headers;
+        bindings.mesh_sdf_indirection = this.indirection;
+        bindings.mesh_sdf_atlas = this.texture.obtainView();
+        bindings.mesh_sdf_sampler = MESH_SDF_SAMPLER;
+
+        return bindings;
+    }
+
+    /**
+     * @returns {number} bytes
+     */
+    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]) {
+            if (buffer !== null) {
+                bytes += buffer.size;
+            }
+        }
+
+        if (this.#atlas !== null) {
+            bytes += this.#atlas.capacity * MESH_SDF_BRICK_TEXELS ** 3;
+        }
+
+        return bytes + this.#cards.gpu_memory_usage;
+    }
+
+    /**
+     * 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.
+     *
+     * @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 the capture shades with, as it
+     *        stands this frame; needed with a `capture_budget`
+     */
+    graph_bake({ graph, budget, capture_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');
+
+        this.#frame++;
+
+        this.#follow_sides();
+
+        // the last bake's commands were submitted before this call: what they read may be handed out
+        const release_next = this.#release_next;
+
+        for (let i = 0; i < release_next.length; i++) {
+            this.#indirection_allocator.free(release_next[i]);
+        }
+
+        release_next.length = 0;
+
+        const queued_bound = this.#read_queued + (this.#admitted_total - this.#read_admitted);
+
+        const has_work = this.#queue.length > 0
+            || queued_bound > 0
+            || this.#freed.length > 0
+            || this.#pushes.length > 0
+            || this.#fill_pending
+            || this.#place_queue.length > 0
+            || this.#compact_queue.length > 0;
+
+        let arena = -1;
+
+        if (has_work) {
+            if (this.#logs_in_flight >= MAX_LOGS_IN_FLIGHT) {
+                this.#skipped_frames++;
+            } else {
+                arena = this.#record_bake(graph, budget, queued_bound);
+            }
+        }
+
+        if (capture_budget > 0 && this.#cards.has_pending_capture) {
+            assert.notNull(materials, 'materials');
+
+            this.#ensure_device();
+
+            if (arena === -1) {
+                arena = graph_import_buffer(graph, this.#indirection, "mesh_sdf_indirection");
+            }
+
+            const geometries = this.#geometries;
+            const blas = this.#blas_bindings;
+
+            blas.blas_lookup = geometries.blas.buffer_metadata;
+            blas.blas_data = geometries.blas.buffer_data;
+            blas.geometries = geometries.buffer_metadata;
+            blas.meshlet_metadata = geometries.meshlets.buffer_metadata;
+            blas.meshlet_data = geometries.meshlets.buffer_data;
+
+            this.#cards.graph_capture({ graph, budget: capture_budget, arena, headers: this.#headers, materials, blas });
+        }
+    }
+
+    /**
+     * @param {FrameGraph} graph
+     * @param {number} budget
+     * @param {number} queued_bound
+     * @returns {number} graph handle of the arena as the bake leaves it
+     */
+    #record_bake(graph, budget, queued_bound) {
+        this.#ensure_device();
+        this.#ensure_headers(this.#geometries.__last_geometry_index);
+
+        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);
+
+        const log_words = MESH_SDF_LOG_HEADER_WORDS + MESH_SDF_LOG_RECORD_WORDS * this.#log_capacity;
+
+        this.#frame_budget = budget;
+        this.#frame_log_capacity = this.#log_capacity;
+        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);
+
+        const data = this.#log_data;
+
+        const pass = graph.add("Mesh SDF Bake", data, this.#execute);
+
+        // the arena as it stands after every growth of the frame: the log is read back out of it
+        data.arena = pass.write(graph_import_buffer(graph, this.#indirection, "mesh_sdf_indirection"));
+
+        pass.make_side_effect();
+
+        const frame = this.#frame;
+        const admitted = this.#admitted_total;
+        const epoch = this.#ring_epoch;
+        const capacity = this.#frame_log_capacity;
+
+        this.#logs_in_flight++;
+
+        graph_read_buffer({ graph, buffer: data.arena, offset: 4 * this.#frame_log_offset, size: this.#frame_log_bytes })
+            .then(reference => {
+                try {
+                    if (!this.#destroyed) {
+                        this.#apply_log(new Uint32Array(reference.getValue()), frame, admitted, epoch, capacity);
+                    }
+                } finally {
+                    reference.release();
+                }
+            })
+            .catch(error => {
+                if (!this.#destroyed) {
+                    // a lost log costs its completions until the geometry is baked again; say so
+                    console.warn('GPUGeometrySDFManager: bake log readback failed', error);
+                }
+            })
+            .finally(() => {
+                this.#logs_in_flight--;
+            });
+
+        return data.arena;
+    }
+
+    /**
+     * Drop and queue again each field whose holders draw another side than it was baked for: two-sided
+     * while any of them draws both sides. A field no one holds keeps its side.
+     */
+    #follow_sides() {
+        const changed = this.#holders_changed;
+
+        for (let i = 0; i < changed.length; i++) {
+            const id = changed[i];
+            const state = this.#state[id];
+
+            if (this.#references[id] === 0 || (state !== HOST_BAKING && state !== HOST_RESIDENT)) {
+                // a queued field takes its holders' side when admitted
+                continue;
+            }
+
+            if ((this.#two_sided_references[id] > 0) === (this.#two_sided[id] === 1)) {
+                continue;
+            }
+
+            this.#drop(id);
+
+            this.#state[id] = HOST_QUEUED;
+            this.#queue.push(id);
+        }
+
+        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]);
+        }
+
+        queue.length = 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.
+     *
+     * @param {number} queued_bound bricks the ring may hold now, at most
+     */
+    #admit(queued_bound) {
+        const queue = this.#queue;
+        const state = this.#state;
+        const blas = this.#geometries.blas;
+        const layout = this.#layout;
+
+        let bound = queued_bound;
+        let runs = 0;
+        let bricks = 0;
+        let kept = 0;
+        let full = false;
+
+        for (let i = 0; i < queue.length; i++) {
+            const id = queue[i];
+
+            if (state[id] !== HOST_QUEUED) {
+                // dropped while queued
+                continue;
+            }
+
+            const record = this.#records[id];
+
+            if (full || blas.get_address(record) === undefined) {
+                // the ring is full this frame, or the tree is not traceable yet
+                queue[kept++] = id;
+                continue;
+            }
+
+            layout.compute(record.geometry.bounding_box, this.#voxel_size, this.#max_bricks);
+
+            const count = layout.brick_count;
+
+            if (bound + count > this.#ring_capacity) {
+                // in request order: the rest wait with it
+                full = true;
+                queue[kept++] = id;
+                continue;
+            }
+
+            // the geometry's pending word, then its entries
+            this.#ensure_indirection(count + 1);
+
+            const range = this.#indirection_allocator.allocate(count + 1);
+
+            assert.notEqual(range.offset, ALLOCATOR_NO_SPACE, 'indirection allocation after growth');
+
+            this.#ranges[id] = range;
+            this.#brick_count[id] = count;
+            this.#generation[id]++;
+            this.#two_sided[id] = this.#two_sided_references[id] > 0 ? 1 : 0;
+            state[id] = HOST_BAKING;
+            this.#baking++;
+
+            if (layout.coarsened) {
+                this.#coarsened_count++;
+            }
+
+            this.#write_header_baking(id, layout, range.offset + 1);
+
+            // level 0's grid, which the cards are placed over
+            const grid = layout.bricks;
+            const placement = mesh_card_placement_of(grid);
+
+            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.#word_scratch[0] = count;
+            this.#device.queue.writeBuffer(this.#indirection, range.offset * 4, this.#word_scratch, 0, 1);
+
+            this.#classify_scratch = grow_typed(this.#classify_scratch, 2 * (runs + 1));
+            this.#classify_scratch[2 * runs] = bricks;
+            this.#classify_scratch[2 * runs + 1] = id;
+
+            runs++;
+            bricks += count;
+            bound += count;
+            this.#admitted_total += count;
+        }
+
+        queue.length = kept;
+
+        this.#frame_classify_runs = runs;
+        this.#frame_classify_bricks = bricks;
+
+        if (runs > 0) {
+            this.#classify_ranges = this.#ensure_runs_buffer(this.#classify_ranges, runs, "classify");
+            this.#device.queue.writeBuffer(this.#classify_ranges, 0, this.#classify_scratch, 0, 2 * runs);
+        }
+    }
+
+    #upload_free_ranges() {
+        const freed = this.#freed;
+        const runs = freed.length / 2;
+
+        let entries = 0;
+
+        if (runs > 0) {
+            this.#free_scratch = grow_typed(this.#free_scratch, 2 * runs);
+
+            for (let i = 0; i < runs; i++) {
+                this.#free_scratch[2 * i] = entries;
+                this.#free_scratch[2 * i + 1] = freed[2 * i];
+
+                entries += freed[2 * i + 1];
+            }
+
+            this.#free_ranges = this.#ensure_runs_buffer(this.#free_ranges, runs, "free");
+            this.#device.queue.writeBuffer(this.#free_ranges, 0, this.#free_scratch, 0, 2 * runs);
+
+            freed.length = 0;
+
+            // read by this frame's free pass
+            const freeing = this.#freeing;
+
+            for (let i = 0; i < freeing.length; i++) {
+                this.#release_next.push(freeing[i]);
+            }
+
+            freeing.length = 0;
+        }
+
+        this.#frame_free_runs = runs;
+        this.#frame_free_entries = entries;
+    }
+
+    /**
+     * {@link #execute_bake}, bound once.
+     * @type {function(Object, Object, Object): void}
+     */
+    #execute = (data, resources, context) => this.#execute_bake(data, resources, context);
+
+    /**
+     * @param {Object} data
+     * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
+     * @param {import("../../../device/graph/GraphicsExecutionContext.js").GraphicsExecutionContext} context
+     */
+    #execute_bake(data, resources, context) {
+        const encoder = context.encoder;
+        const arena = resources.get(data.arena);
+        const b = this.#bindings;
+
+        // the log and the tallies
+        encoder.clearBuffer(arena, 4 * this.#frame_log_offset, this.#frame_bytes);
+
+        if (this.#fill_pending) {
+            this.#fill_pending = false;
+
+            shader_slot_stack_fill.dispatch({
+                encoder,
+                group_count_x: Math.min(Math.ceil(this.#slot_capacity / SLOT_STACK_FILL_WORKGROUP_SIZE), WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
+                bindings: { capacity: this.#slot_capacity, slots: this.#slots },
+            });
+        }
+
+        const pushes = this.#pushes;
+
+        for (let i = 0; i < pushes.length; i += 2) {
+            const settings = this.#push_settings;
+
+            settings.first = pushes[i];
+            settings.count = pushes[i + 1];
+
+            shader_slot_stack_push_range.dispatch({
+                encoder,
+                group_count_x: Math.min(Math.ceil(settings.count / SLOT_STACK_PUSH_RANGE_WORKGROUP_SIZE), WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
+                bindings: { settings, counts: arena, slots: this.#slots },
+            });
+        }
+
+        pushes.length = 0;
+
+        const geometries = this.#geometries;
+
+        b.blas_lookup = geometries.blas.buffer_metadata;
+        b.blas_data = geometries.blas.buffer_data;
+        b.geometries = geometries.buffer_metadata;
+        b.meshlet_metadata = geometries.meshlets.buffer_metadata;
+        b.meshlet_data = geometries.meshlets.buffer_data;
+        b.mesh_sdf_headers = this.#headers;
+        b.mesh_sdf_indirection = arena;
+        b.mesh_sdf_slots = this.#slots;
+        b.mesh_sdf_ring = this.#ring;
+        b.mesh_sdf_take = this.#take;
+
+        if (this.#frame_free_entries > 0) {
+            const groups = Math.ceil(this.#frame_free_entries / MESH_SDF_BAKE_WORKGROUP_SIZE);
+            const groups_x = Math.min(groups, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION);
+            const settings = this.#free_settings;
+
+            settings.range_count = this.#frame_free_runs;
+            settings.entry_count = this.#frame_free_entries;
+            settings.groups_x = groups_x;
+
+            b.settings = settings;
+            b.mesh_sdf_ranges = this.#free_ranges;
+
+            shader_mesh_sdf_free.dispatch({
+                encoder,
+                group_count_x: groups_x,
+                group_count_y: Math.ceil(groups / groups_x),
+                bindings: b,
+            });
+        }
+
+        if (this.#frame_classify_bricks > 0) {
+            const groups = Math.ceil(this.#frame_classify_bricks / MESH_SDF_BAKE_WORKGROUP_SIZE);
+            const groups_x = Math.min(groups, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION);
+            const settings = this.#classify_settings;
+
+            settings.range_count = this.#frame_classify_runs;
+            settings.brick_count = this.#frame_classify_bricks;
+            settings.groups_x = groups_x;
+            settings.ring_capacity = this.#ring_capacity;
+            settings.log_offset = this.#frame_log_offset;
+            settings.log_capacity = this.#frame_log_capacity;
+
+            b.settings = settings;
+            b.mesh_sdf_ranges = this.#classify_ranges;
+
+            shader_mesh_sdf_classify.dispatch({
+                encoder,
+                group_count_x: groups_x,
+                group_count_y: Math.ceil(groups / groups_x),
+                bindings: b,
+            });
+        }
+
+        this.#take_settings.budget = this.#frame_budget;
+        this.#take_settings.log_offset = this.#frame_log_offset;
+        b.settings = this.#take_settings;
+
+        shader_mesh_sdf_take.dispatch({ encoder, bindings: b });
+
+        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;
+
+        b.settings = evaluate_settings;
+
+        shader_mesh_sdf_evaluate.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#take,
+            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();
+
+        shader_mesh_sdf_store.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;
+
+        for (let i = 0; i < placements.length; i += 3) {
+            const id = placements[i];
+            const first = placements[i + 1];
+            const scratch = placements[i + 2];
+
+            encoder.clearBuffer(arena, 4 * (first + scratch), 4 * (this.#placement_words[id] - scratch));
+
+            const histogram = this.#histogram_settings;
+
+            histogram.geometry = id;
+            histogram.columns = this.#placement_columns[id];
+            b.settings = histogram;
+
+            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;
+
+            log.geometry = id;
+            log.log_offset = this.#frame_log_offset;
+            log.log_capacity = this.#frame_log_capacity;
+            b.settings = log;
+
+            shader_mesh_cards_log.dispatch({ encoder, bindings: b });
+        }
+
+        // placed layouts into ranges of their own size
+        const moves = this.#frame_compactions;
+
+        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);
+
+            settings.source = moves[i];
+            settings.destination = moves[i + 1];
+            settings.count = moves[i + 2];
+            settings.groups_x = groups_x;
+            b.settings = settings;
+
+            shader_mesh_cards_compact.dispatch({
+                encoder,
+                group_count_x: groups_x,
+                group_count_y: Math.ceil(groups / groups_x),
+                bindings: b,
+            });
+        }
+    }
+
+    /**
+     * @param {Uint32Array} words
+     * @param {number} frame the frame the log is of
+     * @param {number} admitted {@link #admitted_total} as that frame left it
+     * @param {number} epoch {@link #ring_epoch} as that frame left it
+     * @param {number} capacity records the log held
+     */
+    #apply_log(words, frame, admitted, epoch, capacity) {
+        if (epoch === this.#ring_epoch && frame > this.#read_frame) {
+            this.#read_frame = frame;
+            this.#read_queued = words[MESH_SDF_LOG_QUEUED];
+            this.#read_admitted = admitted;
+        }
+
+        this.#bricks_evaluated += words[MESH_SDF_LOG_TAKEN];
+
+        if (frame === this.#read_frame) {
+            this.#free_slots = words[MESH_SDF_LOG_FREE_SLOTS];
+        }
+
+        if (words[MESH_SDF_LOG_STARVED] !== 0) {
+            this.#starved_frames++;
+
+            // a log from before the last growth asked for what that growth gave
+            if (frame > this.#grown_frame) {
+                this.#grow_slots();
+                this.#grown_frame = this.#frame;
+            }
+        }
+
+        const count = words[MESH_SDF_LOG_COMPLETIONS];
+
+        assert.lessThanOrEqual(count, capacity, 'bake log overflowed: a geometry completed that was not in flight');
+
+        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;
+
+            if (this.#state[id] !== HOST_BAKING || this.#generation[id] !== words[word + 1]) {
+                // of a bake dropped since
+                continue;
+            }
+
+            this.#state[id] = HOST_RESIDENT;
+            this.#baking--;
+            this.#resident_count++;
+
+            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);
+        }
+    }
+
+    /**
+     * 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.
+     *
+     * @param {number} id
+     */
+    #drop(id) {
+        const state = this.#state[id];
+
+        if (state === HOST_NONE) {
+            return;
+        }
+
+        this.#state[id] = HOST_NONE;
+
+        if (state === HOST_QUEUED) {
+            return;
+        }
+
+        if (state === HOST_ALIAS) {
+            this.#aliases.delete(id);
+        } else {
+            if (state === HOST_BAKING) {
+                this.#baking--;
+            } else {
+                this.#resident_count--;
+            }
+
+            const range = this.#ranges[id];
+
+            this.#freed.push(range.offset + 1, this.#brick_count[id]);
+            this.#freeing.push(range);
+            this.#ranges[id] = null;
+
+            this.#drop_cards(id);
+        }
+
+        // bricks of this id still on the ring are stale from here on, by the state
+        if (this.#headers !== null) {
+            this.#word_scratch[0] = MeshSDFState.None;
+            this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES + HEADER_STATE, this.#word_scratch, 0, 1);
+        }
+    }
+
+    /**
+     * @param {number} id
+     * @param {MeshSDFLayout} layout
+     * @param {number} indirection
+     */
+    #write_header_baking(id, layout, indirection) {
+        const view = this.#header_scratch;
+
+        for (let axis = 0; axis < 3; axis++) {
+            view.setFloat32(HEADER_ORIGIN + 4 * axis, layout.origin[axis], true);
+            view.setUint32(HEADER_BRICKS + 4 * axis, layout.bricks[axis], true);
+        }
+
+        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, MeshSDFState.Baking, true);
+        view.setUint32(HEADER_SOURCE, GPU_DATABASE_NULL, true);
+        view.setUint32(HEADER_GENERATION, this.#generation[id], true);
+        view.setUint32(HEADER_TWO_SIDED, this.#two_sided[id], true);
+
+        this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES, view.buffer, 0, HEADER_BYTES);
+    }
+
+    /**
+     * @param {number} id
+     * @param {number} source
+     */
+    #write_header_alias(id, source) {
+        const view = this.#header_scratch;
+
+        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);
+
+        this.#device.queue.writeBuffer(this.#headers, id * HEADER_BYTES, view.buffer, 0, HEADER_BYTES);
+    }
+
+    /**
+     * @param {number} id
+     */
+    #ensure_id(id) {
+        const length = id + 1;
+
+        this.#references = grow_typed(this.#references, length);
+        this.#two_sided_references = grow_typed(this.#two_sided_references, length);
+        this.#two_sided = grow_typed(this.#two_sided, length);
+        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);
+    }
+
+    #ensure_device() {
+        if (this.#headers !== null) {
+            return;
+        }
+
+        const device = this.#device;
+
+        this.#headers = this.#create_buffer("headers", HEADER_BYTES * 64, GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC);
+        this.#header_capacity = 64;
+
+        this.#indirection_capacity = INITIAL_ARENA_WORDS;
+        this.#indirection = this.#create_buffer("indirection", 4 * this.#indirection_capacity, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+        this.#indirection_allocator = new OffsetAllocator(this.#indirection_capacity);
+
+        // the counters are the arena's first words, where every pass finds them
+        const counters = this.#indirection_allocator.allocate(MESH_SDF_COUNTER_WORDS);
+
+        assert.equal(counters.offset, 0, 'the counters are the arena\'s first allocation');
+
+        this.#atlas = new GPUTileAtlas3D({
+            device,
+            formats: ["r8unorm"],
+            content_size: [MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_TEXELS],
+            border: 0,
+            slots_x: ATLAS_SLOTS_XY,
+            slots_y: ATLAS_SLOTS_XY,
+            capacity: INITIAL_SLOT_CAPACITY,
+            // sampled by the readers, stored into by the bake's store pass
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
+            label: "GPUGeometrySDFManager/bricks",
+        });
+
+        this.#atlas.reserve(INITIAL_SLOT_CAPACITY);
+
+        this.#slot_capacity = INITIAL_SLOT_CAPACITY;
+        this.#slots = this.#create_buffer("slots", 4 * this.#slot_capacity, GPUBufferUsage.COPY_SRC);
+        this.#fill_pending = true;
+
+        this.#take = this.#create_buffer("take", 4 * MESH_SDF_TAKE_WORDS, GPUBufferUsage.INDIRECT);
+
+        this.#word_scratch[0] = this.#slot_capacity;
+        this.#word_scratch[1] = 0;
+        this.#word_scratch[2] = 0;
+        this.#word_scratch[3] = 0;
+        device.queue.writeBuffer(this.#indirection, 0, this.#word_scratch, 0, MESH_SDF_COUNTER_WORDS);
+
+        this.#reset_ring();
+
+        this.#ensure_frame(INITIAL_LOG_CAPACITY, 1);
+
+        // aliases made before there was a header to write them into
+        for (const [id, source] of this.#aliases) {
+            this.#ensure_headers(id + 1);
+            this.#write_header_alias(id, source);
+        }
+    }
+
+    /**
+     * A ring for twice the bricks of the largest geometry the cap allows, emptied.
+     */
+    #reset_ring() {
+        const capacity = 2 ** Math.ceil(Math.log2(2 * max_bricks_of_a_geometry(this.#max_bricks)));
+
+        if (this.#ring === null || this.#ring_capacity !== capacity) {
+            this.#ring?.destroy();
+            this.#ring_capacity = capacity;
+            // copied from when the staging grows
+            this.#ring = this.#create_buffer("ring", 16 * (capacity + MESH_SDF_STAGING_VEC4S * this.#staging_bricks), GPUBufferUsage.COPY_SRC);
+        }
+
+        // head and tail
+        this.#word_scratch[0] = 0;
+        this.#word_scratch[1] = 0;
+        this.#device.queue.writeBuffer(this.#indirection, 4, this.#word_scratch, 0, 2);
+
+        this.#ring_epoch++;
+        this.#read_queued = 0;
+        this.#read_admitted = this.#admitted_total;
+    }
+
+    /**
+     * @param {number} id_count
+     */
+    #ensure_headers(id_count) {
+        if (id_count > this.#header_capacity) {
+            let capacity = this.#header_capacity;
+
+            while (capacity < id_count) {
+                capacity *= 2;
+            }
+
+            this.#headers = this.#regrow(this.#headers, "headers", HEADER_BYTES * capacity, GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC);
+            this.#header_capacity = capacity;
+        }
+    }
+
+    /**
+     * Room for a frame: a log for `records` completions and a tally for each of `bricks` bricks taken,
+     * in one range of the arena, and staging for the bricks in the ring. Neither shrinks. A larger range
+     * is a new one and nothing is copied, since the frame's words are written afresh every frame; the
+     * ring's entries are copied when its staging grows.
+     *
+     * @param {number} records
+     * @param {number} bricks
+     */
+    #ensure_frame(records, bricks) {
+        if (this.#frame_range !== null && records <= this.#log_capacity && bricks <= this.#staging_bricks) {
+            return;
+        }
+
+        let log_capacity = Math.max(1, this.#log_capacity);
+
+        while (log_capacity < records) {
+            log_capacity *= 2;
+        }
+
+        const staging = Math.max(bricks, this.#staging_bricks);
+
+        if (this.#frame_range !== null) {
+            this.#indirection_allocator.free(this.#frame_range);
+        }
+
+        const words = MESH_SDF_LOG_HEADER_WORDS + MESH_SDF_LOG_RECORD_WORDS * log_capacity + staging;
+
+        this.#ensure_indirection(words);
+
+        this.#frame_range = this.#indirection_allocator.allocate(words);
+        this.#log_capacity = log_capacity;
+
+        if (staging > this.#staging_bricks) {
+            this.#staging_bricks = staging;
+            this.#ring = this.#regrow(this.#ring, "ring", 16 * (this.#ring_capacity + MESH_SDF_STAGING_VEC4S * staging), 0);
+        }
+    }
+
+    /**
+     * Room in the indirection for an allocation of `count` entries.
+     *
+     * @param {number} count
+     */
+    #ensure_indirection(count) {
+        const allocator = this.#indirection_allocator;
+
+        if (allocator.can_allocate(count)) {
+            return;
+        }
+
+        // exactly what the allocation needs, rounded up to a doubling
+        const target = allocator.grow_target_for(count);
+
+        let capacity = this.#indirection_capacity;
+
+        while (capacity < target) {
+            capacity *= 2;
+        }
+
+        // the new buffer first: grow() appends to the arena, and nothing moves
+        this.#indirection = this.#regrow(this.#indirection, "indirection", 4 * capacity, 0);
+        allocator.grow(capacity);
+        this.#indirection_capacity = capacity;
+    }
+
+    /**
+     * Double the atlas and its slot stack, the new slots pushed by the next bake.
+     */
+    #grow_slots() {
+        const atlas = this.#atlas;
+        const old_capacity = this.#slot_capacity;
+        const capacity = Math.min(2 * old_capacity, atlas.capacity_limit);
+
+        if (capacity <= old_capacity) {
+            return;
+        }
+
+        atlas.reserve(capacity);
+
+        this.#slots = this.#regrow(this.#slots, "slots", 4 * capacity, GPUBufferUsage.COPY_SRC);
+        this.#slot_capacity = capacity;
+        this.#pushes.push(old_capacity, capacity - old_capacity);
+    }
+
+    /**
+     * A runs buffer of at least `runs` entries.
+     *
+     * @param {GPUBuffer|null} buffer
+     * @param {number} runs
+     * @param {string} name
+     * @returns {GPUBuffer}
+     */
+    #ensure_runs_buffer(buffer, runs, name) {
+        const size = 8 * runs;
+
+        if (buffer !== null && buffer.size >= size) {
+            return buffer;
+        }
+
+        buffer?.destroy();
+
+        let capacity = 64;
+
+        while (8 * capacity < size) {
+            capacity *= 2;
+        }
+
+        return this.#create_buffer(name, 8 * capacity, GPUBufferUsage.COPY_DST);
+    }
+
+    /**
+     * @param {string} name
+     * @param {number} size
+     * @param {GPUBufferUsageFlags} usage beside STORAGE
+     * @returns {GPUBuffer}
+     */
+    #create_buffer(name, size, usage) {
+        return this.#device.createBuffer(BufferDescriptor.fromJSON({
+            label: `GPUGeometrySDFManager/${name}`,
+            size,
+            usage: GPUBufferUsage.STORAGE | usage,
+        }));
+    }
+
+    /**
+     * A larger buffer with the old one's bytes, copied ahead of the frame's commands; the old one is
+     * destroyed after the copy is submitted.
+     *
+     * @param {GPUBuffer} old
+     * @param {string} name
+     * @param {number} size
+     * @param {GPUBufferUsageFlags} usage beside STORAGE; COPY_SRC and COPY_DST are added
+     * @returns {GPUBuffer}
+     */
+    #regrow(old, name, size, usage) {
+        const device = this.#device;
+        const buffer = this.#create_buffer(name, size, usage | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+
+        const encoder = device.createCommandEncoder({ label: `GPUGeometrySDFManager/${name} growth` });
+
+        encoder.copyBufferToBuffer(old, 0, buffer, 0, old.size);
+        device.queue.submit([encoder.finish()]);
+
+        old.destroy();
+
+        return buffer;
+    }
+
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+
+        this.#destroyed = true;
+
+        for (const buffer of [this.#headers, this.#indirection, this.#slots, this.#take, this.#ring, this.#classify_ranges, this.#free_ranges]) {
+            buffer?.destroy();
+        }
+
+        this.#atlas?.destroy();
+        this.#cards.destroy();
+
+        this.#headers = null;
+        this.#indirection = null;
+        this.#slots = null;
+        this.#take = null;
+        this.#ring = null;
+        this.#classify_ranges = null;
+        this.#free_ranges = null;
+        this.#atlas = null;
     }
 }