@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/geometry/sdf/MESH_SDF.d.ts

@@ -38,6 +38,13 @@ export const MESH_SDF_EMPTY: number;
  * @type {number}
  */
 export const MESH_SDF_EMPTY_INSIDE: number;
+/**
+ * A brick's number when it holds no slot. A brick given a slot is numbered among its geometry's
+ * stored bricks, 0 up, in the order the bake stored them: what a payload kept per stored brick, as
+ * a surface cache's tiles, is laid out by.
+ * @type {number}
+ */
+export const MESH_SDF_UNNUMBERED: number;
 /**
  * What a geometry's header says about its field.
  */

package/src/shade/renderer/geometry/sdf/MESH_SDF.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MESH_SDF.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,yCAFU,MAAM,CAEgG;AAEhH;;;;;GAKG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;GAKG;AACH,6BAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,oCAFU,MAAM,CAEwC;;;;2BAK9C,MAAM;AAHhB;;;;GAIG;AACH;IACI,0FAA0F;;IAE1F,wFAAwF;;IAExF,sCAAsC;;IAEtC,4GAA4G;;GAE7G"}
+{"version":3,"file":"MESH_SDF.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,yCAFU,MAAM,CAEgG;AAEhH;;;;;GAKG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;GAKG;AACH,6BAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,oCAFU,MAAM,CAEwC;AAExD;;;;;GAKG;AACH,kCAFU,MAAM,CAE8B;;;;2BAKpC,MAAM;AAHhB;;;;GAIG;AACH;IACI,0FAA0F;;IAE1F,wFAAwF;;IAExF,sCAAsC;;IAEtC,4GAA4G;;GAE7G"}

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

@@ -45,6 +45,14 @@ export const MESH_SDF_EMPTY = 0x80000000;
  */
 export const MESH_SDF_EMPTY_INSIDE = MESH_SDF_EMPTY + 1;
 
+/**
+ * A brick's number when it holds no slot. A brick given a slot is numbered among its geometry's
+ * stored bricks, 0 up, in the order the bake stored them: what a payload kept per stored brick, as
+ * a surface cache's tiles, is laid out by.
+ * @type {number}
+ */
+export const MESH_SDF_UNNUMBERED = 0xffffffff;
+
 /**
  * What a geometry's header says about its field.
  * @readonly

package/src/shade/renderer/geometry/sdf/MESH_SDF_BRICK_KEY.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A brick's content key, from its 512 bytes, texel x + 8y + 64z.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset the brick's first byte
+ * @returns {number} u32
+ */
+export function mesh_sdf_brick_key(bytes: Uint8Array, offset: number): number;
+/**
+ * The seed of the key's hash.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_KEY_SEED: number;
+//# sourceMappingURL=MESH_SDF_BRICK_KEY.d.ts.map

package/src/shade/renderer/geometry/sdf/MESH_SDF_BRICK_KEY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SDF_BRICK_KEY.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF_BRICK_KEY.js"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,0CAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAUlB;AArBD;;;GAGG;AACH,sCAFU,MAAM,CAEkC"}

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

@@ -0,0 +1,35 @@
+import { lowbias32 } from "../../../../core/math/hash/lowbias32.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT } from "./MESH_SDF.js";
+
+/*
+ A brick's content key: a u32, the sum over the brick's texels of a hash of (texel, byte), mod 2^32.
+
+   term(t, b) = lowbias32(((t << 8) | b) ^ seed)      t: texel x + 8y + 64z, b: its byte
+
+ A key finds the slots that may hold a brick's bytes; it never says that they do. Two bricks share a slot
+ only once their 512 bytes compare equal, so keys that agree for different bytes cost a share, never a
+ brick its bytes. A sum, the terms add in any order, on any thread.
+*/
+
+/**
+ * The seed of the key's hash.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_KEY_SEED = 0x9e3779b9;
+
+/**
+ * A brick's content key, from its 512 bytes, texel x + 8y + 64z.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset the brick's first byte
+ * @returns {number} u32
+ */
+export function mesh_sdf_brick_key(bytes, offset) {
+    let key = 0;
+
+    for (let t = 0; t < MESH_SDF_BRICK_TEXEL_COUNT; t++) {
+        key = (key + lowbias32((((t << 8) | bytes[offset + t]) ^ MESH_SDF_BRICK_KEY_SEED) >>> 0)) >>> 0;
+    }
+
+    return key;
+}

package/src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MESH_SDF_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,8BAFU,YAAY,CA0CR;6BAnDe,mCAAmC"}
+{"version":3,"file":"MESH_SDF_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,8BAFU,YAAY,CAsCR;6BA/Ce,mCAAmC"}

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

