@aardworx/wombat.rendering 0.19.23 → 0.19.25

package/src/runtime/heapScene/pools.ts

@@ -3,11 +3,11 @@
 // classes here are tightly interleaved:
 //
 //   AttributeArena    — byte-bump over a STORAGE GrowBuffer
-//   IndexAllocator    — element-bump over an INDEX GrowBuffer
+//   (index arrays are AttributeArena regions too — VS storage-decodes them)
 //   DrawHeap          — slot-indexed allocator over a STORAGE GrowBuffer
 //                       (one slot per RO drawHeader)
 //   UniformPool       — aval-keyed refcounted alloc on top of AttributeArena
-//   IndexPool         — aval-keyed refcounted alloc on top of IndexAllocator,
+//   IndexPool         — aval-keyed refcounted alloc on top of AttributeArena,
 //                       with value-tuple dedup for constant avals (§5b).
 //
 // Plus the per-allocation header constants used by all of them and
@@ -21,8 +21,7 @@ import type { BufferView } from "../../core/bufferView.js";
 import type { HostBufferSource } from "../../core/buffer.js";
 import { GrowBuffer, ALIGN16, DEFAULT_MAX_BUFFER_BYTES } from "./growBuffer.js";
 import { Freelist } from "./freelist.js";
-import { DirtyRanges } from "./dirtyRanges.js";
-import { ChunkedAttributeArena, ChunkedIndexAllocator } from "./chunkedArena.js";
+import { ChunkedAttributeArena } from "./chunkedArena.js";
 
 // ─── Debug toggles ─────────────────────────────────────────────────────
 
@@ -43,8 +42,17 @@ const DEBUG_ALLOC_OVERLAP: boolean =
 export const ALLOC_HEADER_BYTES   = 8;
 export const ALLOC_HEADER_PAD_TO  = 16;
 
-/** Encoding-tag enum (low 16 bits of typeId). */
+/** Default fragmentation-waste floor (bytes) below which `AttributeArena`
+ *  declines to compact — relocating a few KB isn't worth a GPU copy +
+ *  ref re-seat. Matches Aardvark's 4 MiB compaction floor. */
+export const COMPACTION_WASTE_FLOOR_BYTES = 4 * 1024 * 1024;
+
+/** Encoding-tag enum (low 16 bits of typeId). The generated VS decode
+ *  branches on this per field (2-arm select; header word 0 shares the
+ *  cache line with the broadcast length in word 1). */
 export const ENC_V3F_TIGHT = 1; // tightly-packed array of vec3<f32> (12 B/elt)
+export const ENC_OCT32     = 2; // oct-packed unit vectors, 2×unorm16 in one u32 (4 B/elt)
+export const ENC_C4B       = 3; // RGBA8-unorm colors, one u32/elt → unpack4x8unorm (4 B/elt)
 
 /** Semantic-tag enum (high 16 bits of typeId). Optional metadata —
  *  the shader doesn't branch on this. */
@@ -61,7 +69,10 @@ export const SEM_NORMALS   = 2;
  */
 interface PoolEntry {
   readonly chunkIdx: number;
-  readonly ref: number;
+  /** Byte offset within the chunk's GPUBuffer. Mutated by
+   *  `UniformPool.remapRefs` when a waste-triggered arena compaction
+   *  relocates the allocation. */
+  ref: number;
   readonly dataBytes: number;
   readonly typeId: number;
   readonly pack: (val: unknown, dst: Float32Array, off: number) => void;
@@ -77,34 +88,107 @@ interface PoolEntry {
  * an aval still share the underlying allocation.
  */
 export class UniformPool {
-  private readonly byAval = new Map<aval<unknown>, Map<number, PoolEntry>>();
+  /** Value is a single `PoolEntry` (the overwhelmingly common case —
+   *  one aval, one chunk) or a `Map<chunkIdx, PoolEntry>` once the
+   *  same aval is allocated in a second chunk. The flat form saves a
+   *  whole inner `Map` per aval, which at heap scale (several avals
+   *  per draw) is megabytes of JS heap. */
+  private readonly byAval = new Map<aval<unknown>, PoolEntry | Map<number, PoolEntry>>();
+
+  private getEntry(av: aval<unknown>, chunkIdx: number): PoolEntry | undefined {
+    const v = this.byAval.get(av);
+    if (v === undefined) return undefined;
+    if (v instanceof Map) return v.get(chunkIdx);
+    return v.chunkIdx === chunkIdx ? v : undefined;
+  }
+  private setEntry(av: aval<unknown>, e: PoolEntry): void {
+    const v = this.byAval.get(av);
+    if (v === undefined) { this.byAval.set(av, e); return; }
+    if (v instanceof Map) { v.set(e.chunkIdx, e); return; }
+    const m = new Map<number, PoolEntry>();
+    m.set(v.chunkIdx, v);
+    m.set(e.chunkIdx, e);
+    this.byAval.set(av, m);
+  }
+  private deleteEntry(av: aval<unknown>, chunkIdx: number): void {
+    const v = this.byAval.get(av);
+    if (v === undefined) return;
+    if (v instanceof Map) {
+      v.delete(chunkIdx);
+      if (v.size === 1) {
+        this.byAval.set(av, v.values().next().value as PoolEntry);
+      } else if (v.size === 0) this.byAval.delete(av);
+      return;
+    }
+    if (v.chunkIdx === chunkIdx) this.byAval.delete(av);
+  }
+  private *entriesOf(av: aval<unknown>): IterableIterator<PoolEntry> {
+    const v = this.byAval.get(av);
+    if (v === undefined) return;
+    if (v instanceof Map) yield* v.values();
+    else yield v;
+  }
 
   has(av: aval<unknown>, chunkIdx: number): boolean {
-    return this.byAval.get(av)?.has(chunkIdx) ?? false;
+    return this.getEntry(av, chunkIdx) !== undefined;
   }
   /** True when the pool holds at least one entry for `av` in any
    *  chunk. Used by the scene's `inputChanged` dispatch to decide
    *  whether a marking aval is one of our tracked allocations. */
   hasAny(av: aval<unknown>): boolean {
-    return (this.byAval.get(av)?.size ?? 0) > 0;
+    const v = this.byAval.get(av);
+    return v !== undefined && (!(v instanceof Map) || v.size > 0);
   }
   entry(av: aval<unknown>, chunkIdx: number): PoolEntry | undefined {
-    return this.byAval.get(av)?.get(chunkIdx);
+    return this.getEntry(av, chunkIdx);
   }
   /** First chunk this aval is allocated in, if any. Used by `addRO`
    *  to prefer co-locating a new RO with its already-allocated
    *  shared inputs (avoids unnecessary duplication). */
   firstChunkContaining(av: aval<unknown>): number | undefined {
-    const byChunk = this.byAval.get(av);
-    if (byChunk === undefined || byChunk.size === 0) return undefined;
-    return byChunk.keys().next().value as number;
+    for (const e of this.entriesOf(av)) return e.chunkIdx;
+    return undefined;
+  }
+
+  /**
+   * Unkeyed allocation for slots the GPU overwrites every dirty frame
+   * (§7 derived-uniform outputs). No aval, no `byAval` entry, no
+   * sharing — the caller keeps the ref in its drawHeader cell (which
+   * the compaction remap re-seats) and frees it with `releaseRaw`.
+   * Avoids a placeholder `AVal.constant` + pool entry per draw.
+   */
+  allocRaw(
+    arena: ChunkedAttributeArena,
+    chunkIdx: number,
+    dataBytes: number,
+    typeId: number,
+    length: number,
+  ): number {
+    const r = arena.alloc(dataBytes, chunkIdx);
+    if (r.chunkIdx !== chunkIdx) {
+      throw new Error(
+        `UniformPool.allocRaw: allocator spilled from chunk ${chunkIdx} to chunk ${r.chunkIdx} ` +
+        `(${dataBytes} bytes). Caller's bucket is bound to chunk ${chunkIdx}.`,
+      );
+    }
+    const allocBytes = ALIGN16(ALLOC_HEADER_PAD_TO + dataBytes);
+    const buf = new ArrayBuffer(allocBytes);
+    const u32 = new Uint32Array(buf);
+    u32[0] = typeId;
+    u32[1] = length;
+    u32[2] = length > 0 ? Math.floor(dataBytes / length) : 0;
+    arena.write(chunkIdx, r.off, new Uint8Array(buf));
+    return r.off;
+  }
+  releaseRaw(arena: ChunkedAttributeArena, chunkIdx: number, ref: number, dataBytes: number): void {
+    arena.release(chunkIdx, ref, dataBytes);
   }
 
   /**
    * Acquire (or share) an allocation for `aval` in `chunkIdx`.
    * Returns the byte offset within that chunk's GPUBuffer. If a
    * fresh allocation is made, the value is packed + uploaded
-   * immediately into the chunk's CPU shadow.
+   * immediately to the chunk's GPU buffer (mirror-less).
    */
   acquire(
     device: GPUDevice,
@@ -117,8 +201,7 @@ export class UniformPool {
     length: number,
     pack: (val: unknown, dst: Float32Array, off: number) => void,
   ): number {
-    let byChunk = this.byAval.get(av);
-    const existing = byChunk?.get(chunkIdx);
+    const existing = this.getEntry(av, chunkIdx);
     if (existing !== undefined) {
       existing.refcount++;
       return existing.ref;
@@ -152,19 +235,14 @@ export class UniformPool {
     pack(value, f32, ALLOC_HEADER_PAD_TO / 4);
     arena.write(finalChunk, r.off, new Uint8Array(buf));
     void device;
-    if (byChunk === undefined) {
-      byChunk = new Map();
-      this.byAval.set(av, byChunk);
-    }
-    byChunk.set(finalChunk, {
+    this.setEntry(av, {
       chunkIdx: finalChunk, ref: r.off, dataBytes, typeId, pack, refcount: 1,
     });
     return r.off;
   }
 
   release(arena: ChunkedAttributeArena, av: aval<unknown>, chunkIdx: number): void {
-    const byChunk = this.byAval.get(av);
-    const e = byChunk?.get(chunkIdx);
+    const e = this.getEntry(av, chunkIdx);
     if (e === undefined) return;
     e.refcount--;
     if (e.refcount > 0) return;
@@ -179,8 +257,20 @@ export class UniformPool {
     // 16 B inside the previous alloc → overlapping allocations →
     // garbage `typeId`/`length` in the attribute header.
     arena.release(e.chunkIdx, e.ref, e.dataBytes);
-    byChunk!.delete(chunkIdx);
-    if (byChunk!.size === 0) this.byAval.delete(av);
+    this.deleteEntry(av, chunkIdx);
+  }
+
+  /** Re-seat every entry's `ref` in `chunkIdx` after a waste-triggered
+   *  arena compaction relocated allocations. `remap` maps OLD→NEW byte
+   *  offset. Entries whose ref didn't move are left as-is. O(entries). */
+  remapRefs(chunkIdx: number, remap: ReadonlyMap<number, number>): void {
+    if (remap.size === 0) return;
+    for (const v of this.byAval.values()) {
+      const e = v instanceof Map ? v.get(chunkIdx) : (v.chunkIdx === chunkIdx ? v : undefined);
+      if (e === undefined) continue;
+      const nn = remap.get(e.ref);
+      if (nn !== undefined) e.ref = nn;
+    }
   }
 
   /** Re-pack one entry's data region into every chunk that holds
@@ -193,10 +283,8 @@ export class UniformPool {
     av: aval<unknown>,
     val: unknown,
   ): void {
-    const byChunk = this.byAval.get(av);
-    if (byChunk === undefined) return;
     let dst: Float32Array | undefined;
-    for (const e of byChunk.values()) {
+    for (const e of this.entriesOf(av)) {
       if (dst === undefined || dst.length !== e.dataBytes / 4) {
         dst = new Float32Array(e.dataBytes / 4);
       }
@@ -212,10 +300,8 @@ export class UniformPool {
   /** Total bytes touched by `repack` for this aval — sum across
    *  chunks. Used by the dirty-bytes diagnostics. */
   totalDataBytes(av: aval<unknown>): number {
-    const byChunk = this.byAval.get(av);
-    if (byChunk === undefined) return 0;
     let s = 0;
-    for (const e of byChunk.values()) s += e.dataBytes;
+    for (const e of this.entriesOf(av)) s += e.dataBytes;
     return s;
   }
 }
@@ -223,7 +309,7 @@ export class UniformPool {
 // ─── IndexPool ─────────────────────────────────────────────────────────
 
 /**
- * Aval-keyed pool over the `IndexAllocator`. Two draws referencing
+ * Aval-keyed pool over the (attribute) arena. Two draws referencing
  * the same `Uint32Array` (or aval thereof) share an index range —
  * 19K instanced clones of the same mesh share one allocation, one
  * upload.
@@ -236,11 +322,40 @@ export class UniformPool {
  */
 export class IndexPool {
   /** Per-aval, per-chunk bookkeeping. Same aval acquired in two
-   *  chunks gets two entries (accepted §3 duplication). */
+   *  chunks gets two entries (accepted §3 duplication). Value is a
+   *  single binding (common case) or a Map<chunkIdx, binding> once
+   *  the aval spans chunks — same flat-form saving as UniformPool. */
   private readonly byAval = new Map<
     aval<Uint32Array>,
-    Map<number, { entry: IndexPoolEntry; perAvalCount: number }>
+    IndexBinding | Map<number, IndexBinding>
   >();
+
+  private getBinding(av: aval<Uint32Array>, chunkIdx: number): IndexBinding | undefined {
+    const v = this.byAval.get(av);
+    if (v === undefined) return undefined;
+    if (v instanceof Map) return v.get(chunkIdx);
+    return v.entry.chunkIdx === chunkIdx ? v : undefined;
+  }
+  private setBinding(av: aval<Uint32Array>, b: IndexBinding): void {
+    const v = this.byAval.get(av);
+    if (v === undefined) { this.byAval.set(av, b); return; }
+    if (v instanceof Map) { v.set(b.entry.chunkIdx, b); return; }
+    const m = new Map<number, IndexBinding>();
+    m.set(v.entry.chunkIdx, v);
+    m.set(b.entry.chunkIdx, b);
+    this.byAval.set(av, m);
+  }
+  private deleteBinding(av: aval<Uint32Array>, chunkIdx: number): void {
+    const v = this.byAval.get(av);
+    if (v === undefined) return;
+    if (v instanceof Map) {
+      v.delete(chunkIdx);
+      if (v.size === 1) this.byAval.set(av, v.values().next().value as IndexBinding);
+      else if (v.size === 0) this.byAval.delete(av);
+      return;
+    }
+    if (v.entry.chunkIdx === chunkIdx) this.byAval.delete(av);
+  }
   /** Per-chunk constant-aval value-dedup (§5b in-chunk). */
   private readonly byValueKey = new Map<string, IndexPoolEntry>();
   private readonly bufferIds = new WeakMap<ArrayBufferLike, number>();
@@ -255,20 +370,20 @@ export class IndexPool {
   }
 
   firstChunkContaining(av: aval<Uint32Array>): number | undefined {
-    const byChunk = this.byAval.get(av);
-    if (byChunk === undefined || byChunk.size === 0) return undefined;
-    return byChunk.keys().next().value as number;
+    const v = this.byAval.get(av);
+    if (v === undefined) return undefined;
+    if (v instanceof Map) return v.size > 0 ? (v.keys().next().value as number) : undefined;
+    return v.entry.chunkIdx;
   }
 
   acquire(
     device: GPUDevice,
-    indices: ChunkedIndexAllocator,
+    arena: ChunkedAttributeArena,
     av: aval<Uint32Array>,
     chunkIdx: number,
     arr: Uint32Array,
   ): { chunkIdx: number; firstIndex: number; count: number } {
-    let byChunk = this.byAval.get(av);
-    const bound = byChunk?.get(chunkIdx);
+    const bound = this.getBinding(av, chunkIdx);
     if (bound !== undefined) {
       bound.perAvalCount++;
       bound.entry.totalRefcount++;
@@ -278,59 +393,92 @@ export class IndexPool {
     if (av.isConstant) {
       // Value-dedup is scoped per chunk — two constant avals in the
       // same chunk collapse to one allocation; two constant avals in
-      // DIFFERENT chunks each get their own (we can't share across
-      // chunks since the index range lives in the chunk's GPUBuffer).
+      // DIFFERENT chunks each get their own (the index range lives in
+      // the chunk's GPUBuffer).
       valueKey = `${chunkIdx}:${this.bufferIdOf(arr.buffer)}:${arr.byteOffset}:${arr.byteLength}`;
       const shared = this.byValueKey.get(valueKey);
       if (shared !== undefined) {
         shared.totalRefcount++;
-        if (byChunk === undefined) {
-          byChunk = new Map();
-          this.byAval.set(av, byChunk);
-        }
-        byChunk.set(chunkIdx, { entry: shared, perAvalCount: 1 });
+        this.setBinding(av, { entry: shared, perAvalCount: 1 });
         return { chunkIdx: shared.chunkIdx, firstIndex: shared.firstIndex, count: shared.count };
       }
     }
-    const r = indices.alloc(arr.length, chunkIdx);
-    indices.write(
-      r.chunkIdx, r.off * 4,
-      new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength),
-    );
+    // Index data lives in the SAME arena as attributes/uniforms (the heap VS
+    // storage-decodes indices — `indexStorage[_indexStart + i]` — so they need
+    // no separate index buffer). Allocate a normal header+data region; the
+    // raw u32 indices sit at `ref + 16`, so the element offset the drawTable
+    // stores is `(ref + 16) >> 2`. The header is unread by index gathers but
+    // kept for a uniform region layout (and so compaction treats it like any
+    // other region).
+    const byteLen = arr.byteLength;
+    const r = arena.alloc(byteLen, chunkIdx);
+    const dataOff = r.off + ALLOC_HEADER_PAD_TO;
+    const hdr = new Uint32Array([0, arr.length, 4, 0]); // (typeId, length, strideBytes, pad)
+    arena.write(r.chunkIdx, r.off, new Uint8Array(hdr.buffer));
+    arena.write(r.chunkIdx, dataOff, new Uint8Array(arr.buffer, arr.byteOffset, byteLen));
     void device;
+    const firstIndex = dataOff >>> 2;
     const entry: IndexPoolEntry = {
-      chunkIdx: r.chunkIdx, firstIndex: r.off, count: arr.length,
+      chunkIdx: r.chunkIdx, ref: r.off, firstIndex, count: arr.length,
       totalRefcount: 1, valueKey,
     };
-    if (byChunk === undefined) {
-      byChunk = new Map();
-      this.byAval.set(av, byChunk);
-    }
-    byChunk.set(r.chunkIdx, { entry, perAvalCount: 1 });
+    this.setBinding(av, { entry, perAvalCount: 1 });
     if (valueKey !== undefined) this.byValueKey.set(valueKey, entry);
-    return { chunkIdx: r.chunkIdx, firstIndex: r.off, count: arr.length };
+    return { chunkIdx: r.chunkIdx, firstIndex, count: arr.length };
+  }
+
+  /** The allocation's byte header offset (`ref`) of `av`'s entry in `chunkIdx`,
+   *  or undefined if not allocated there. The heap compaction pass looks the
+   *  region up in the arena remap by this ref to compute the draw's new
+   *  `_indexStart`. */
+  baseFor(av: aval<Uint32Array>, chunkIdx: number): number | undefined {
+    return this.getBinding(av, chunkIdx)?.entry.ref;
+  }
+
+  /** Re-seat every entry after a compaction relocated its region. `remap` maps
+   *  OLD→NEW byte header offset (`ref`); `firstIndex` is recomputed from the
+   *  new ref. Entries are shared by value-dedup, so each is visited once. */
+  remapRefs(chunkIdx: number, remap: ReadonlyMap<number, number>): void {
+    if (remap.size === 0) return;
+    const seen = new Set<IndexPoolEntry>();
+    for (const v of this.byAval.values()) {
+      const bound = v instanceof Map ? v.get(chunkIdx) : (v.entry.chunkIdx === chunkIdx ? v : undefined);
+      if (bound === undefined || seen.has(bound.entry)) continue;
+      seen.add(bound.entry);
+      const nn = remap.get(bound.entry.ref);
+      if (nn !== undefined) {
+        bound.entry.ref = nn;
+        bound.entry.firstIndex = (nn + ALLOC_HEADER_PAD_TO) >>> 2;
+      }
+    }
   }
 
-  release(indices: ChunkedIndexAllocator, av: aval<Uint32Array>, chunkIdx: number): void {
-    const byChunk = this.byAval.get(av);
-    const bound = byChunk?.get(chunkIdx);
+  release(arena: ChunkedAttributeArena, av: aval<Uint32Array>, chunkIdx: number): void {
+    const bound = this.getBinding(av, chunkIdx);
     if (bound === undefined) return;
     bound.perAvalCount--;
     bound.entry.totalRefcount--;
-    if (bound.perAvalCount === 0) {
-      byChunk!.delete(chunkIdx);
-      if (byChunk!.size === 0) this.byAval.delete(av);
-    }
+    if (bound.perAvalCount === 0) this.deleteBinding(av, chunkIdx);
     if (bound.entry.totalRefcount > 0) return;
-    indices.release(bound.entry.chunkIdx, bound.entry.firstIndex, bound.entry.count);
+    arena.release(bound.entry.chunkIdx, bound.entry.ref, bound.entry.count * 4);
     if (bound.entry.valueKey !== undefined) {
       this.byValueKey.delete(bound.entry.valueKey);
     }
   }
 }
 
+interface IndexBinding {
+  entry: IndexPoolEntry;
+  perAvalCount: number;
+}
+
 interface IndexPoolEntry {
   chunkIdx: number;
+  /** Byte header offset of the region in the (attribute) arena — the unit the
+   *  compaction remap is keyed by. */
+  ref: number;
+  /** Element (u32) offset to the index DATA (`(ref + 16) >> 2`) — the value
+   *  the drawTable's `_indexStart` stores. */
   firstIndex: number;
   count: number;
   totalRefcount: number;
@@ -387,52 +535,40 @@ export class DrawHeap {
  */
 export class AttributeArena {
   private cursor = 0;
+  /** Sum of `allocBytes` over all live allocations. `cursor - liveBytes`
+   *  is the fragmentation waste below the high-water mark — what
+   *  `compact()` reclaims. */
+  private liveBytes = 0;
   private readonly freelist = new Freelist();
   /** DEBUG: tracks every live allocation by start byte → size. Set
    *  on alloc, cleared on release. Used by `assertNoOverlap()` to
    *  detect allocator returning overlapping ranges. Enabled in
    *  development; cheap (one Map insert/delete per alloc). */
   private readonly liveAllocs = new Map<number, number>();
-  /** CPU shadow of the entire GPU buffer; writes go here first then
-   *  flush() emits one writeBuffer per dirty contiguous range. A
-   *  single min..max span would re-upload nearly the whole arena on
-   *  scattered edits — see dirtyRanges.ts. */
-  private shadow: Uint8Array;
-  private readonly dirty = new DirtyRanges();
-  constructor(private readonly buf: GrowBuffer) {
-    this.shadow = new Uint8Array(buf.capacity);
-    buf.onResize(() => {
-      const grown = new Uint8Array(buf.capacity);
-      grown.set(this.shadow);
-      this.shadow = grown;
-    });
-  }
+  // MIRROR-LESS: no CPU shadow of the arena. Writes go straight to
+  // `queue.writeBuffer` (queue-ordered with submits, so they serialize
+  // correctly against GrowBuffer's grow-copy and the compaction bounce —
+  // both of which preserve contents GPU-side). This halves the heap's
+  // host-memory footprint: the source-of-truth for values is the user's
+  // avals (they must stay alive — changeability is the point), and the
+  // GPU buffer is the render copy; a third full-size CPU mirror bought
+  // only dirty-range batching + debug readback comparisons.
+  constructor(
+    private readonly device: GPUDevice,
+    private readonly buf: GrowBuffer,
+  ) {}
   get buffer(): GPUBuffer { return this.buf.buffer; }
   get capacity(): number { return this.buf.capacity; }
   get usedBytes(): number { return this.cursor; }
-  /** Read 4 u32s from the CPU shadow starting at byte `off`. Used by
-   *  the validator to compare against the GPU's read-back values:
-   *  if CPU shadow is correct but GPU shows garbage → the corruption
-   *  came from a GPU-side write (a compute kernel writing to a wrong
-   *  byte). If both differ from what pool.acquire wrote → CPU-side
-   *  write path is the culprit. */
-  peekShadowU32(off: number, count: number): Uint32Array {
-    return new Uint32Array(this.shadow.buffer, this.shadow.byteOffset + off, count);
-  }
   write(dst: number, data: Uint8Array): void {
-    this.shadow.set(data, dst);
-    this.dirty.add(dst, dst + data.byteLength);
-  }
-  flush(device: GPUDevice): void {
-    if (this.dirty.isEmpty) return;
-    this.dirty.drain((start, end) => {
-      device.queue.writeBuffer(
-        this.buf.buffer, start,
-        this.shadow.buffer, this.shadow.byteOffset + start,
-        end - start,
-      );
-    });
+    // Immediate upload; Chrome's queue staging does the batching. The
+    // write targets the CURRENT buffer handle — a later grow copies it
+    // forward (queue-ordered), so ordering stays correct.
+    this.device.queue.writeBuffer(this.buf.buffer, dst, data as BufferSource);
   }
+  /** No-op — kept for call-site compatibility (mirror-less arena uploads
+   *  in `write`). */
+  flush(_device: GPUDevice): void {}
   /**
    * Allocate space for one attribute. Returns the byte ref (offset
    * to the header — data lives at ref + 16).
@@ -446,6 +582,7 @@ export class AttributeArena {
     const reused = this.freelist.alloc(allocBytes);
     if (reused !== undefined) {
       this.recordAlloc(reused, allocBytes, "freelist");
+      this.liveBytes += allocBytes;
       return reused;
     }
     const next = this.cursor + allocBytes;
@@ -455,6 +592,7 @@ export class AttributeArena {
     this.buf.setUsed(next);
     const ref = next - allocBytes;
     this.recordAlloc(ref, allocBytes, "bump");
+    this.liveBytes += allocBytes;
     return ref;
   }
   alloc(dataBytes: number): number {
@@ -484,6 +622,7 @@ export class AttributeArena {
       );
     }
     this.liveAllocs.delete(ref);
+    this.liveBytes -= allocBytes;
     this.freelist.release(ref, allocBytes);
     // §5: shrink the bump cursor back if release exposed a free
     // tail touching it (cascading — `freelist.release` may have
@@ -514,111 +653,92 @@ export class AttributeArena {
     }
     this.liveAllocs.set(off, size);
   }
-  onResize(cb: () => void): IDisposable { return this.buf.onResize(cb); }
-  destroy(): void { this.buf.destroy(); }
-}
-
-// ─── IndexAllocator (element-bump) ─────────────────────────────────────
+  /** Bytes the bump cursor can still grow into before hitting the chunk cap
+   *  (ignores freelist holes — a conservative lower bound on free space, used
+   *  by group placement to decide whether a draw's group fits here). */
+  get bumpHeadroom(): number { return this.buf.maxCapacity - this.cursor; }
+  /** Live bytes (sum of all live allocations, header+pad included). */
+  get liveByteCount(): number { return this.liveBytes; }
+  /** Fragmentation waste below the high-water mark: free bytes the tail-
+   *  reclaim couldn't recover because they sit between live allocations. */
+  get wasteBytes(): number { return this.cursor - this.liveBytes; }
 
-/**
- * Element-bump allocator over an index GrowBuffer (units = u32). Each
- * draw's index range is allocated as one block; on release the block
- * is returned to a Freelist and can be reused best-fit.
- */
-export class IndexAllocator {
-  private cursor = 0;     // in u32s, not bytes
-  private readonly freelist = new Freelist();
-  /** DEBUG: live index allocations tracked by start element. */
-  private readonly liveAllocs = new Map<number, number>();
-  private shadow: Uint8Array;
-  private readonly dirty = new DirtyRanges();
-  constructor(private readonly buf: GrowBuffer) {
-    this.shadow = new Uint8Array(buf.capacity);
-    buf.onResize(() => {
-      const grown = new Uint8Array(buf.capacity);
-      grown.set(this.shadow);
-      this.shadow = grown;
-    });
-  }
-  get buffer(): GPUBuffer { return this.buf.buffer; }
-  get usedElements(): number { return this.cursor; }
-  write(dstByteOffset: number, data: Uint8Array): void {
-    this.shadow.set(data, dstByteOffset);
-    this.dirty.add(dstByteOffset, dstByteOffset + data.byteLength);
-  }
-  flush(device: GPUDevice): void {
-    if (this.dirty.isEmpty) return;
-    this.dirty.drain((start, end) => {
-      device.queue.writeBuffer(
-        this.buf.buffer, start,
-        this.shadow.buffer, this.shadow.byteOffset + start,
-        end - start,
-      );
-    });
-  }
-  /** Non-throwing alloc — returns `undefined` when the request
-   *  would exceed the underlying GrowBuffer's `maxCapacity` cap.
-   *  Used by `ChunkedIndexAllocator` to probe before spilling. */
-  tryAlloc(elements: number): number | undefined {
-    const reused = this.freelist.alloc(elements);
-    if (reused !== undefined) {
-      this.recordAlloc(reused, elements, "freelist");
-      return reused;
+  /**
+   * Waste-triggered compaction. Relocates live allocations to the front of
+   * the buffer, eliminating the high-water ratchet that exact-size freelist
+   * reuse alone can't fix (a drifting allocation-size distribution never
+   * reuses its holes and grows toward the high-water forever).
+   *
+   * The byte move happens GPU-side via `copyBufferToBuffer` through a scratch
+   * buffer — no CPU→GPU re-upload — and is mirrored into the CPU shadow so it
+   * stays authoritative for future partial writes. Same-buffer copies can't
+   * overlap, hence the scratch round-trip.
+   *
+   * Returns a map of OLD→NEW byte offset for every allocation that moved; the
+   * caller must re-seat every cached ref (drawHeader cells, uniform-pool
+   * entries, derived-uniform handles, partition master refs). Returns an
+   * empty map when it declines to compact (waste below `wasteFloorBytes` or
+   * less than half the extent wasted).
+   *
+   * Precondition: the arena's pending shadow writes must already be flushed
+   * to the GPU buffer (the GPU copy reads the live buffer). O(live).
+   */
+  compact(device: GPUDevice, wasteFloorBytes: number, force = false): Map<number, number> {
+    const waste = this.cursor - this.liveBytes;
+    if (!force && (this.liveBytes * 2 >= this.cursor || waste < wasteFloorBytes)) {
+      return new Map();
     }
-    const nextElts = this.cursor + elements;
-    if (nextElts * 4 > this.buf.maxCapacity) return undefined;
-    this.cursor = nextElts;
-    this.buf.ensureCapacity(nextElts * 4);
-    this.buf.setUsed(nextElts * 4);
-    const off = nextElts - elements;
-    this.recordAlloc(off, elements, "bump");
-    return off;
-  }
-  private recordAlloc(off: number, size: number, source: string): void {
-    if (DEBUG_ALLOC_OVERLAP) {
-      for (const [liveOff, liveSize] of this.liveAllocs) {
-        if (off < liveOff + liveSize && liveOff < off + size) {
-          throw new Error(
-            `IndexAllocator.tryAlloc(${source}): returned [${off},${off + size}) ` +
-            `(size=${size}) overlaps live alloc at [${liveOff},${liveOff + liveSize}) ` +
-            `(size=${liveSize}). Index allocator is handing out shared memory!`,
-          );
-        }
+    // Live allocations sorted by current offset.
+    const live = [...this.liveAllocs.entries()].sort((a, b) => a[0] - b[0]);
+    // Assign packed offsets (bump from 0); build the OLD→NEW remap and the
+    // source-contiguous runs to copy. A run is a maximal set of live blocks
+    // adjacent in the source; under the bump it lands dest-contiguous too, so
+    // the compacted prefix [0, newExtent) is fully covered by the runs.
+    const remap = new Map<number, number>();
+    const runs: { srcStart: number; dstStart: number; len: number }[] = [];
+    let w = 0;
+    let cur: { srcStart: number; dstStart: number; len: number } | undefined;
+    for (const [off, size] of live) {
+      if (w !== off) remap.set(off, w);
+      if (cur !== undefined && off === cur.srcStart + cur.len) {
+        cur.len += size;
+      } else {
+        cur = { srcStart: off, dstStart: w, len: size };
+        runs.push(cur);
       }
+      w += size;
     }
-    this.liveAllocs.set(off, size);
-  }
-  alloc(elements: number): number {
-    const r = this.tryAlloc(elements);
-    if (r === undefined) {
-      throw new Error(`IndexAllocator: allocation of ${elements} elements exceeds chunk cap`);
-    }
-    return r;
-  }
-  release(off: number, elements: number): void {
-    const tracked = this.liveAllocs.get(off);
-    if (tracked === undefined) {
-      throw new Error(
-        `IndexAllocator.release: off=${off} (elements=${elements}) was not in ` +
-        `liveAllocs — double-free or release for an alloc that never happened. ` +
-        `Live alloc count=${this.liveAllocs.size}.`,
-      );
-    }
-    if (tracked !== elements) {
-      throw new Error(
-        `IndexAllocator.release: size mismatch at off=${off} — recorded=${tracked} ` +
-        `but release elements=${elements}. Will corrupt the freelist.`,
-      );
-    }
-    this.liveAllocs.delete(off);
-    this.freelist.release(off, elements);
-    while (true) {
-      const top = this.freelist.takeBlockEndingAt(this.cursor);
-      if (top === undefined) break;
-      this.cursor = top.off;
-      this.buf.setUsed(this.cursor * 4);
+    const newExtent = w;
+    if (remap.size === 0) return remap; // already tight
+
+    // GPU move: arena → scratch (compacted), then scratch → arena[0,newExtent).
+    // Both copies are between distinct buffers, so no overlap constraint.
+    const scratch = device.createBuffer({
+      label: "AttributeArena/compact-scratch",
+      size: newExtent,
+      usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+    });
+    const enc = device.createCommandEncoder({ label: "AttributeArena/compact" });
+    for (const r of runs) {
+      enc.copyBufferToBuffer(this.buf.buffer, r.srcStart, scratch, r.dstStart, r.len);
     }
+    enc.copyBufferToBuffer(scratch, 0, this.buf.buffer, 0, newExtent);
+    device.queue.submit([enc.finish()]);
+    scratch.destroy();
+
+    // Rebuild allocator bookkeeping: live allocs at their new offsets, no free
+    // blocks (everything is now contiguous), cursor at the new high-water.
+    // (Mirror-less: the GPU bounce above IS the move — nothing else to sync.)
+    const moved: Array<[number, number]> = [];
+    for (const [off, size] of live) moved.push([remap.get(off) ?? off, size]);
+    this.liveAllocs.clear();
+    for (const [o, s] of moved) this.liveAllocs.set(o, s);
+    this.freelist.clear();
+    this.cursor = newExtent;
+    this.buf.setUsed(newExtent);
+    return remap;
   }
+
   onResize(cb: () => void): IDisposable { return this.buf.onResize(cb); }
   destroy(): void { this.buf.destroy(); }
 }
@@ -626,17 +746,18 @@ export class IndexAllocator {
 // ─── ArenaState + helpers ──────────────────────────────────────────────
 
 /**
- * Global arena state: attribute / uniform data lives in `attrs`
- * (multi-typed-view storage); indices live in `indices` (separate
- * INDEX-usage buffer). Both are chunked: each chunk owns a separate
- * GPUBuffer + Freelist. Refs that downstream code stores are byte
- * offsets within a chunk; the chunk identity is carried alongside
- * (via bucket.chunkIdx in heapScene) and made implicit at draw
- * time by which chunk's bind group is active.
+ * Global arena state: ONE chunked arena holds all heap data (per-draw
+ * uniforms, attributes, and index arrays) as multi-typed views over the same
+ * buffers. Each chunk owns a separate GPUBuffer + Freelist. Refs that
+ * downstream code stores are byte offsets within a chunk; the chunk identity
+ * is carried alongside (via `bucket.chunkIdx`) and made implicit at draw time
+ * by which chunk's bind group is active.
  */
 export interface ArenaState {
-  readonly attrs:    ChunkedAttributeArena;
-  readonly indices:  ChunkedIndexAllocator;
+  /** The single arena holding ALL heap data — per-draw uniforms, vertex /
+   *  instance attributes, AND index arrays (the heap VS storage-decodes
+   *  indices, so they need no separate index buffer). */
+  readonly attrs: ChunkedAttributeArena;
 }
 
 export function buildArenaState(
@@ -655,19 +776,20 @@ export function buildArenaState(
   // exercise multi-chunk routing).
   const adapterCap = device.limits.maxStorageBufferBindingSize;
   const cap = maxChunkBytes ?? Math.min(adapterCap, DEFAULT_MAX_BUFFER_BYTES);
+  void idxBytesHint; void idxExtraUsage; // legacy params (separate index buffer removed)
+  // Clamp the pre-size hint to the per-chunk cap: GrowBuffer RAISES its max
+  // to fit a larger initial size, which would mint an oversized page (and
+  // §7 derived-record handles cap page offsets at 2^29 B = 512 MB). A
+  // multi-page scene simply pre-sizes each page at the cap as it opens.
   const attrs = new ChunkedAttributeArena(
-    device, `${label}/attrs`, GPUBufferUsage.STORAGE,
-    attrBytesHint, cap,
-  );
-  const indices = new ChunkedIndexAllocator(
-    device, `${label}/idx`, GPUBufferUsage.INDEX | idxExtraUsage,
-    idxBytesHint, cap,
+    device, `${label}/arena`, GPUBufferUsage.STORAGE,
+    Math.min(attrBytesHint, cap), cap,
   );
-  return { attrs, indices };
+  return { attrs };
 }
 
 export function arenaBytes(arena: ArenaState): number {
-  return arena.attrs.totalUsedBytes() + arena.indices.totalUsedElements() * 4;
+  return arena.attrs.totalUsedBytes();
 }
 
 /** Upload a single attribute — header (typeId, length) + data — into the arena at byte offset `ref`. */