@@ -28,10 +28,6 @@ export const MESH_SDF_STRUCT = WebGPUStruct.from({
      * The first entry of level 0 in the indirection.
      */
     indirection: u32,
-    /**
-     * The first word of the geometry's card layout, `GPU_DATABASE_NULL` until its cards are placed.
-     */
-    cards: u32,
     /**
      * `MeshSDFState`.
      */

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Records of the frame's claims, which name one brick of the frame for each content key no slot is
+ * listed under, for a frame of `bricks` bricks taken: twice as many, so that a key's probes pass an
+ * empty record within a few, and no fewer than the probe limit, so that they meet no record twice; a
+ * power of two.
+ *
+ * @param {number} bricks
+ * @returns {number}
+ */
+export function mesh_sdf_claim_size(bricks: number): number;
 /**
  * Lanes of every bake workgroup: a block of a brick's texels in evaluate and store, and a run of
  * classify or free threads.
@@ -39,10 +49,39 @@ export const MESH_SDF_COUNTER_WORDS: 4;
 export const MESH_SDF_TAKE_DISPATCH: 0;
 /** `take`: the ring position of the first brick taken. */
 export const MESH_SDF_TAKE_START: 3;
-/** `take`: the dispatch of card placement's page pass, three words: a thread a column, as its merge found. */
-export const MESH_SDF_TAKE_PLACE_DISPATCH: 4;
+/** `take`: the bricks taken. */
+export const MESH_SDF_TAKE_COUNT: 4;
 /** `take`, in words. */
-export const MESH_SDF_TAKE_WORDS: 8;
+export const MESH_SDF_TAKE_WORDS: 5;
+/**
+ * A brick's entry from evaluate to resolve in the frame it is taken: a texel of it is within the band,
+ * and which slot holds its bytes is resolve's to say. Past EMPTY, so it holds no slot.
+ * @type {number}
+ */
+export const MESH_SDF_PENDING: number;
+/**
+ * No slot: what a brick taken's record holds for its slot until it has one, and what a find of the
+ * slots by content returns when it finds none (`chunk_mesh_sdf_contents`).
+ * @type {number}
+ */
+export const MESH_SDF_NO_CONTENT: number;
+/** A brick taken's record: the tally of its workgroups ({@link MESH_SDF_TALLY_BAND_UNIT}). */
+export const MESH_SDF_TAKEN_TALLY: 0;
+/** A brick taken's record: its content key, the sum of key's terms. */
+export const MESH_SDF_TAKEN_KEY: 1;
+/** A brick taken's record: the slot find found under its key, then the slot resolve gave it. */
+export const MESH_SDF_TAKEN_SLOT: 2;
+/** A brick taken's record: 1 when its slot is fresh, which store fills. */
+export const MESH_SDF_TAKEN_FRESH: 3;
+/**
+ * A brick taken's record: the brick of the frame, by its place in the take, that first claimed its
+ * key, when find found no slot under it.
+ */
+export const MESH_SDF_TAKEN_REP: 4;
+/** A brick taken's record: its texels whose bytes differ from the slot's it found, or its representative's. */
+export const MESH_SDF_TAKEN_DIFFERS: 5;
+/** Words of a brick taken's record. */
+export const MESH_SDF_TAKEN_WORDS: 6;
 /** `log`: bricks left on the ring after the frame's take, stale ones included. */
 export const MESH_SDF_LOG_QUEUED: 0;
 /** `log`: 1 when the take was held back by the free slots, which asks the host for more. */
@@ -53,19 +92,25 @@ export const MESH_SDF_LOG_FREE_SLOTS: 2;
 export const MESH_SDF_LOG_TAKEN: 3;
 /** `log`: geometries completed this frame; their records follow the header. */
 export const MESH_SDF_LOG_COMPLETIONS: 4;
+/** `log`: bricks resolve gave a slot already holding their bytes. */
+export const MESH_SDF_LOG_SHARED: 5;
+/**
+ * `log`: bricks whose content key was that of a slot, or of their representative, holding other
+ * bytes, and which took a slot of their own.
+ */
+export const MESH_SDF_LOG_COLLIDED: 6;
 /** `log`: words before the first record. */
-export const MESH_SDF_LOG_HEADER_WORDS: 5;
+export const MESH_SDF_LOG_HEADER_WORDS: 7;
 /**
- * `log`: words a record: the geometry id, the generation it was baked at, and what the record
- * reports. A completion reports nothing; a placement, marked by MESH_SDF_LOG_PLACED on the id,
- * reports the columns and the pages its cards took.
+ * `log`: words a completion record: the geometry id, the generation it was baked at, and the bricks
+ * given a slot, which count writes ({@link MESH_SDF_LOG_STORED}).
  */
-export const MESH_SDF_LOG_RECORD_WORDS: 4;
+export const MESH_SDF_LOG_RECORD_WORDS: 3;
 /**
- * `log`: the mark on a record's geometry id that says its cards were placed. Geometry ids stay below it.
+ * `log`: the word of a completion record that holds its geometry's stored bricks.
  * @type {number}
  */
-export const MESH_SDF_LOG_PLACED: number;
+export const MESH_SDF_LOG_STORED: number;
 /**
  * A tally, a workgroup's of its lanes and a brick's of its workgroups: the low half counts those
  * finished, the high half those with a texel within the band, in this unit.

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MESH_SDF_BAKE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wCAFU,MAAM,CAEmF;AAEnG;;;;GAIG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;GAGG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;;;GAKG;AACH,2CAFU,MAAM,CAE0F;AAE1G,kEAAkE;AAClE,uCAAwC;AACxC,uEAAuE;AACvE,sCAAuC;AACvC,mEAAmE;AACnE,sCAAuC;AACvC,4DAA4D;AAC5D,uCAAwC;AAExC,2GAA2G;AAC3G,uCAAwC;AACxC,0DAA0D;AAC1D,oCAAqC;AACrC,8GAA8G;AAC9G,6CAA8C;AAC9C,wBAAwB;AACxB,oCAAqC;AAErC,kFAAkF;AAClF,oCAAqC;AACrC,4FAA4F;AAC5F,qCAAsC;AACtC,yCAAyC;AACzC,wCAAyC;AACzC,iDAAiD;AACjD,mCAAoC;AACpC,+EAA+E;AAC/E,yCAA0C;AAC1C,4CAA4C;AAC5C,0CAA2C;AAC3C;;;;GAIG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,uCAFU,MAAM,CAE8B"}
+{"version":3,"file":"MESH_SDF_BAKE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.js"],"names":[],"mappings":"AAkIA;;;;;;;;GAQG;AACH,4CAHW,MAAM,GACJ,MAAM,CAIlB;AA/FD;;;;GAIG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wCAFU,MAAM,CAEmF;AAEnG;;;;GAIG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;GAGG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;;;GAKG;AACH,2CAFU,MAAM,CAE0F;AAE1G,kEAAkE;AAClE,uCAAwC;AACxC,uEAAuE;AACvE,sCAAuC;AACvC,mEAAmE;AACnE,sCAAuC;AACvC,4DAA4D;AAC5D,uCAAwC;AAExC,2GAA2G;AAC3G,uCAAwC;AACxC,0DAA0D;AAC1D,oCAAqC;AACrC,gCAAgC;AAChC,oCAAqC;AACrC,wBAAwB;AACxB,oCAAqC;AAErC;;;;GAIG;AACH,+BAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,kCAFU,MAAM,CAE8B;AAE9C,8FAA8F;AAC9F,qCAAsC;AACtC,uEAAuE;AACvE,mCAAoC;AACpC,gGAAgG;AAChG,oCAAqC;AACrC,2EAA2E;AAC3E,qCAAsC;AACtC;;;GAGG;AACH,mCAAoC;AACpC,+GAA+G;AAC/G,uCAAwC;AACxC,uCAAuC;AACvC,qCAAsC;AAetC,kFAAkF;AAClF,oCAAqC;AACrC,4FAA4F;AAC5F,qCAAsC;AACtC,yCAAyC;AACzC,wCAAyC;AACzC,iDAAiD;AACjD,mCAAoC;AACpC,+EAA+E;AAC/E,yCAA0C;AAC1C,qEAAqE;AACrE,oCAAqC;AACrC;;;GAGG;AACH,sCAAuC;AACvC,4CAA4C;AAC5C,0CAA2C;AAC3C;;;GAGG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;GAIG;AACH,uCAFU,MAAM,CAE8B"}

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.js

@@ -1,15 +1,31 @@
-import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_VOXELS } from "../MESH_SDF.js";
+import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
+import { HASH_TABLE_PROBE_LIMIT } from "../../../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_VOXELS, MESH_SDF_EMPTY } from "../MESH_SDF.js";
 
 /*
  The bake's device state (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4), shared by its passes:
 
+   free:     a thread an entry of the ranges freed since the last bake: a slot one entry fewer holds,
+             given back when no entry holds it.
    classify: one thread a brick of the geometries admitted this frame. A brick no texel of which can
              be within the band is EMPTY; the rest go onto the ring.
    take:     one thread. Up to the budget off the ring, and no more than the stack has free slots, so
              that no pop below can fail.
    evaluate: a thread a texel of each brick taken, MESH_SDF_GROUPS_PER_BRICK workgroups a brick, into
-             staging. The brick's last thread to finish gives it a slot or EMPTY.
-   store:    a thread a texel of each brick taken, from staging into the brick's slot.
+             staging. The brick's last thread to finish makes it PENDING or EMPTY, and a PENDING brick
+             takes the next number of its geometry's stored bricks.
+   key:      a thread a texel of each PENDING brick: its term of the brick's content key
+             (`MESH_SDF_BRICK_KEY.js`), added into the brick's record.
+   resolve:  four passes. Find, a thread a brick taken: a PENDING brick finds a slot listed under its key
+             (`chunk_mesh_sdf_contents`), and one that finds none claims its key in the frame's claims,
+             the first to claim it the key's representative. Compare, a thread a texel: a brick's bytes
+             against the slot's it found, or its representative's, a texel that differs marking it. Fresh,
+             a thread a brick: a representative pops a slot and lists it under its key, and a brick whose
+             bytes differ pops one of its own. Hold, a thread a brick: every PENDING brick takes its slot,
+             its representative's when it has none, and its entry holds it.
+   store:    a thread a texel of each brick that took a fresh slot, from staging into it.
+   count:    a thread a record of the frame's log: a completion's stored bricks, read once every brick
+             of the frame has settled.
 
  A geometry's bricks are counted down in its pending word from its brick count, one as classify drops
  a brick and one as evaluate settles it, and the one that reaches zero logs the geometry complete.
@@ -18,9 +34,12 @@ import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_VOXELS } from "../MESH_SDF.j
  SHADE_DEVICE_FLOOR beside the five a BLAS query reads. Two of them carry more than their name:
 
    mesh_sdf_indirection, the arena of every brick's entry, which the bake views as atomics, holds at
-     word 0 the counters (MESH_SDF_COUNTER_*); at `log_offset` the frame's log (MESH_SDF_LOG_*), and
-     at `tally_offset` the frame's tallies, a word a brick taken; and a geometry's pending word just
-     before its first entry, `header.indirection - 1`;
+     word 0 the counters (MESH_SDF_COUNTER_*); at `log_offset` the frame's log (MESH_SDF_LOG_*), at
+     `tally_offset` a record of MESH_SDF_TAKEN_WORDS for each brick taken (MESH_SDF_TAKEN_*), and at
+     `claim_offset` the frame's claims, `claim_size` words each 0 or a brick's place in the take + 1;
+     and a geometry's range (`chunk_mesh_sdf`): its stored count at `header.indirection - 2`, its
+     pending word at `header.indirection - 1`, its entries, then the numbers of its bricks and its
+     bricks by number;
    mesh_sdf_ring holds the ring's entries, then from `ring_capacity` on the frame's staging,
      MESH_SDF_STAGING_VEC4S a brick taken.
 */
@@ -72,10 +91,55 @@ export const MESH_SDF_COUNTER_WORDS = 4;
 export const MESH_SDF_TAKE_DISPATCH = 0;
 /** `take`: the ring position of the first brick taken. */
 export const MESH_SDF_TAKE_START = 3;
-/** `take`: the dispatch of card placement's page pass, three words: a thread a column, as its merge found. */
-export const MESH_SDF_TAKE_PLACE_DISPATCH = 4;
+/** `take`: the bricks taken. */
+export const MESH_SDF_TAKE_COUNT = 4;
 /** `take`, in words. */
-export const MESH_SDF_TAKE_WORDS = 8;
+export const MESH_SDF_TAKE_WORDS = 5;
+
+/**
+ * A brick's entry from evaluate to resolve in the frame it is taken: a texel of it is within the band,
+ * and which slot holds its bytes is resolve's to say. Past EMPTY, so it holds no slot.
+ * @type {number}
+ */
+export const MESH_SDF_PENDING = MESH_SDF_EMPTY + 2;
+
+/**
+ * No slot: what a brick taken's record holds for its slot until it has one, and what a find of the
+ * slots by content returns when it finds none (`chunk_mesh_sdf_contents`).
+ * @type {number}
+ */
+export const MESH_SDF_NO_CONTENT = 0xffffffff;
+
+/** A brick taken's record: the tally of its workgroups ({@link MESH_SDF_TALLY_BAND_UNIT}). */
+export const MESH_SDF_TAKEN_TALLY = 0;
+/** A brick taken's record: its content key, the sum of key's terms. */
+export const MESH_SDF_TAKEN_KEY = 1;
+/** A brick taken's record: the slot find found under its key, then the slot resolve gave it. */
+export const MESH_SDF_TAKEN_SLOT = 2;
+/** A brick taken's record: 1 when its slot is fresh, which store fills. */
+export const MESH_SDF_TAKEN_FRESH = 3;
+/**
+ * A brick taken's record: the brick of the frame, by its place in the take, that first claimed its
+ * key, when find found no slot under it.
+ */
+export const MESH_SDF_TAKEN_REP = 4;
+/** A brick taken's record: its texels whose bytes differ from the slot's it found, or its representative's. */
+export const MESH_SDF_TAKEN_DIFFERS = 5;
+/** Words of a brick taken's record. */
+export const MESH_SDF_TAKEN_WORDS = 6;
+
+/**
+ * Records of the frame's claims, which name one brick of the frame for each content key no slot is
+ * listed under, for a frame of `bricks` bricks taken: twice as many, so that a key's probes pass an
+ * empty record within a few, and no fewer than the probe limit, so that they meet no record twice; a
+ * power of two.
+ *
+ * @param {number} bricks
+ * @returns {number}
+ */
+export function mesh_sdf_claim_size(bricks) {
+    return ceilPowerOfTwo(Math.max(HASH_TABLE_PROBE_LIMIT, 2 * bricks));
+}
 
 /** `log`: bricks left on the ring after the frame's take, stale ones included. */
 export const MESH_SDF_LOG_QUEUED = 0;
@@ -87,20 +151,26 @@ export const MESH_SDF_LOG_FREE_SLOTS = 2;
 export const MESH_SDF_LOG_TAKEN = 3;
 /** `log`: geometries completed this frame; their records follow the header. */
 export const MESH_SDF_LOG_COMPLETIONS = 4;
+/** `log`: bricks resolve gave a slot already holding their bytes. */
+export const MESH_SDF_LOG_SHARED = 5;
+/**
+ * `log`: bricks whose content key was that of a slot, or of their representative, holding other
+ * bytes, and which took a slot of their own.
+ */
+export const MESH_SDF_LOG_COLLIDED = 6;
 /** `log`: words before the first record. */
-export const MESH_SDF_LOG_HEADER_WORDS = 5;
+export const MESH_SDF_LOG_HEADER_WORDS = 7;
 /**
- * `log`: words a record: the geometry id, the generation it was baked at, and what the record
- * reports. A completion reports nothing; a placement, marked by MESH_SDF_LOG_PLACED on the id,
- * reports the columns and the pages its cards took.
+ * `log`: words a completion record: the geometry id, the generation it was baked at, and the bricks
+ * given a slot, which count writes ({@link MESH_SDF_LOG_STORED}).
  */
-export const MESH_SDF_LOG_RECORD_WORDS = 4;
+export const MESH_SDF_LOG_RECORD_WORDS = 3;
 
 /**
- * `log`: the mark on a record's geometry id that says its cards were placed. Geometry ids stay below it.
+ * `log`: the word of a completion record that holds its geometry's stored bricks.
  * @type {number}
  */
-export const MESH_SDF_LOG_PLACED = 0x80000000;
+export const MESH_SDF_LOG_STORED = 2;
 
 /**
  * A tally, a workgroup's of its lanes and a brick's of its workgroups: the low half counts those

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.d.ts

@@ -1,7 +1,7 @@
 /**
  * The indirection arena as the bake sees it: every word an atomic, the counters at word 0, the
- * frame's log at `log_offset` and its tallies at `tally_offset`, and a geometry's pending word before its
- * entries (`MESH_SDF_BAKE.js`).
+ * frame's log at `log_offset` and its tallies at `tally_offset`, and each geometry's range, its stored
+ * count and pending word before its entries (`MESH_SDF_BAKE.js`, `chunk_mesh_sdf`).
  * Readers bind the same buffer as plain words, through `MESH_SDF_INDIRECTION_RESOURCE`.
  * @type {ShaderResourceDescriptor}
  */

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_mesh_sdf_bake.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH,sCAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,uCAFU,wBAAwB,CAEyF;AAE3H;;;;;GAKG;AACH,kCAFU,SAAS,CA2BZ;AAEP;;;;;;;;;;;GAWG;AACH,yCAFU,SAAS,CAwBZ;AAIP;;;;;;;;;GASG;AACH,wCAFU,SAAS,CAsBhB;yCA9IsC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_mesh_sdf_bake.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.js"],"names":[],"mappings":"AAsCA;;;;;;GAMG;AACH,sCAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,uCAFU,wBAAwB,CAEyF;AAE3H;;;;;GAKG;AACH,kCAFU,SAAS,CAyCZ;AAEP;;;;;;;;;;;GAWG;AACH,yCAFU,SAAS,CAwBZ;AAIP;;;;;;;;;GASG;AACH,wCAFU,SAAS,CAsBhB;yCAxKsC,sDAAsD;0BADrE,uCAAuC"}

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.js

@@ -10,24 +10,36 @@ import {
     MESH_SDF_COUNTER_HEAD,
     MESH_SDF_COUNTER_SLOTS,
     MESH_SDF_COUNTER_TAIL,
+    MESH_SDF_LOG_COLLIDED,
     MESH_SDF_LOG_COMPLETIONS,
     MESH_SDF_LOG_FREE_SLOTS,
     MESH_SDF_LOG_HEADER_WORDS,
     MESH_SDF_LOG_QUEUED,
     MESH_SDF_LOG_RECORD_WORDS,
+    MESH_SDF_LOG_SHARED,
     MESH_SDF_LOG_STARVED,
     MESH_SDF_LOG_TAKEN,
     MESH_SDF_GROUPS_PER_BRICK,
+    MESH_SDF_NO_CONTENT,
+    MESH_SDF_PENDING,
     MESH_SDF_STAGING_VEC4S,
+    MESH_SDF_TAKE_COUNT,
     MESH_SDF_TAKE_DISPATCH,
     MESH_SDF_TAKE_START,
+    MESH_SDF_TAKEN_DIFFERS,
+    MESH_SDF_TAKEN_FRESH,
+    MESH_SDF_TAKEN_KEY,
+    MESH_SDF_TAKEN_REP,
+    MESH_SDF_TAKEN_SLOT,
+    MESH_SDF_TAKEN_TALLY,
+    MESH_SDF_TAKEN_WORDS,
     MESH_SDF_TALLY_BAND_UNIT
 } from "./MESH_SDF_BAKE.js";
 
 /**
  * The indirection arena as the bake sees it: every word an atomic, the counters at word 0, the
- * frame's log at `log_offset` and its tallies at `tally_offset`, and a geometry's pending word before its
- * entries (`MESH_SDF_BAKE.js`).
+ * frame's log at `log_offset` and its tallies at `tally_offset`, and each geometry's range, its stored
+ * count and pending word before its entries (`MESH_SDF_BAKE.js`, `chunk_mesh_sdf`).
  * Readers bind the same buffer as plain words, through `MESH_SDF_INDIRECTION_RESOURCE`.
  * @type {ShaderResourceDescriptor}
  */
@@ -61,12 +73,26 @@ const MESH_SDF_COUNTER_TAIL = ${MESH_SDF_COUNTER_TAIL}u;
 
 const MESH_SDF_TAKE_DISPATCH = ${MESH_SDF_TAKE_DISPATCH}u;
 const MESH_SDF_TAKE_START = ${MESH_SDF_TAKE_START}u;
+const MESH_SDF_TAKE_COUNT = ${MESH_SDF_TAKE_COUNT}u;
+
+const MESH_SDF_PENDING = ${MESH_SDF_PENDING}u;
+const MESH_SDF_NO_CONTENT = ${MESH_SDF_NO_CONTENT}u;
+
+const MESH_SDF_TAKEN_TALLY = ${MESH_SDF_TAKEN_TALLY}u;
+const MESH_SDF_TAKEN_KEY = ${MESH_SDF_TAKEN_KEY}u;
+const MESH_SDF_TAKEN_SLOT = ${MESH_SDF_TAKEN_SLOT}u;
+const MESH_SDF_TAKEN_FRESH = ${MESH_SDF_TAKEN_FRESH}u;
+const MESH_SDF_TAKEN_REP = ${MESH_SDF_TAKEN_REP}u;
+const MESH_SDF_TAKEN_DIFFERS = ${MESH_SDF_TAKEN_DIFFERS}u;
+const MESH_SDF_TAKEN_WORDS = ${MESH_SDF_TAKEN_WORDS}u;
 
 const MESH_SDF_LOG_QUEUED = ${MESH_SDF_LOG_QUEUED}u;
 const MESH_SDF_LOG_STARVED = ${MESH_SDF_LOG_STARVED}u;
 const MESH_SDF_LOG_FREE_SLOTS = ${MESH_SDF_LOG_FREE_SLOTS}u;
 const MESH_SDF_LOG_TAKEN = ${MESH_SDF_LOG_TAKEN}u;
 const MESH_SDF_LOG_COMPLETIONS = ${MESH_SDF_LOG_COMPLETIONS}u;
+const MESH_SDF_LOG_SHARED = ${MESH_SDF_LOG_SHARED}u;
+const MESH_SDF_LOG_COLLIDED = ${MESH_SDF_LOG_COLLIDED}u;
 const MESH_SDF_LOG_HEADER_WORDS = ${MESH_SDF_LOG_HEADER_WORDS}u;
 const MESH_SDF_LOG_RECORD_WORDS = ${MESH_SDF_LOG_RECORD_WORDS}u;
 `, [

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_contents.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Records of the content table for a slot capacity: twice the slots, so the table is at most half
+ * full and a key's sequence passes an empty record within a few probes, and no fewer than the probe
+ * limit, which a table holds (`chunk_hash_table_atomic`); a power of two.
+ *
+ * @param {number} slot_capacity
+ * @returns {number}
+ */
+export function mesh_sdf_content_table_size(slot_capacity: number): number;
+/**
+ * Words a slot's contents take in `mesh_sdf_contents`: the entries holding it, then the content key
+ * (`MESH_SDF_BRICK_KEY.js`) it is listed under.
+ * @type {number}
+ */
+export const MESH_SDF_CONTENT_WORDS: number;
+/**
+ * What each slot of the atlas holds, {@link MESH_SDF_CONTENT_WORDS} a slot, by slot.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_CONTENTS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The slots by content: a `chunk_hash_table_atomic` table at word 0, keyed by a content key's high 31
+ * bits, a record's value the slot.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_CONTENT_TABLE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The atlas's slots by what they hold, so that bricks of the same bytes share one slot. Each slot
+ * counts the entries holding it, and the content table lists slots under the content keys of their
+ * bytes, for bricks to find.
+ *
+ * A key names the slots that may hold a brick's bytes and never says that one does: a brick takes a
+ * slot it found only once its bytes and the slot's compare equal, so keys that agree for different
+ * bytes cost a share, never a brick its bytes. Every slot the table lists is held, free taking a
+ * slot's record out with its last entry. A slot listed nowhere, its insert refused (no record free
+ * within the probe limit) or its bytes never offered for sharing, is held all the same and never found.
+ *
+ * ```wgsl
+ * fn mesh_sdf_content_find(key: u32) -> u32          // the first slot listed under the key, or MESH_SDF_NO_CONTENT
+ * fn mesh_sdf_content_list(slot: u32, key: u32)      // a slot about to hold bytes of the key, listed under it
+ * fn mesh_sdf_content_hold(slot: u32)                // one entry more
+ * fn mesh_sdf_content_release(slot: u32) -> bool     // one entry fewer: true for the last, its record gone
+ * ```
+ *
+ * The table keys a record by the key's high 31 bits, so a slot found counts only when the key it is
+ * listed under is the key. No find shares a dispatch with a list or a release: each meets the table
+ * as the dispatches before it left it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_contents: CodeChunk;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_contents.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_contents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_contents.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_contents.js"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,2DAHW,MAAM,GACJ,MAAM,CAIlB;AA9BD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,yCAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,8CAFU,wBAAwB,CAEkH;AAcpJ;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCAFU,SAAS,CA+EZ;yCA1IkC,sDAAsD;0BADrE,uCAAuC"}

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_contents.js

@@ -0,0 +1,146 @@
+import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
+import { chunk_hash_table_atomic } from "../../../gpu_primitive/hash_table/chunk_hash_table_atomic.js";
+import { HASH_TABLE_PROBE_LIMIT } from "../../../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { atomic_u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { chunk_mesh_sdf_bake } from "./chunk_mesh_sdf_bake.js";
+
+/**
+ * Words a slot's contents take in `mesh_sdf_contents`: the entries holding it, then the content key
+ * (`MESH_SDF_BRICK_KEY.js`) it is listed under.
+ * @type {number}
+ */
+export const MESH_SDF_CONTENT_WORDS = 2;
+
+/**
+ * What each slot of the atlas holds, {@link MESH_SDF_CONTENT_WORDS} a slot, by slot.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_CONTENTS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_contents", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * The slots by content: a `chunk_hash_table_atomic` table at word 0, keyed by a content key's high 31
+ * bits, a record's value the slot.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_CONTENT_TABLE_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_content_table", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * Records of the content table for a slot capacity: twice the slots, so the table is at most half
+ * full and a key's sequence passes an empty record within a few probes, and no fewer than the probe
+ * limit, which a table holds (`chunk_hash_table_atomic`); a power of two.
+ *
+ * @param {number} slot_capacity
+ * @returns {number}
+ */
+export function mesh_sdf_content_table_size(slot_capacity) {
+    return ceilPowerOfTwo(Math.max(HASH_TABLE_PROBE_LIMIT, 2 * slot_capacity));
+}
+
+/**
+ * The atlas's slots by what they hold, so that bricks of the same bytes share one slot. Each slot
+ * counts the entries holding it, and the content table lists slots under the content keys of their
+ * bytes, for bricks to find.
+ *
+ * A key names the slots that may hold a brick's bytes and never says that one does: a brick takes a
+ * slot it found only once its bytes and the slot's compare equal, so keys that agree for different
+ * bytes cost a share, never a brick its bytes. Every slot the table lists is held, free taking a
+ * slot's record out with its last entry. A slot listed nowhere, its insert refused (no record free
+ * within the probe limit) or its bytes never offered for sharing, is held all the same and never found.
+ *
+ * ```wgsl
+ * fn mesh_sdf_content_find(key: u32) -> u32          // the first slot listed under the key, or MESH_SDF_NO_CONTENT
+ * fn mesh_sdf_content_list(slot: u32, key: u32)      // a slot about to hold bytes of the key, listed under it
+ * fn mesh_sdf_content_hold(slot: u32)                // one entry more
+ * fn mesh_sdf_content_release(slot: u32) -> bool     // one entry fewer: true for the last, its record gone
+ * ```
+ *
+ * The table keys a record by the key's high 31 bits, so a slot found counts only when the key it is
+ * listed under is the key. No find shares a dispatch with a list or a release: each meets the table
+ * as the dispatches before it left it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_contents = CodeChunk.from(
+    //language=WGSL
+    `
+const MESH_SDF_CONTENT_WORDS = ${MESH_SDF_CONTENT_WORDS}u;
+
+/** the key's records in the content table, whose keys stay below 0xFFFFFFFE: its high 31 bits */
+fn mesh_sdf_content_table_key(key: u32) -> u32 {
+    return key >> 1u;
+}
+
+/** the key a slot is listed under: of no meaning for a slot listed nowhere */
+fn mesh_sdf_content_key(slot: u32) -> u32 {
+    return atomicLoad(&mesh_sdf_contents[slot * MESH_SDF_CONTENT_WORDS + 1u]);
+}
+
+fn mesh_sdf_content_find(key: u32) -> u32 {
+    let table_key = mesh_sdf_content_table_key(key);
+
+    var cursor = hash_table_atomic_start(&mesh_sdf_content_table, 0u, table_key);
+
+    // the probe limit bounds the records a find meets
+    for (var i = 0u; i < HASH_TABLE_PROBE_LIMIT; i++) {
+        let record = hash_table_atomic_find(&mesh_sdf_content_table, 0u, table_key, &cursor);
+
+        if (record == HASH_TABLE_MISS) {
+            break;
+        }
+
+        let slot = hash_table_atomic_value(&mesh_sdf_content_table, record);
+
+        if (mesh_sdf_content_key(slot) == key) {
+            return slot;
+        }
+    }
+
+    return MESH_SDF_NO_CONTENT;
+}
+
+fn mesh_sdf_content_list(slot: u32, key: u32) {
+    atomicStore(&mesh_sdf_contents[slot * MESH_SDF_CONTENT_WORDS + 1u], key);
+
+    // refused, the slot is held all the same and never found
+    hash_table_atomic_insert(&mesh_sdf_content_table, 0u, mesh_sdf_content_table_key(key), slot);
+}
+
+fn mesh_sdf_content_hold(slot: u32) {
+    atomicAdd(&mesh_sdf_contents[slot * MESH_SDF_CONTENT_WORDS], 1u);
+}
+
+fn mesh_sdf_content_release(slot: u32) -> bool {
+    if (atomicSub(&mesh_sdf_contents[slot * MESH_SDF_CONTENT_WORDS], 1u) != 1u) {
+        return false;
+    }
+
+    // the slot's record, when it has one: no other record names it
+    let table_key = mesh_sdf_content_table_key(mesh_sdf_content_key(slot));
+
+    var cursor = hash_table_atomic_start(&mesh_sdf_content_table, 0u, table_key);
+
+    for (var i = 0u; i < HASH_TABLE_PROBE_LIMIT; i++) {
+        let record = hash_table_atomic_find(&mesh_sdf_content_table, 0u, table_key, &cursor);
+
+        if (record == HASH_TABLE_MISS) {
+            break;
+        }
+
+        if (hash_table_atomic_value(&mesh_sdf_content_table, record) == slot) {
+            hash_table_atomic_remove(&mesh_sdf_content_table, 0u, record);
+            break;
+        }
+    }
+
+    return true;
+}
+`, [
+        chunk_hash_table_atomic,
+        chunk_mesh_sdf_bake,
+    ]);
+
+chunk_mesh_sdf_contents.requireResource(MESH_SDF_CONTENTS_RESOURCE);
+chunk_mesh_sdf_contents.requireResource(MESH_SDF_CONTENT_TABLE_RESOURCE);

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_classify.d.ts

@@ -18,7 +18,7 @@ export const MESH_SDF_CLASSIFY_SETTINGS: WebGPUStruct;
  * whichever side of the surface it is on, since the vote casts no ray where the surface is not within
  * the band (UE 5.4's). Otherwise the brick goes onto the ring as `(geometry, generation, brick, 0)`,
  * for evaluate to settle. Either way its entry starts EMPTY, which is what a freed range must find in
- * an entry never stored.
+ * an entry never stored, and its number `MESH_SDF_UNNUMBERED`, until evaluate gives it a slot.
  *
  * A dropped brick is settled here: it counts its geometry's pending word down, and the last brick of
  * a geometry to settle logs it complete.