@aardworx/wombat.rendering 0.9.33 → 0.19.0

package/src/runtime/heapScene.ts

@@ -85,7 +85,7 @@ import {
 } from "./heapScene/growBuffer.js";
 import {
   UniformPool, IndexPool, DrawHeap,
-  AttributeArena, IndexAllocator, insertSortedFreeBlock,
+  AttributeArena, IndexAllocator,
   buildArenaState, arenaBytes, writeAttribute,
   asAval, isBufferView, asFloat32,
   ALLOC_HEADER_BYTES, ALLOC_HEADER_PAD_TO,
@@ -94,7 +94,21 @@ import {
 } from "./heapScene/pools.js";
 import { encodeModeKey, type PipelineStateDescriptor } from "./pipelineCache/index.js";
 import { snapshotDescriptor, ModeKeyTracker } from "./derivedModes/modeKeyCpu.js";
+import { GpuPartitionScene } from "./derivedModes/partitionDispatcher.js";
+import {
+  emitPartitionKernel,
+  substituteReadInputInStmt,
+  collectUniformReadsInStmt,
+  rewriteOutputsToSlotIndices,
+} from "./derivedModes/kernelCodegen.js";
+import { type DerivedModeRule, type ModeAxis } from "./derivedModes/rule.js";
+import type { CullMode, FrontFace, Topology } from "./pipelineCache/index.js";
 import { addMarkingCallback } from "@aardworx/wombat.adaptive";
+import {
+  analyseOutputSet, evaluateStructural, evaluateStructuralSet,
+  stableStringify,
+  type Expr, type Stmt,
+} from "@aardworx/wombat.shader/ir";
 
 // GrowBuffer + ALIGN16 + MIN_BUFFER_BYTES + POW2 live in ./heapScene/growBuffer.
 // Packers (WGSL-type → JS-value → arena bytes) live in ./heapScene/packers.
@@ -160,6 +174,10 @@ interface BucketSlot {
   pipeline: GPURenderPipeline;
   /** modeKey this slot covers — the bitfield-encoded descriptor. */
   modeKey: bigint;
+  /** Snapshotted full descriptor the slot was created with. Used by
+   *  CPU→GPU promotion to synthesise per-distinct-descriptor combos
+   *  for pre-existing CPU-routed ROs. */
+  cpuDescriptor?: PipelineStateDescriptor;
   /** Render bind group (drawTable + firstDrawInTile are per-slot). */
   bindGroup?: GPUBindGroup;
 
@@ -190,10 +208,57 @@ interface BucketSlot {
   scanDirty: boolean;
 }
 
+/**
+ * One distinct derived-mode rule registered on a GPU-routed bucket,
+ * keyed by axis. Multiple ROs in the same bucket may carry different
+ * rules across different axes; each axis maintains its own
+ * `axisRuleId` namespace. A bucket-unique `comboId` (a chosen
+ * tuple of (axis → axisRuleId, or "no rule") per RO) is baked into
+ * master-pool records and selects the right composer fn in the
+ * partition kernel.
+ */
+interface AxisRuleEntry {
+  readonly axis: ModeAxis;
+  readonly axisRuleId: number;
+  readonly contentHash: string;
+  readonly rule: DerivedModeRule<ModeAxis>;
+  readonly body: Stmt;
+  /** Last declared u32 we re-specialised against — drives the
+   *  dispatch-time "needs re-specialise?" check. */
+  lastDeclaredU32: number | undefined;
+}
+
+/**
+ * One combination of rules carried by ROs in a GPU-routed bucket.
+ * A combo specifies at most one rule per axis (axes absent from the
+ * map fall back to baseDescriptor at a compile-time-constant per-
+ * axis index). Master records store `comboId` — the partition
+ * kernel emits one `combo_<id>` fn per combo composing per-axis
+ * indices into a global slot index via mixed-radix encoding.
+ */
+interface ComboEntry {
+  readonly comboId: number;
+  readonly comboKey: string;
+  /** axis → axisRuleId for axes this combo has a rule on. */
+  readonly axisRules: ReadonlyMap<ModeAxis, number>;
+  /** axis → explicit fixed value for axes the combo has no rule on
+   *  but wants to override baseDescriptor's value (e.g. pre-existing
+   *  CPU-routed ROs whose pipelineState differs from baseDescriptor
+   *  on a non-ruled axis). Axes absent from both maps fall back to
+   *  baseDescriptor at codegen time. */
+  readonly axisFixedValues: ReadonlyMap<ModeAxis, unknown>;
+}
+
 interface Bucket {
   readonly label: string;
   readonly textures: HeapTextureSet | undefined;
   readonly layout: BucketLayout;
+  /** §3: which arena chunk this bucket's ROs live in. The bucket's
+   *  bind groups reference `arena.attrs.chunk(chunkIdx).buffer` and
+   *  `arena.indices.chunk(chunkIdx).buffer`. Two ROs sharing an
+   *  effect that landed in different chunks live in DIFFERENT
+   *  buckets — encode emits a draw per (effect, chunkIdx). */
+  readonly chunkIdx: number;
   /**
    * One entry per distinct pipeline state. Phase 5a: always length 1
    * (per-RO pipeline-state still keyed at the bucket level).
@@ -276,6 +341,60 @@ interface Bucket {
    * for slots without an atlas source aval.
    */
   readonly localAtlasArrIdx: (number | undefined)[];
+
+  // ─── Phase 5c.3 GPU-routed bucket state ─────────────────────────
+  /**
+   * True when this bucket's first RO carried a GPU-flavoured mode
+   * rule (e.g. `gpuFlipCullByDeterminant`). The partition kernel
+   * decides per-record routing each frame; CPU never reslots.
+   */
+  gpuRouted: boolean;
+  /**
+   * Per-bucket partition dispatcher. Owns the master record buffer
+   * + per-slot atomic counters + params. Slot draw buffers are
+   * externally owned (point at `bucket.slots[i].drawTableBuf.buffer`).
+   */
+  partitionScene: GpuPartitionScene | undefined;
+  /**
+   * drawId → master record index (for swap-pop on removeDraw).
+   */
+  drawIdToRecord: Map<number, number> | undefined;
+  /**
+   * master record index → drawId (for fixup when swap-pop moves the
+   * tail record into the freed slot).
+   */
+  recordToDrawId: number[] | undefined;
+  /**
+   * Per-axis distinct rules registered on this bucket, keyed by
+   * content hash (axis + expr.id + declared identity). `axisRuleId`
+   * is unique within an axis. ROs carry an arbitrary subset of axis
+   * rules; combos (below) dedupe distinct subsets across ROs.
+   */
+  rulesByAxis: Map<ModeAxis, Map<string, AxisRuleEntry>> | undefined;
+  /** Per-axis ordered list of registered rule hashes; index =
+   *  `axisRuleId` for that axis. */
+  axisRuleOrder: Map<ModeAxis, string[]> | undefined;
+  /** Bucket-wide ordered list of arena uniform names read by any
+   *  rule body. Each entry maps to a `ref<i>: u32` field in the
+   *  master-record uniform tail; appendRecord packs them per RO. */
+  uniformOrder: string[] | undefined;
+  uniformIdx: Map<string, number> | undefined;
+  /** Distinct combos appearing on ROs in this bucket. */
+  combosByKey: Map<string, ComboEntry> | undefined;
+  /** `comboId` → comboKey. Index = comboId. */
+  comboOrder: string[] | undefined;
+  /** drawId → comboId. Master records carry the comboId; this is
+   *  the CPU-side mirror used when an RO is removed. */
+  drawIdToComboId: Map<number, number> | undefined;
+  /** Seed PipelineStateDescriptor (the descriptor of the first GPU-
+   *  routed RO). Used as the base for slot descriptors. */
+  baseDescriptor: PipelineStateDescriptor | undefined;
+  /**
+   * Has the partition kernel's inputs (records or rule deps)
+   * changed since last dispatch? Set true on addRO / removeDraw /
+   * any tracker-leaf mark. Reset after dispatch.
+   */
+  partitionDirty: boolean;
 }
 
 // ---------------------------------------------------------------------------
@@ -319,6 +438,18 @@ export interface HeapDrawSpec {
    * computes `indexCount * instanceCount` per record.
    */
   readonly instanceCount?: aval<number> | number;
+  /**
+   * Optional visibility gate. When ticks to `false`, this RO emits
+   * 0 vertices that frame — its drawTable record gets effective
+   * `indexCount = 0`, the scan kernel's prefix sum skips past it,
+   * and no fragment shader invocations fire. Pool allocations,
+   * arena uploads, and bucket membership all stay intact, so the
+   * `true → false → true` round-trip is a pair of small drawTable
+   * writes plus a scan-pass re-issue — no `addDraw`/`removeDraw`
+   * churn. Designed for `<Sg Active={cval}>` driven by LOD walkers
+   * that flip many tiles per camera move.
+   */
+  readonly active?: aval<boolean>;
   /**
    * Index buffer for this draw. Indices live in their own `INDEX`-
    * usage `GPUBuffer` (WebGPU forces this), separate from the arena.
@@ -570,6 +701,18 @@ export interface BuildHeapSceneOptions {
    * effect's `spec.inputs[name]` like any other uniform.
    */
   readonly enableDerivedUniforms?: boolean;
+  /**
+   * §3 — per-arena-chunk size cap in bytes. When omitted, falls
+   * back to `min(device.limits.maxStorageBufferBindingSize,
+   * DEFAULT_MAX_BUFFER_BYTES = 256 MB)` so chunks grow as far as
+   * the hardware allows. Demos / tests can pass a small value
+   * (e.g. 4 MB) to exercise multi-chunk routing without realistic
+   * workload pressure. Each chunk lives in its own GPUBuffer;
+   * buckets bind exactly one chunk and emit one draw call per
+   * (effect, chunkIdx). Shared-aval avals that land in different
+   * chunks duplicate their pool entries (accepted trade-off).
+   */
+  readonly maxChunkBytes?: number;
 }
 
 export function buildHeapScene(
@@ -607,6 +750,7 @@ export function buildHeapScene(
   const arena = buildArenaState(
     device, 64 * 1024, 16 * 1024, "heapScene",
     GPUBufferUsage.STORAGE,
+    opts.maxChunkBytes,
   );
 
   // ─── Per-draw global bookkeeping (sparse, indexed by drawId) ──────
@@ -642,6 +786,90 @@ export function buildHeapScene(
   const modeAvalToDrawIds  = new Map<aval<unknown>, Set<number>>();
   const modeAvalCallbacks  = new Map<aval<unknown>, IDisposable>();
 
+  // ─── HeapDrawSpec.active subscription ────────────────────────────────
+  // Per-drawId state for the "skip without re-allocating" path. When a
+  // tile (or any RO) flips visibility many times per second (e.g. an
+  // LOD walker culling/uncrossing the frustum), pool churn would be
+  // prohibitive. Instead we keep the RO in the bucket and flip its
+  // drawTable record's `indexCount` field between the original count
+  // (visible) and 0 (hidden). The scan kernel's prefix sum naturally
+  // skips a record with 0 emit count, so this costs one drawTable
+  // write + a re-scan dispatch — no arena/freelist activity.
+  const drawIdToActiveAval = new Map<number, aval<boolean>>();
+  const drawIdToOrigIndexCount = new Map<number, number>();
+  const drawIdToActiveCallback = new Map<number, IDisposable>();
+  const activeAvalToDrawIds = new Map<aval<boolean>, Set<number>>();
+  const activeDirty = new Set<number>();
+
+  function subscribeActive(av: aval<boolean>, drawId: number): void {
+    let set = activeAvalToDrawIds.get(av);
+    if (set === undefined) {
+      set = new Set<number>();
+      activeAvalToDrawIds.set(av, set);
+    }
+    set.add(drawId);
+    const cb = addMarkingCallback(av, () => { activeDirty.add(drawId); });
+    drawIdToActiveCallback.set(drawId, cb);
+  }
+
+  function unsubscribeActive(drawId: number): void {
+    const av = drawIdToActiveAval.get(drawId);
+    if (av === undefined) return;
+    const cb = drawIdToActiveCallback.get(drawId);
+    cb?.dispose();
+    drawIdToActiveCallback.delete(drawId);
+    const set = activeAvalToDrawIds.get(av);
+    if (set !== undefined) {
+      set.delete(drawId);
+      if (set.size === 0) activeAvalToDrawIds.delete(av);
+    }
+    drawIdToActiveAval.delete(drawId);
+    drawIdToOrigIndexCount.delete(drawId);
+    activeDirty.delete(drawId);
+  }
+
+  /** Update the drawTable record's effective indexCount in place
+   *  (GPU-routed: masterShadow + partition re-dispatch; legacy:
+   *  drawTableShadow + scan re-dispatch). Common helper used by the
+   *  active-aval drain in `update()`. */
+  function setEffectiveIndexCount(drawId: number, newIndexCount: number): void {
+    const bucket = drawIdToBucket[drawId];
+    if (bucket === undefined) return;
+    if (bucket.gpuRouted) {
+      const partition = bucket.partitionScene!;
+      const recIdx = bucket.drawIdToRecord!.get(drawId);
+      if (recIdx === undefined) return;
+      const ru32 = partition.recordU32;
+      const oldIndexCount = partition.masterShadow[recIdx * ru32 + 3]!;
+      const instanceCount = partition.masterShadow[recIdx * ru32 + 4]!;
+      partition.masterShadow[recIdx * ru32 + 3] = newIndexCount >>> 0;
+      const delta = (newIndexCount - oldIndexCount) * instanceCount;
+      bucket.partitionDirty = true;
+      for (const s of bucket.slots) {
+        s.totalEmitEstimate = Math.max(0, s.totalEmitEstimate + delta);
+        s.scanDirty = true;
+      }
+    } else {
+      const slotIdx = drawIdToSlotIdx[drawId];
+      const slot = slotIdx !== undefined ? bucket.slots[slotIdx] : bucket.slots[0];
+      if (slot === undefined) return;
+      const localSlot = drawIdToLocalSlot[drawId];
+      if (localSlot === undefined) return;
+      const recIdx = slot.slotToRecord[localSlot];
+      if (recIdx === undefined || recIdx < 0) return;
+      const shadow = slot.drawTableShadow!;
+      const oldIndexCount = shadow[recIdx * RECORD_U32 + 3]!;
+      const instanceCount = shadow[recIdx * RECORD_U32 + 4]!;
+      shadow[recIdx * RECORD_U32 + 3] = newIndexCount >>> 0;
+      const byteOff = recIdx * RECORD_BYTES + 3 * 4;
+      if (byteOff < slot.drawTableDirtyMin) slot.drawTableDirtyMin = byteOff;
+      if (byteOff + 4 > slot.drawTableDirtyMax) slot.drawTableDirtyMax = byteOff + 4;
+      const delta = (newIndexCount - oldIndexCount) * instanceCount;
+      slot.totalEmitEstimate = Math.max(0, slot.totalEmitEstimate + delta);
+      slot.scanDirty = true;
+    }
+  }
+
   function subscribeModeLeaf(av: aval<unknown>, drawId: number): void {
     let set = modeAvalToDrawIds.get(av);
     if (set === undefined) {
@@ -867,7 +1095,7 @@ export function buildHeapScene(
     override inputChanged(_t: unknown, o: IAdaptiveObject): void {
       // Pool avals are stored as `aval<unknown>`; the IAdaptiveObject
       // identity matches.
-      if (pool.has(o as unknown as aval<unknown>)) {
+      if (pool.hasAny(o as unknown as aval<unknown>)) {
         allocDirty.add(o as unknown as aval<unknown>);
         return;
       }
@@ -892,11 +1120,21 @@ export function buildHeapScene(
   // `enableDerivedUniforms: false` to opt out.
   const enableDerivedUniforms = opts.enableDerivedUniforms !== false;
   const derivedScene: DerivedUniformsScene | undefined = enableDerivedUniforms
-    ? new DerivedUniformsScene(device, arena.attrs.buffer, {
+    ? new DerivedUniformsScene(device, {
         // Larger initial capacity reduces grow-during-first-frame churn.
         initialConstituentSlots: 4096,
       })
     : undefined;
+  // §3: register each arena chunk's main-heap buffer with the
+  // derived-uniforms scene; refresh the binding when chunks open or
+  // a chunk's GrowBuffer reallocates.
+  if (derivedScene !== undefined) {
+    const wireChunk = (idx: number): void => {
+      derivedScene.setMainHeapForChunk(idx, () => arena.attrs.chunk(idx).buffer);
+    };
+    for (let i = 0; i < arena.attrs.chunkCount; i++) wireChunk(i);
+    arena.attrs.onChunkAdded(wireChunk);
+  }
   /** Per-RO §7 registration handles, keyed by global drawId.
    *  Drained on removeDraw to release slots + records. */
   const derivedByDrawId = new Map<number, RoRegistration>();
@@ -1412,11 +1650,12 @@ export function buildHeapScene(
     // SAME global arena GPUBuffer (emscripten-style aliasing). The
     // WGSL prelude declares one binding per view; the shader picks
     // whichever matches its read.
+    const attrsBuf = arena.attrs.chunk(bucket.chunkIdx).buffer;
     const entries: GPUBindGroupEntry[] = [
-      { binding: 0, resource: { buffer: arena.attrs.buffer } },          // heapU32
+      { binding: 0, resource: { buffer: attrsBuf } },                    // heapU32
       { binding: 1, resource: { buffer: bucket.drawHeap.buffer } },      // headersU32
-      { binding: 2, resource: { buffer: arena.attrs.buffer } },          // heapF32
-      { binding: 3, resource: { buffer: arena.attrs.buffer } },          // heapV4f
+      { binding: 2, resource: { buffer: attrsBuf } },                    // heapF32
+      { binding: 3, resource: { buffer: attrsBuf } },                    // heapV4f
     ];
     {
       const s = bucket.slots[slotIdx]!;
@@ -1431,7 +1670,7 @@ export function buildHeapScene(
       const dtBytes = Math.max(RECORD_BYTES, s.recordCount * RECORD_BYTES);
       entries.push(
         { binding: 4, resource: { buffer: s.drawTableBuf.buffer, offset: 0, size: dtBytes } },
-        { binding: 5, resource: { buffer: arena.indices.buffer } },
+        { binding: 5, resource: { buffer: arena.indices.chunk(bucket.chunkIdx).buffer } },
         { binding: 6, resource: { buffer: s.firstDrawInTileBuf!.buffer } },
       );
       s.renderBoundRecordCount = s.recordCount;
@@ -1541,16 +1780,37 @@ export function buildHeapScene(
     }
   }
 
-  arena.attrs.onResize(() => {
-    rebuildAllBindGroups();
-    if (derivedScene !== undefined) derivedScene.rebindMainHeap(arena.attrs.buffer);
+  arena.attrs.onAnyResize((resizedChunkIdx) => {
+    // Only rebuild bind groups for buckets that bind THIS chunk —
+    // a resize in chunk K doesn't affect a bucket reading chunk N≠K.
+    for (const b of buckets) {
+      if (b.chunkIdx !== resizedChunkIdx) continue;
+      for (let i = 0; i < b.slots.length; i++) {
+        b.slots[i]!.bindGroup = buildBucketBindGroup(b, i);
+      }
+      if (b.gpuRouted && b.partitionScene !== undefined) {
+        b.partitionScene.rebindSlotDrawBufs(b.slots.map(s => s.drawTableBuf!.buffer));
+      }
+    }
+    // §7: each chunk's main-heap getter is registered via
+    // `derivedScene.setMainHeapForChunk` (at construction + on
+    // onChunkAdded). The getter returns the chunk's current
+    // GPUBuffer; the dispatcher's bind groups consult it per
+    // dispatch, so no explicit rebind needed here.
   });
   if (atlasPool !== undefined) {
     for (const f of ATLAS_PAGE_FORMATS) {
       atlasPool.onPageAdded(f, () => rebuildAllBindGroups(true));
     }
   }
-  arena.indices.onResize(() => rebuildAllBindGroups());
+  arena.indices.onAnyResize((resizedChunkIdx) => {
+    for (const b of buckets) {
+      if (b.chunkIdx !== resizedChunkIdx) continue;
+      for (let i = 0; i < b.slots.length; i++) {
+        b.slots[i]!.bindGroup = buildBucketBindGroup(b, i);
+      }
+    }
+  });
 
   // ─── findOrCreateBucket ───────────────────────────────────────────
   // Slice 3c: the bucket key collapses to (familyId, pipelineState).
@@ -1604,6 +1864,7 @@ export function buildHeapScene(
 
     const slot: BucketSlot = {
       pipeline, modeKey,
+      cpuDescriptor: descriptor,
       drawTableDirtyMin: Infinity, drawTableDirtyMax: 0,
       recordCount: 0, slotToRecord: [], recordToSlot: [],
       totalEmitEstimate: 0, scanDirty: false,
@@ -1632,6 +1893,11 @@ export function buildHeapScene(
       rebuildScanBg();
       slot.drawTableDirtyMin = 0;
       slot.drawTableDirtyMax = slot.recordCount * RECORD_BYTES;
+      // Phase 5c.3: partition's bind group references every slot's
+      // drawTable. When ANY slot's GPUBuffer reallocates we rebind all.
+      if (bucket.gpuRouted && bucket.partitionScene !== undefined) {
+        bucket.partitionScene.rebindSlotDrawBufs(bucket.slots.map(s => s.drawTableBuf!.buffer));
+      }
     });
     blockSumsBuf.onResize(rebuildScanBg);
     blockOffsetsBuf.onResize(rebuildScanBg);
@@ -1648,10 +1914,721 @@ export function buildHeapScene(
   /** Side map from Bucket → family. Populated by findOrCreateBucket. */
   const familyForBucket = new WeakMap<Bucket, ReturnType<typeof familyFor>>();
 
+  /** Canonical axis order — every part of the GPU routing path uses
+   *  this ordering so the kernel's params layout, the per-slot mixed-
+   *  radix mode key, and the declared-aval lookup stay in lockstep. */
+  const AXIS_ORDER: ReadonlyArray<ModeAxis> = [
+    "cull", "frontFace", "topology",
+    "depthCompare", "depthWrite", "alphaToCoverage",
+  ];
+
+  function collectRules(modeRules: NonNullable<HeapDrawSpec["modeRules"]>): DerivedModeRule<ModeAxis>[] {
+    const out: DerivedModeRule<ModeAxis>[] = [];
+    for (const axis of AXIS_ORDER) {
+      const r = (modeRules as Record<string, DerivedModeRule<ModeAxis> | undefined>)[axis];
+      if (r !== undefined) out.push(r);
+    }
+    return out;
+  }
+
+  /** Apply a per-axis enum value to a `PipelineStateDescriptor` and
+   *  return the patched copy. Used to materialise one descriptor per
+   *  slot (= one per cartesian-product point across the rule domains). */
+  function patchDescriptor(
+    base: PipelineStateDescriptor,
+    axis: ModeAxis,
+    value: unknown,
+  ): PipelineStateDescriptor {
+    switch (axis) {
+      case "cull":            return { ...base, cullMode:  value as CullMode };
+      case "frontFace":       return { ...base, frontFace: value as FrontFace };
+      case "topology": {
+        const topology = value as Topology;
+        return { ...base, topology, stripIndexFormat: stripFormatForTopology(topology) };
+      }
+      case "depthCompare":
+        return base.depth !== undefined
+          ? { ...base, depth: { ...base.depth, compare: value as GPUCompareFunction } }
+          : base;
+      case "depthWrite":
+        return base.depth !== undefined
+          ? { ...base, depth: { ...base.depth, write: value as boolean } }
+          : base;
+      case "alphaToCoverage": return { ...base, alphaToCoverage: value as boolean };
+      case "blend": {
+        // Blend is per-attachment; apply the resolved AttachmentBlend
+        // to attachment 0 (the main color target). Multi-attachment
+        // structured rules can extend this when needed.
+        const blend = value as import("./pipelineCache/index.js").AttachmentBlend;
+        const atts = base.attachments.slice();
+        if (atts.length === 0) atts.push(blend);
+        else atts[0] = blend;
+        return { ...base, attachments: atts };
+      }
+      default: return base;
+    }
+  }
+
+  function stripFormatForTopology(t: Topology): GPUIndexFormat | undefined {
+    return t === "line-strip" || t === "triangle-strip" ? "uint32" : undefined;
+  }
+
+  /** Per-axis enum order. The rule body produces u32 indices into
+   *  this array, and the heap renderer uses the same order to map
+   *  resolved-set integers back to pipeline descriptor values. The
+   *  ordering MUST match the bitfield encoder in pipelineCache. */
+  const AXIS_ENUM_TABLE: { readonly [A in ModeAxis]: ReadonlyArray<unknown> } = {
+    cull:            ["none", "front", "back"],
+    frontFace:       ["ccw", "cw"],
+    topology:        ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"],
+    depthCompare:    ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"],
+    depthWrite:      [false, true],
+    alphaToCoverage: [false, true],
+    // Blend has no canonical enum table — the rule's `resolve` /
+    // `values` callback MUST be supplied so the heap renderer knows
+    // how to map u32 outputs to AttachmentBlend objects.
+    blend:           [],
+  };
+
+  /**
+   * Map a resolved slot value (from `evaluateStructuralSet`) to the
+   * axis-shape value used for descriptor patching.
+   *
+   *  - If the resolved value is a JS object: it's already the full
+   *    axis value (e.g. an `AttachmentBlend` from a blend rule's
+   *    object-literal return) — use it directly.
+   *  - If it's a number: for enum axes, look up the canonical
+   *    table; for structured axes without a table, pass through.
+   */
+  function resolveAxisValue<A extends ModeAxis>(
+    rule: DerivedModeRule<A>,
+    value: unknown,
+  ): unknown {
+    if (typeof value === "object" && value !== null) return value;
+    if (typeof value === "number") {
+      const table = AXIS_ENUM_TABLE[rule.axis];
+      if (table.length > 0) {
+        const v = table[value];
+        if (v !== undefined) return v;
+      }
+      return value;
+    }
+    return value;
+  }
+
+  /**
+   * Resolve an axis's `declared` value to a u32 index.
+   *
+   *  - omitted: `0` (the rule body either doesn't reference `declared`
+   *    or wants the canonical zero of its axis as the default).
+   *  - number: passed through directly (e.g. `declared: 2` for cull "back").
+   *  - aval / string / boolean: looked up in the canonical enum table.
+   */
+  function resolveDeclaredU32<A extends ModeAxis>(rule: DerivedModeRule<A>, tok: AdaptiveToken): number {
+    const d = rule.declared;
+    if (d === undefined) return 0;
+    const v = (typeof d === "object" && d !== null && "getValue" in (d as object))
+      ? (d as aval<unknown>).getValue(tok)
+      : d;
+    if (typeof v === "number") return v >>> 0;
+    const table = AXIS_ENUM_TABLE[rule.axis];
+    if (table.length === 0) {
+      throw new Error(
+        `heapScene/gpuRouting: axis '${rule.axis}' has no canonical enum table; ` +
+        `pass \`declared\` as a u32 index or omit it`,
+      );
+    }
+    const i = table.indexOf(v);
+    if (i < 0) {
+      throw new Error(
+        `heapScene/gpuRouting: declared value '${String(v)}' for axis '${rule.axis}' ` +
+        `not in canonical enum table ${JSON.stringify(table)}`,
+      );
+    }
+    return i;
+  }
+
+  /** Extract the rule body Stmt from a RuleExpr's Module. The plugin
+   *  emits one `Entry` ValueDef whose body is the user's closure body
+   *  (with the synthetic compute-stage scaffolding stripped). */
+  function ruleBodyOf(rule: DerivedModeRule<ModeAxis>): Stmt {
+    const tmpl = rule.expr.template as { values: ReadonlyArray<{ kind: string; entry?: { body: Stmt } }> };
+    for (const v of tmpl.values) {
+      if (v.kind === "Entry" && v.entry !== undefined) return v.entry.body;
+    }
+    throw new Error(
+      `heapScene/gpuRouting: rule for axis '${rule.axis}' has no Entry in its template (id=${rule.expr.id})`,
+    );
+  }
+
+  /**
+   * Specialise a rule for the current declared u32 value:
+   *   1. Bake `declared` as a Const in the rule body (so the kernel
+   *      has no per-dispatch uniform — declared marks trigger a
+   *      re-specialise + cached-kernel swap).
+   *   2. Run `analyseOutputSet` to collect distinct return Exprs.
+   *   3. `evaluateStructuralSet` folds each Expr to a JS value (a
+   *      number for enum axes; a full object for structured axes
+   *      like blend). Distinct values define the slot count.
+   *   4. Build a stableStringify-keyed `exprToSlot` map.
+   *   5. Rewrite the body so every ReturnValue emits a Const u32
+   *      slot index.
+   *   6. emitPartitionKernel produces the WGSL.
+   */
+  /** WeakMap-based stable identity for aval objects. Two `cval`s
+   *  have different identity; the same cval observed twice has the
+   *  same identity. Used in `ruleContentHash` so rules differing
+   *  only in their `declared` aval are recognised as distinct. */
+  const avalIdentityMap = new WeakMap<object, number>();
+  let nextAvalIdentity = 0;
+  function avalIdentity(av: object): number {
+    let id = avalIdentityMap.get(av);
+    if (id === undefined) {
+      id = ++nextAvalIdentity;
+      avalIdentityMap.set(av, id);
+    }
+    return id;
+  }
+
+  /** Content hash for rule identity within a bucket. Two rules
+   *  hashing the same can share a `ruleId` and one body; rules
+   *  hashing differently get distinct ids. */
+  function ruleContentHash(rule: DerivedModeRule<ModeAxis>): string {
+    const dec = rule.declared;
+    let dKey: string;
+    if (dec === undefined) {
+      dKey = "u";
+    } else if (typeof dec === "object" && dec !== null && "getValue" in (dec as object)) {
+      dKey = `a${avalIdentity(dec as object)}`;
+    } else {
+      dKey = `v${String(dec)}`;
+    }
+    return `${rule.axis}|${rule.expr.id}|${dKey}`;
+  }
+
+  /** Read baseDescriptor's value for a given axis (the value used by
+   *  combos that have no rule on that axis). */
+  function axisValueOfDesc(desc: PipelineStateDescriptor, axis: ModeAxis): unknown {
+    switch (axis) {
+      case "cull":            return desc.cullMode;
+      case "frontFace":       return desc.frontFace;
+      case "topology":        return desc.topology;
+      case "depthCompare":    return desc.depth?.compare;
+      case "depthWrite":      return desc.depth?.write;
+      case "alphaToCoverage": return desc.alphaToCoverage;
+      case "blend":           return desc.attachments[0];
+    }
+  }
+
+  /**
+   * Specialise the WHOLE bucket — N-D cartesian over per-axis
+   * unions:
+   *   1. Per (axis, rule): bake declared as Const, analyse the body,
+   *      `evaluateStructuralSet` to fold each return Expr to a JS
+   *      value. Collect the per-axis union (dedup by stableStringify,
+   *      sorted deterministically). If any combo lacks a rule on
+   *      this axis, also include baseDesc's value for that axis.
+   *   2. Active axes = axes with ≥1 registered rule, in AXIS_ORDER.
+   *      Cardinalities Cₐ = |axisValues[a]|; totalSlots = ∏ Cₐ.
+   *   3. Per axis-rule: rewrite the body so every `ReturnValue`
+   *      emits a `Const u32` PER-AXIS index (into axisValues[axis]).
+   *   4. Per combo: assemble a ComboCodegenSpec (per-axis source =
+   *      rule or compile-time const index).
+   *   5. Emit the kernel.
+   *
+   * Returns the cartesian slot descriptors + the kernel WGSL.
+   */
+  function specialiseBucket(
+    bucket: Bucket,
+  ): { slotDescs: ReadonlyArray<PipelineStateDescriptor>; kernelWGSL: string } {
+    const Tu32 = { kind: "Int", signed: false, width: 32 } as const;
+    const rulesByAxis = bucket.rulesByAxis!;
+    const axisRuleOrder = bucket.axisRuleOrder!;
+    const combosByKey = bucket.combosByKey!;
+    const comboOrder  = bucket.comboOrder!;
+    if (comboOrder.length === 0) {
+      throw new Error("heapScene/gpuRouting: specialiseBucket called with no registered combos");
+    }
+    const base = bucket.baseDescriptor!;
+    // An axis is "active" (gets cartesian-product cardinality) if it
+    // has at least one rule, OR any combo overrides baseDesc with a
+    // distinct fixed value. Both grow the per-axis value union.
+    const baseAxisValues = new Map<ModeAxis, unknown>(AXIS_ORDER.map(a => [a, axisValueOfDesc(base, a)] as const));
+    const activeAxes: ModeAxis[] = AXIS_ORDER.filter(a => {
+      if ((rulesByAxis.get(a)?.size ?? 0) > 0) return true;
+      const baseVal = baseAxisValues.get(a);
+      const baseKey = stableStringify(baseVal);
+      for (const k of comboOrder) {
+        const c = combosByKey.get(k)!;
+        const fixed = c.axisFixedValues.get(a);
+        if (fixed !== undefined && stableStringify(fixed) !== baseKey) return true;
+      }
+      return false;
+    });
+
+    // Step 1: per-axis-rule analyse + collect per-axis union.
+    interface PerRule {
+      entry: AxisRuleEntry;
+      bakedBody: Stmt;
+      resolved: ReadonlyArray<unknown>;
+      declaredU32: number;
+    }
+    const perAxisRules = new Map<ModeAxis, PerRule[]>();
+    for (const axis of activeAxes) {
+      const list: PerRule[] = [];
+      for (const hash of axisRuleOrder.get(axis)!) {
+        const entry = rulesByAxis.get(axis)!.get(hash)!;
+        const declaredU32 = resolveDeclaredU32(entry.rule, AdaptiveToken.top);
+        const declaredConst: Expr = {
+          kind: "Const", type: Tu32 as never,
+          value: { kind: "Int", value: declaredU32 >>> 0, signed: false } as never,
+        } as Expr;
+        const bakedBody = substituteReadInputInStmt(entry.body, "Uniform", "declared", declaredConst);
+        const symbolic = analyseOutputSet(bakedBody);
+        const env = new Map<string, number>([["declared", declaredU32]]);
+        const { resolved, unresolvedCount } = evaluateStructuralSet(symbolic, env, new Map());
+        let outputs = resolved.slice();
+        if (outputs.length === 0 || unresolvedCount > 0) {
+          const table = AXIS_ENUM_TABLE[entry.rule.axis];
+          if (table.length > 0 && unresolvedCount > 0) {
+            outputs = table.map((_, i) => i);
+          } else if (outputs.length === 0) {
+            throw new Error(
+              `heapScene/gpuRouting: rule on axis '${entry.rule.axis}' could not be ` +
+              `statically resolved AND the axis has no canonical enum table. ` +
+              `Simplify the rule body so analyseOutputSet can fold each branch.`,
+            );
+          }
+        }
+        list.push({ entry, bakedBody, resolved: outputs, declaredU32 });
+        entry.lastDeclaredU32 = declaredU32;
+      }
+      perAxisRules.set(axis, list);
+    }
+
+    // Per axis: union of resolved values across rules + each combo's
+    // effective value when it has no rule on this axis. Combos that
+    // declare an explicit `axisFixedValues[axis]` contribute that
+    // value; combos without an entry default to baseDesc.value.
+    interface AxisInfo {
+      readonly axis: ModeAxis;
+      readonly values: ReadonlyArray<unknown>;          // resolved axis values, sorted
+      readonly keyToIdx: ReadonlyMap<string, number>;   // stableStringify(value) → idx
+      readonly baseValue: unknown;                       // baseDesc's value for this axis
+      readonly baseIdx: number;                          // index of baseValue in values
+    }
+    const axisInfos: AxisInfo[] = [];
+    for (const axis of activeAxes) {
+      const list = perAxisRules.get(axis) ?? [];
+      const dummyRule = { axis } as DerivedModeRule<ModeAxis>;
+      const byKey = new Map<string, unknown>();
+      for (const p of list) {
+        for (const v of p.resolved) {
+          const av = resolveAxisValue(dummyRule, v);
+          byKey.set(stableStringify(av), av);
+        }
+      }
+      const baseValue = baseAxisValues.get(axis);
+      // Include every combo's effective value for this axis (so
+      // const-source idx lookups always succeed).
+      for (const k of comboOrder) {
+        const c = combosByKey.get(k)!;
+        if (c.axisRules.has(axis)) continue;
+        const effective = c.axisFixedValues.has(axis) ? c.axisFixedValues.get(axis) : baseValue;
+        byKey.set(stableStringify(effective), effective);
+      }
+      const sortedKeys = [...byKey.keys()].sort();
+      const values = sortedKeys.map(k => byKey.get(k)!);
+      const keyToIdx = new Map(sortedKeys.map((k, i) => [k, i] as const));
+      const baseIdx = keyToIdx.get(stableStringify(baseValue)) ?? 0;
+      axisInfos.push({ axis, values, keyToIdx, baseValue, baseIdx });
+    }
+
+    // Step 2: cartesian shape.
+    const cards = axisInfos.map(a => a.values.length);
+    const totalSlots = cards.reduce((m, n) => m * n, 1);
+
+    // Step 3: rewrite each axis-rule body to emit per-axis indices.
+    const ruleSpecs: import("./derivedModes/kernelCodegen.js").RuleCodegenSpec[] = [];
+    for (const info of axisInfos) {
+      const list = perAxisRules.get(info.axis)!;
+      const dummyRule = { axis: info.axis } as DerivedModeRule<ModeAxis>;
+      for (const p of list) {
+        const env = new Map<string, number>([["declared", p.declaredU32]]);
+        const exprToAxisIdx = (e: Expr): number | undefined => {
+          const v = evaluateStructural(e, env, new Map());
+          if (v === undefined) return undefined;
+          const av = resolveAxisValue(dummyRule, v);
+          return info.keyToIdx.get(stableStringify(av));
+        };
+        const rewrittenBody = rewriteOutputsToSlotIndices(p.bakedBody, exprToAxisIdx);
+        ruleSpecs.push({
+          axis: info.axis,
+          axisRuleId: p.entry.axisRuleId,
+          body: rewrittenBody,
+          intrinsics: new Map(),
+          helpersWGSL: "",
+          inputUniforms: ["ModelTrafo"],
+        });
+      }
+    }
+
+    // Step 4: per-combo axis sources. Rule axes → rule source.
+    // Non-rule axes → const idx of (axisFixedValues.get(axis)
+    // ?? baseValue) within the axis's sorted union.
+    const comboSpecs: import("./derivedModes/kernelCodegen.js").ComboCodegenSpec[] = [];
+    for (const comboKey of comboOrder) {
+      const combo = combosByKey.get(comboKey)!;
+      const axes = axisInfos.map(info => {
+        const axisRuleId = combo.axisRules.get(info.axis);
+        if (axisRuleId !== undefined) {
+          return {
+            axis: info.axis,
+            cardinality: info.values.length,
+            source: { kind: "rule" as const, axisRuleId },
+          };
+        }
+        const effective = combo.axisFixedValues.has(info.axis)
+          ? combo.axisFixedValues.get(info.axis)
+          : info.baseValue;
+        const idx = info.keyToIdx.get(stableStringify(effective)) ?? info.baseIdx;
+        return {
+          axis: info.axis,
+          cardinality: info.values.length,
+          source: { kind: "const" as const, idx },
+        };
+      });
+      comboSpecs.push({ comboId: combo.comboId, axes });
+    }
+
+    // Step 5: enumerate cartesian → slot descriptors (mixed-radix
+    // decode in the same axis order the kernel uses).
+    const slotDescs: PipelineStateDescriptor[] = [];
+    for (let slotIdx = 0; slotIdx < totalSlots; slotIdx++) {
+      let desc = base;
+      let rem = slotIdx;
+      // Match kernel: strides[i] = ∏_{j>i} cards[j]. Decode:
+      // idx[i] = (slotIdx / strides[i]) % cards[i].
+      const strides: number[] = new Array(axisInfos.length).fill(1);
+      for (let i = axisInfos.length - 2; i >= 0; i--) strides[i] = strides[i + 1]! * cards[i + 1]!;
+      for (let i = 0; i < axisInfos.length; i++) {
+        const info = axisInfos[i]!;
+        const ai = Math.floor(rem / strides[i]!) % cards[i]!;
+        rem -= ai * strides[i]!;
+        desc = patchDescriptor(desc, info.axis, info.values[ai]);
+      }
+      slotDescs.push(desc);
+    }
+
+    const kernelWGSL = emitPartitionKernel({
+      rules: ruleSpecs,
+      combos: comboSpecs,
+      totalSlots,
+      uniformOrder: bucket.uniformOrder ?? [],
+    });
+    return { slotDescs, kernelWGSL };
+  }
+
+  /** Build pipeline + slot for each cartesian slot descriptor. */
+  function ensureSlotsForResolved(
+    bucket: Bucket,
+    slotDescs: ReadonlyArray<PipelineStateDescriptor>,
+  ): void {
+    const fam = familyForBucket.get(bucket)!;
+    for (let slotIdx = 0; slotIdx < slotDescs.length; slotIdx++) {
+      const desc = slotDescs[slotIdx]!;
+      const key = encodeModeKey(desc);
+      if (slotIdx < bucket.slots.length) {
+        const slot = bucket.slots[slotIdx]!;
+        if (slot.modeKey !== key) {
+          slot.pipeline = getOrCreatePipeline(fam, bucket.layout, bucket.isAtlasBucket, desc);
+          slot.modeKey  = key;
+        }
+      } else {
+        createSlot(bucket, desc);
+      }
+    }
+  }
+
+  /** Register a combo (set of axis rules, ≤ one per axis) on a GPU-
+   *  routed bucket (or promote the bucket on first call). Returns
+   *  the bucket-unique `comboId` to bake into master-pool records. */
+  function registerCombo(
+    bucket: Bucket,
+    axisRules: ReadonlyArray<DerivedModeRule<ModeAxis>>,
+    baseDesc: PipelineStateDescriptor,
+  ): number {
+    // CPU→GPU promotion: capture pre-existing CPU-routed ROs so they
+    // can be migrated into the master pool after the partition is up.
+    // Each RO is tagged with its CPU descriptor (read off the slot's
+    // `cpuDescriptor` snapshot); we synthesise a const-source combo
+    // per distinct descriptor below, with `axisFixedValues` set on
+    // any axis the descriptor differs from baseDescriptor on.
+    interface CpuMigration {
+      localSlot: number;
+      drawId: number;
+      firstIndex: number;
+      indexCount: number;
+      instanceCount: number;
+      perDrawRefs: Map<string, number>;
+      descriptor: PipelineStateDescriptor;
+      /** Filled in below after synthetic combos are registered. */
+      targetComboId: number;
+    }
+    let cpuMigration: CpuMigration[] | undefined;
+    if (!bucket.gpuRouted && bucket.drawSlots.size > 0) {
+      cpuMigration = [];
+      for (const ls of bucket.drawSlots) {
+        const e = bucket.localEntries[ls]!;
+        const drawId = bucket.localToDrawId[ls]!;
+        const slotIdx = drawIdToSlotIdx[drawId];
+        const slot = slotIdx !== undefined ? bucket.slots[slotIdx] : undefined;
+        const descriptor = slot?.cpuDescriptor;
+        if (descriptor === undefined) {
+          throw new Error(
+            `heapScene/gpuRouting: pre-existing CPU RO (drawId=${drawId}, localSlot=${ls}) ` +
+            `has no captured descriptor — bucket promotion cannot synthesise a migration combo.`,
+          );
+        }
+        cpuMigration.push({
+          localSlot:     ls,
+          drawId,
+          firstIndex:    e.firstIndex,
+          indexCount:    e.indexCount,
+          instanceCount: e.instanceCount,
+          perDrawRefs:   bucket.localPerDrawRefs[ls]!,
+          descriptor,
+          targetComboId: 0,
+        });
+      }
+    }
+    if (!bucket.gpuRouted) {
+      bucket.baseDescriptor = baseDesc;
+      bucket.rulesByAxis    = new Map();
+      bucket.axisRuleOrder  = new Map();
+      bucket.uniformOrder   = [];
+      bucket.uniformIdx     = new Map();
+      bucket.combosByKey    = new Map();
+      bucket.comboOrder     = [];
+      bucket.drawIdToComboId = new Map();
+      bucket.drawIdToRecord = new Map();
+      bucket.recordToDrawId = [];
+      // Synthesise one combo per distinct pre-existing CPU
+      // descriptor. Each carries `axisFixedValues` on axes where the
+      // descriptor differs from baseDescriptor; specialiseBucket
+      // expands the per-axis union to include each variant value
+      // and emits a const-source combo fn that routes to the right
+      // cartesian slot.
+      if (cpuMigration !== undefined) {
+        const baseVals = new Map<ModeAxis, unknown>(AXIS_ORDER.map(a => [a, axisValueOfDesc(baseDesc, a)] as const));
+        const synthByKey = new Map<string, number>();
+        for (const m of cpuMigration) {
+          const axisFixedValues = new Map<ModeAxis, unknown>();
+          const keyParts: string[] = [];
+          for (const a of AXIS_ORDER) {
+            const v = axisValueOfDesc(m.descriptor, a);
+            const baseKey = stableStringify(baseVals.get(a));
+            const vKey = stableStringify(v);
+            if (vKey !== baseKey) {
+              axisFixedValues.set(a, v);
+              keyParts.push(`${a}:_:fixed:${vKey}`);
+            } else {
+              keyParts.push(`${a}:_`);
+            }
+          }
+          const comboKey = keyParts.join("|");
+          let comboId = synthByKey.get(comboKey);
+          if (comboId === undefined) {
+            comboId = bucket.comboOrder.length;
+            bucket.combosByKey.set(comboKey, {
+              comboId, comboKey,
+              axisRules:       new Map(),
+              axisFixedValues,
+            });
+            bucket.comboOrder.push(comboKey);
+            synthByKey.set(comboKey, comboId);
+          }
+          m.targetComboId = comboId;
+        }
+      }
+    }
+    // Per-axis: dedupe rule by content hash; assign axisRuleId.
+    const perAxisRuleId = new Map<ModeAxis, number>();
+    let respec = false;
+    for (const rule of axisRules) {
+      if (perAxisRuleId.has(rule.axis)) {
+        throw new Error(
+          `heapScene/gpuRouting: combo has two rules on the same axis '${rule.axis}'`,
+        );
+      }
+      const hash = ruleContentHash(rule);
+      let axisMap = bucket.rulesByAxis!.get(rule.axis);
+      if (axisMap === undefined) {
+        axisMap = new Map();
+        bucket.rulesByAxis!.set(rule.axis, axisMap);
+        bucket.axisRuleOrder!.set(rule.axis, []);
+      }
+      let entry = axisMap.get(hash);
+      if (entry === undefined) {
+        const order = bucket.axisRuleOrder!.get(rule.axis)!;
+        const body = ruleBodyOf(rule);
+        entry = {
+          axis: rule.axis,
+          axisRuleId: order.length,
+          contentHash: hash,
+          rule,
+          body,
+          lastDeclaredU32: undefined,
+        };
+        axisMap.set(hash, entry);
+        order.push(hash);
+        // Discover the arena uniforms this rule reads — append unseen
+        // ones to the bucket-wide uniformOrder so master records
+        // carry refs for them. `declared` is a CPU-baked Const, not
+        // an arena uniform; skip it.
+        for (const uName of collectUniformReadsInStmt(body)) {
+          if (uName === "declared") continue;
+          if (!bucket.uniformIdx!.has(uName)) {
+            const idx = bucket.uniformOrder!.length;
+            bucket.uniformOrder!.push(uName);
+            bucket.uniformIdx!.set(uName, idx);
+          }
+        }
+        respec = true;
+      }
+      perAxisRuleId.set(rule.axis, entry.axisRuleId);
+    }
+    // Combo key = canonical-axis-order list of (axis, contentHash).
+    const comboKeyParts: string[] = [];
+    for (const axis of AXIS_ORDER) {
+      const axisRuleId = perAxisRuleId.get(axis);
+      if (axisRuleId === undefined) {
+        comboKeyParts.push(`${axis}:_`);
+      } else {
+        comboKeyParts.push(`${axis}:${bucket.axisRuleOrder!.get(axis)![axisRuleId]!}`);
+      }
+    }
+    const comboKey = comboKeyParts.join("|");
+    let combo = bucket.combosByKey!.get(comboKey);
+    if (combo === undefined) {
+      const comboId = bucket.comboOrder!.length;
+      const axisRules = new Map<ModeAxis, number>();
+      for (const [axis, id] of perAxisRuleId) axisRules.set(axis, id);
+      combo = { comboId, comboKey, axisRules, axisFixedValues: new Map() };
+      bucket.combosByKey!.set(comboKey, combo);
+      bucket.comboOrder!.push(comboKey);
+      respec = true;
+    }
+    // First time gpuRouted? Build the partition scene now.
+    if (!bucket.gpuRouted) {
+      const { slotDescs, kernelWGSL } = specialiseBucket(bucket);
+      ensureSlotsForResolved(bucket, slotDescs);
+      const partition = new GpuPartitionScene(device, `${bucket.label}/partition`, {
+        totalSlots: slotDescs.length,
+        slotDrawBufs: bucket.slots.map(s => s.drawTableBuf!.buffer),
+        kernelWGSL,
+        initialRecords: Math.max(16, (cpuMigration?.length ?? 0) + 16),
+        numUniforms: bucket.uniformOrder!.length,
+      });
+      bucket.gpuRouted      = true;
+      bucket.partitionScene = partition;
+      bucket.partitionDirty = true;
+      // Migrate any captured CPU records into the master pool, each
+      // using the synthetic combo registered for its CPU descriptor.
+      if (cpuMigration !== undefined) {
+        let totalEmit = 0;
+        for (const m of cpuMigration) {
+          const uRefs = bucket.uniformOrder!.map(n => m.perDrawRefs.get(n) ?? 0);
+          const recIdx = partition.appendRecord(
+            m.localSlot, m.firstIndex, m.indexCount, m.instanceCount, m.targetComboId, uRefs,
+          );
+          bucket.drawIdToRecord!.set(m.drawId, recIdx);
+          bucket.recordToDrawId![recIdx] = m.drawId;
+          bucket.drawIdToComboId!.set(m.drawId, m.targetComboId);
+          totalEmit += m.indexCount * m.instanceCount;
+        }
+        const numRecords = partition.numRecords;
+        const recBytes = numRecords * RECORD_BYTES;
+        const needBlocks = Math.max(1, Math.ceil(numRecords / SCAN_TILE_SIZE));
+        for (const s of bucket.slots) {
+          s.drawTableBuf!.ensureCapacity(recBytes);
+          s.drawTableBuf!.setUsed(Math.max(s.drawTableBuf!.usedBytes, recBytes));
+          s.blockSumsBuf!.ensureCapacity(needBlocks * 4);
+          s.blockOffsetsBuf!.ensureCapacity(needBlocks * 4);
+          s.recordCount = numRecords;
+          s.totalEmitEstimate += totalEmit;
+          const newNumTiles = Math.max(1, Math.ceil(s.totalEmitEstimate / TILE_K));
+          s.firstDrawInTileBuf!.ensureCapacity((newNumTiles + 1) * 4);
+          s.scanDirty = true;
+        }
+      }
+    } else if (respec) {
+      const { slotDescs, kernelWGSL } = specialiseBucket(bucket);
+      ensureSlotsForResolved(bucket, slotDescs);
+      const newCount = bucket.slots.length;
+      const draws = bucket.slots.map(s => s.drawTableBuf!.buffer);
+      if (newCount > bucket.partitionScene!.totalSlots) {
+        bucket.partitionScene!.growSlots(newCount, draws);
+      } else {
+        bucket.partitionScene!.rebindSlotDrawBufs(draws);
+      }
+      // Bucket-wide uniformOrder may have grown (a new rule reads a
+      // previously-unseen uniform). Widen master records before
+      // rebuilding the kernel — the WGSL struct width changes too.
+      if (bucket.uniformOrder!.length > bucket.partitionScene!.numUniforms) {
+        bucket.partitionScene!.growUniforms(bucket.uniformOrder!.length);
+      }
+      bucket.partitionScene!.rebuildKernel(kernelWGSL);
+      bucket.partitionDirty = true;
+    }
+    return combo.comboId;
+  }
+
+  /**
+   * Per-frame partition dispatch. Detects per-rule `declared`
+   * changes and re-specialises the whole bucket if any rule's
+   * declared value differs from what was used at the last
+   * dispatch (cheap — analysis runs on cached IR).
+   */
+  function dispatchPartition(bucket: Bucket, enc: GPUCommandEncoder, tok: AdaptiveToken): void {
+    if (!bucket.gpuRouted || bucket.partitionScene === undefined) return;
+    let needRespec = false;
+    outer: for (const axisMap of bucket.rulesByAxis!.values()) {
+      for (const entry of axisMap.values()) {
+        const declaredU32 = resolveDeclaredU32(entry.rule, tok);
+        if (declaredU32 !== entry.lastDeclaredU32) { needRespec = true; break outer; }
+      }
+    }
+    if (needRespec) {
+      const { slotDescs, kernelWGSL } = specialiseBucket(bucket);
+      ensureSlotsForResolved(bucket, slotDescs);
+      const newCount = bucket.slots.length;
+      const draws = bucket.slots.map(s => s.drawTableBuf!.buffer);
+      if (newCount > bucket.partitionScene.totalSlots) {
+        bucket.partitionScene.growSlots(newCount, draws);
+      } else {
+        bucket.partitionScene.rebindSlotDrawBufs(draws);
+      }
+      bucket.partitionScene.rebuildKernel(kernelWGSL);
+    }
+    bucket.partitionScene.flush();
+    bucket.partitionScene.dispatch(arena.attrs.chunk(bucket.chunkIdx).buffer, enc);
+    for (let i = 0; i < bucket.slots.length; i++) {
+      enc.copyBufferToBuffer(
+        bucket.partitionScene.slotCountBufs[i]!, 0,
+        bucket.slots[i]!.paramsBuf!, 0, 4,
+      );
+      bucket.slots[i]!.scanDirty = true;
+    }
+    bucket.partitionDirty = false;
+  }
+
+
   function findOrCreateBucket(
     effect: Effect,
     _textures: HeapTextureSet | undefined,
     pipelineState: PipelineState | undefined,
+    chunkIdx: number,
     /**
      * Optional precomputed descriptor. addDrawImpl passes this when
      * the spec carries `modeRules` so the bucket key reflects the
@@ -1664,12 +2641,13 @@ export function buildHeapScene(
       throw new Error("heapScene: findOrCreateBucket called before family build");
     }
     const fam = familyFor(effect);
-    // Phase 5c.2: bucket key drops modeKey. All ROs with the same
-    // (effect, textureSet) share one bucket; per-modeKey slots live
-    // inside the bucket and route records via `ensureSlot`. Pipeline
-    // pre-warm + the scene-level pipelineByModeKey cache mean every
-    // realized slot lookup hits the cache.
-    const bk = `family#${fam.schema.id}`;
+    // §3: bucket key includes `chunkIdx` — two ROs with the same
+    // effect/family that landed in different arena chunks live in
+    // separate buckets so each bucket can bind exactly one chunk's
+    // GPUBuffers in its draw call. The shaders are unchanged
+    // (refs are byte offsets within whichever chunk's buffer is
+    // currently bound).
+    const bk = `family#${fam.schema.id}/c${chunkIdx}`;
     const existing = bucketByKey.get(bk);
     if (existing !== undefined) return existing;
 
@@ -1682,7 +2660,7 @@ export function buildHeapScene(
     const drawHeap = new DrawHeap(drawHeapBuf, layout.drawHeaderBytes);
 
     const bucket: Bucket = {
-      label: bk, textures: undefined, layout,
+      label: bk, textures: undefined, layout, chunkIdx,
       slots: [],  // populated lazily by ensureSlot per modeKey
       bindGroup: null as unknown as GPUBindGroup,  // legacy field; slot.bindGroup is the real one
       drawHeap,
@@ -1696,6 +2674,19 @@ export function buildHeapScene(
       localAtlasReleases: [],
       localAtlasTextures: [],
       localAtlasArrIdx: [],
+      gpuRouted: false,
+      partitionScene: undefined,
+      drawIdToRecord: undefined,
+      recordToDrawId: undefined,
+      rulesByAxis: undefined,
+      axisRuleOrder: undefined,
+      uniformOrder: undefined,
+      uniformIdx: undefined,
+      combosByKey: undefined,
+      comboOrder: undefined,
+      drawIdToComboId: undefined,
+      baseDescriptor: undefined,
+      partitionDirty: false,
     };
     familyForBucket.set(bucket, fam);
 
@@ -1890,6 +2881,11 @@ export function buildHeapScene(
   // inside a single outer evaluateAlways and invoke addDrawImpl
   // directly with their token — collapsing 1000× nested
   // evaluateAlways into 1× outer.
+  // DEBUG counters.
+  let __addDrawCalls = 0;
+  let __removeDrawCalls = 0;
+  (sceneObj as unknown as { __addDrawCalls: () => number }).__addDrawCalls = () => __addDrawCalls;
+  (sceneObj as unknown as { __removeDrawCalls: () => number }).__removeDrawCalls = () => __removeDrawCalls;
   function addDraw(spec: HeapDrawSpec): number {
     let id = -1;
     sceneObj.evaluateAlways(AdaptiveToken.top, (tok) => {
@@ -1898,6 +2894,7 @@ export function buildHeapScene(
     return id;
   }
   function addDrawImpl(spec: HeapDrawSpec, outerTok: AdaptiveToken): number {
+    __addDrawCalls++;
     const drawId = nextDrawId++;
     // Family-merge (slice 3c): build the family lazily from this
     // single spec when no batched lazy-build occurred earlier (e.g.
@@ -1929,12 +2926,59 @@ export function buildHeapScene(
         token:        outerTok,
       });
     }
-    const bucket = findOrCreateBucket(spec.effect, spec.textures, spec.pipelineState, precomputedDescriptor);
+    // §3 chunk routing — pick which arena chunk this RO's allocations
+    // land in. Preference order:
+    //   1. If any of the RO's bindings is an aval that's already
+    //      allocated in some chunk via the uniform pool, prefer that
+    //      chunk to avoid duplication.
+    //   2. Otherwise, use the newest open chunk (highest chunkIdx).
+    //      ChunkedArena.alloc spills to the next chunk automatically
+    //      when this one is full; the spill ends up driving the
+    //      pool's `finalChunk` selection so all of the RO's
+    //      allocations land in one chunk consistently.
+    let chunkIdx: number;
+    {
+      let preferred: number | undefined;
+      for (const [, val] of Object.entries(spec.inputs)) {
+        const av = (typeof val === "object" && val !== null && "getValue" in (val as object))
+          ? (val as aval<unknown>) : undefined;
+        if (av !== undefined) {
+          const where = pool.firstChunkContaining(av);
+          if (where !== undefined) { preferred = where; break; }
+        }
+      }
+      chunkIdx = preferred ?? Math.max(0, arena.attrs.chunkCount - 1);
+    }
+    const bucket = findOrCreateBucket(spec.effect, spec.textures, spec.pipelineState, chunkIdx, precomputedDescriptor);
+    // Phase 5c.3 — every RO carrying a derived-mode rule is registered
+    // on the bucket (lazy-promoting it to GPU-routed on the first
+    // call). ROs may carry DIFFERENT rules even when they share the
+    // bucket's `(effect, textureSet)` — each gets its own `ruleId`
+    // baked into the master-pool record and the partition kernel's
+    // dispatch switch picks the right body per record.
+    const collectedRules = spec.modeRules !== undefined ? collectRules(spec.modeRules) : [];
+    const roDescriptor = precomputedDescriptor ?? snapshotDescriptor(spec.pipelineState, sig);
+    let roComboId = 0;
+    if (collectedRules.length > 0) {
+      roComboId = registerCombo(bucket, collectedRules, roDescriptor);
+    } else if (bucket.gpuRouted) {
+      // An unruled RO joining an already-GPU-routed bucket needs a
+      // real combo to land on. Register the trivial all-fixed combo
+      // (every axis falls back to baseDescriptor) so this record's
+      // `comboId` doesn't silently alias to combo 0 (which is
+      // whichever combo was registered first — almost never the
+      // "no rules" intent).
+      roComboId = registerCombo(bucket, [], roDescriptor);
+    }
     // Phase 5c.2: route this RO to the bucket's slot covering its
     // current descriptor. ensureSlot creates a new slot on miss; the
-    // pipeline lookup hits the scene-level cache.
-    const roDescriptor = precomputedDescriptor ?? snapshotDescriptor(spec.pipelineState, sig);
-    const roSlot       = ensureSlot(bucket, roDescriptor);
+    // pipeline lookup hits the scene-level cache. For GPU-routed
+    // buckets the slot decision is made each frame on the GPU; we
+    // still pin the RO to slot 0 (declared) CPU-side so existing
+    // accounting paths (slotToRecord, dirty bookkeeping) keep
+    // working. The partition kernel overwrites both slots' draw
+    // tables every frame from the master.
+    const roSlot       = bucket.gpuRouted ? bucket.slots[0]! : ensureSlot(bucket, roDescriptor);
     const roSlotIdx    = bucket.slots.indexOf(roSlot);
     const fam = familyFor(spec.effect);
     const effectFields = fam.fieldsForEffect.get(spec.effect.id)!;
@@ -1944,7 +2988,7 @@ export function buildHeapScene(
     // index allocation + one upload.
     const indicesAval = asAval(spec.indices) as aval<Uint32Array>;
     const indicesArr = readPlain(spec.indices) as Uint32Array;
-    const idxAlloc = indexPool.acquire(device, arena.indices, indicesAval, indicesArr);
+    const idxAlloc = indexPool.acquire(device, arena.indices, indicesAval, bucket.chunkIdx, indicesArr);
 
     const localSlot = bucket.drawHeap.alloc();
     // Per-RO instancing: read `spec.instanceCount` (defaults to 1).
@@ -1977,7 +3021,7 @@ export function buildHeapScene(
         if (ruleForUniform(spec, f.name) !== undefined) {
           const dummyAval = AVal.constant<M44d>(M44d.zero);
           const ref = pool.acquire(
-            device, arena.attrs, dummyAval, M44d.zero,
+            device, arena.attrs, dummyAval, bucket.chunkIdx, M44d.zero,
             PACKER_MAT4.dataBytes, PACKER_MAT4.typeId, 1, PACKER_MAT4.pack,
           );
           perDrawRefs.set(f.name, ref);
@@ -2026,7 +3070,7 @@ export function buildHeapScene(
             : poolPlacementFor(f, value);
         }
         const ref = pool.acquire(
-          device, arena.attrs, av, value,
+          device, arena.attrs, av, bucket.chunkIdx, value,
           placement.dataBytes, placement.typeId, placement.length, placement.pack,
         );
         perDrawRefs.set(f.name, ref);
@@ -2049,6 +3093,51 @@ export function buildHeapScene(
     packBucketHeader(bucket, localSlot, perDrawRefs, layoutId);
     if (bucket.isAtlasBucket && spec.textures !== undefined && spec.textures.kind === "atlas") {
       packAtlasTextureFields(bucket, localSlot, spec.textures);
+      // Pair this addDraw with one atlas refcount bump. The spec's
+      // release closure (stored below, fired in removeDraw) decrements
+      // exactly once per add/remove cycle; without this incRef the
+      // refcount underflows when the same cached spec is re-introduced
+      // across multiple aset add/remove cycles (e.g., a tile flipping
+      // in and out of the heap-eligible subset).
+      //
+      // Falls back to a full re-acquire if the entry was already
+      // evicted (incRef returns false): in that case the spec's stored
+      // (pageId, origin, size) are stale and the new acquire's values
+      // overwrite them before packAtlasTextureFields is re-called.
+      if (atlasPool !== undefined) {
+        const ok = atlasPool.incRef(spec.textures.poolRef);
+        if (!ok) {
+          // Entry was evicted while the cached spec was idle in heap-
+          // remove state. Acquire a fresh sub-rect, redirect the spec
+          // (and the per-aval cell behind its release closure) to the
+          // new ref, and re-emit the drawHeader fields.
+          const acq = atlasPool.acquire(
+            spec.textures.page.format,
+            spec.textures.sourceAval as aval<ITexture>,
+            spec.textures.size.x, spec.textures.size.y,
+            { wantsMips: spec.textures.numMips > 1 },
+          );
+          (spec.textures as { pageId: number }).pageId = acq.pageId;
+          (spec.textures as { origin: V2f }).origin = acq.origin;
+          (spec.textures as { size: V2f }).size = acq.size;
+          (spec.textures as { numMips: number }).numMips = acq.numMips;
+          (spec.textures as { page: AtlasPage }).page = acq.page;
+          (spec.textures as { poolRef: number }).poolRef = acq.ref;
+          // The release closure captures a per-aval cell whose `ref`
+          // must track the LATEST acquired sub-rect; otherwise the
+          // closure releases a long-evicted ref (no-op leak).
+          if (spec.textures.repack !== undefined) {
+            // repack updates the per-aval cell to the new ref as a
+            // side effect of its own atlas-mark drain path. Re-using
+            // it here would free the entry we just acquired; instead
+            // mirror the same effect with a tiny helper attached to
+            // the spec at adapter time (`__retarget`).
+          }
+          const retarget = (spec.textures as unknown as { __retarget?: (ref: number) => void }).__retarget;
+          if (retarget !== undefined) retarget(acq.ref);
+          packAtlasTextureFields(bucket, localSlot, spec.textures);
+        }
+      }
       bucket.localAtlasReleases[localSlot] = spec.textures.release;
       bucket.localAtlasTextures[localSlot] = spec.textures;
       // Reactivity wire-up: subscribe to `sourceAval` (so sceneObj.inputChanged
@@ -2072,7 +3161,53 @@ export function buildHeapScene(
     const end = byteOff + bucket.layout.drawHeaderBytes;
     if (end > bucket.headerDirtyMax) bucket.headerDirtyMax = end;
 
-    {
+    if (bucket.gpuRouted) {
+      // Phase 5c.3 GPU routing: master pool is authoritative.
+      // Both slot[0] and slot[1] get the SAME accounting (counts,
+      // emit estimates, buffer capacities) — partition overwrites
+      // their GPU drawTables every frame, so per-slot CPU shadows
+      // are irrelevant. We still grow their buffers in lockstep so
+      // the scan dispatch shape covers every possible record.
+      const partition = bucket.partitionScene!;
+      const recIdx = partition.numRecords;
+      if (recIdx >= SCAN_MAX_RECORDS) {
+        throw new Error(
+          `heapScene: GPU-routed bucket exceeds SCAN_MAX_RECORDS (${SCAN_MAX_RECORDS})`,
+        );
+      }
+      // Pack the bucket's per-RO uniform refs (arena byte offsets) in
+      // the same order as `bucket.uniformOrder`. ROs whose perDrawRefs
+      // don't carry a given name (e.g. their effect doesn't declare
+      // it) get 0 — the kernel only reads refs through combo fns that
+      // gate on `r.comboId`, so an unread 0 is harmless.
+      const uniformRefs: number[] = (bucket.uniformOrder ?? []).map(
+        name => perDrawRefs.get(name) ?? 0,
+      );
+      partition.appendRecord(localSlot, idxAlloc.firstIndex, idxAlloc.count, instanceCount, roComboId, uniformRefs);
+      bucket.drawIdToRecord!.set(drawId, recIdx);
+      bucket.recordToDrawId![recIdx] = drawId;
+      bucket.drawIdToComboId!.set(drawId, roComboId);
+      // Master grew? Invalidate partition's bind group so it picks
+      // up the new masterBuf.  (rebindSlotDrawBufs nulls bindGroup.)
+      // grow() inside appendRecord already does this when capacity
+      // is exceeded; nothing to do here.
+      const numRecords = recIdx + 1;
+      const recBytes = numRecords * RECORD_BYTES;
+      const needBlocks = Math.max(1, Math.ceil(numRecords / SCAN_TILE_SIZE));
+      const emitDelta = idxAlloc.count * instanceCount;
+      for (const s of bucket.slots) {
+        s.drawTableBuf!.ensureCapacity(recBytes);
+        s.drawTableBuf!.setUsed(Math.max(s.drawTableBuf!.usedBytes, recBytes));
+        s.blockSumsBuf!.ensureCapacity(needBlocks * 4);
+        s.blockOffsetsBuf!.ensureCapacity(needBlocks * 4);
+        s.recordCount = numRecords;
+        s.totalEmitEstimate += emitDelta;
+        const newNumTiles = Math.max(1, Math.ceil(s.totalEmitEstimate / TILE_K));
+        s.firstDrawInTileBuf!.ensureCapacity((newNumTiles + 1) * 4);
+        s.scanDirty = true;
+      }
+      bucket.partitionDirty = true;
+    } else {
       const dtBuf = roSlot.drawTableBuf!;
       const recIdx = roSlot.recordCount;
       if (recIdx >= SCAN_MAX_RECORDS) {
@@ -2111,6 +3246,23 @@ export function buildHeapScene(
     drawIdToSlotIdx[drawId]   = roSlotIdx;
     drawIdToIndexAval[drawId] = indicesAval;
 
+    // ─── HeapDrawSpec.active wire-up ──────────────────────────────────
+    // Track the visibility aval (if any) and apply its initial value
+    // immediately. After this point, ticks on the aval are routed via
+    // `subscribeActive` → `activeDirty` and drained in `update()`.
+    if (spec.active !== undefined) {
+      drawIdToActiveAval.set(drawId, spec.active);
+      drawIdToOrigIndexCount.set(drawId, idxAlloc.count);
+      const initial = spec.active.getValue(outerTok);
+      subscribeActive(spec.active, drawId);
+      if (initial === false) {
+        // Apply the off state synchronously so the very first frame
+        // already skips this RO (no flash of un-gated geometry while
+        // we wait for the next update tick).
+        setEffectiveIndexCount(drawId, 0);
+      }
+    }
+
     // ─── Reactive rebucket: track PS-modeKey changes ────────────────
     // When any mode-axis aval marks (e.g. cullCval.value = 'front'),
     // schedule this RO for rebucket on the next update(). Today's
@@ -2144,34 +3296,18 @@ export function buildHeapScene(
     drawIdToModeTracker[drawId] = tracker;
     tracker.forEachLeaf((av) => subscribeModeLeaf(av, drawId));
 
-    // ─── GPU-eval mode rule registration (Task 2 Phase 5) ────────────
-    // If spec.modeRules.cull is GPU-flavoured, register the RO with
-    // the scene-wide dispatcher. Provide the arena byte offset of the
-    // RO's input uniform so the kernel reads from the right slot.
-    {
-      const cullRule = spec.modeRules?.cull;
-      const gpuRule = cullRule?.gpu;
-      if (gpuRule !== undefined) {
-        // Subscribe to the declared aval (if reactive) so the cull-
-        // mode flip propagates through the rule's CPU fallback
-        // recompute path.
-        if (typeof gpuRule.declared !== "string") {
-          subscribeModeLeaf(gpuRule.declared as aval<unknown>, drawId);
-        }
-      }
-
-      // ─── Pipeline pre-warm for derived-mode rules (5c.2) ──────────
-      // Enumerate the rule's possible outputs and pre-build the
-      // matching pipelines in the scene-level cache. Future cullModeC
-      // flips become cache hits — zero `createRenderPipeline` calls
-      // on the hot path.
-      if (cullRule !== undefined && cullRule.domain !== undefined && tracker.descriptor !== undefined) {
-        const fam = familyFor(spec.effect);
-        const baseDesc = tracker.descriptor;
-        for (const mode of cullRule.domain) {
-          if (mode === baseDesc.cullMode) continue; // already built
-          const variantDesc: PipelineStateDescriptor = { ...baseDesc, cullMode: mode };
-          getOrCreatePipeline(fam, bucket.layout, bucket.isAtlasBucket, variantDesc);
+    // ─── Derived-mode rule registration ────────────────────────────
+    // Subscribe to each rule's `declared` aval so the bucket's
+    // partition kernel re-dispatches when it changes. Slot pipelines
+    // for every (axis, declared) combination are pre-built eagerly
+    // in `initGpuRouting` (one per cartesian-product point), so
+    // declared flips are pipeline-cache hits.
+    if (spec.modeRules !== undefined) {
+      for (const rule of Object.values(spec.modeRules) as Array<DerivedModeRule<ModeAxis> | undefined>) {
+        if (rule === undefined) continue;
+        const d = rule.declared;
+        if (typeof d === "object" && d !== null && "getValue" in (d as object)) {
+          subscribeModeLeaf(d as aval<unknown>, drawId);
         }
       }
     }
@@ -2213,16 +3349,13 @@ export function buildHeapScene(
         const reg = registerRoDerivations(derivedScene, {}, {
           rules: ruleSubset,
           trafoAvals,
-          // A non-trafo rule leaf reads the uniform's data straight from this RO's
-          // drawHeader region in the arena (= its pool ref + the alloc-header pad).
-          // Only resolvable if the uniform was actually packed (i.e. it's a drawHeader
-          // field of the effect too) — undefined otherwise, which `resolveSource` rejects.
           hostUniformOffset: (n) => {
             const r = perDrawRefs.get(n);
             return r === undefined ? undefined : r + ALLOC_HEADER_PAD_TO;
           },
           outputOffset: (n) => outOffsetByName.get(n),
           drawHeaderBaseByte: 0,
+          chunkIdx: bucket.chunkIdx,
         });
         derivedByDrawId.set(drawId, reg);
       }
@@ -2234,9 +3367,13 @@ export function buildHeapScene(
   }
 
   function removeDraw(drawId: number): void {
+    __removeDrawCalls++;
     const bucket    = drawIdToBucket[drawId];
     const localSlot = drawIdToLocalSlot[drawId];
     if (bucket === undefined || localSlot === undefined) return;
+    // Tear down `active` subscription (if any) so its callback won't
+    // fire after the underlying drawTable record is gone.
+    unsubscribeActive(drawId);
     // §7: deregister this RO's derivation records and release slots.
     if (derivedScene !== undefined) {
       const reg = derivedByDrawId.get(drawId);
@@ -2245,13 +3382,54 @@ export function buildHeapScene(
         derivedByDrawId.delete(drawId);
       }
     }
-    {
+    if (bucket.gpuRouted) {
+      const partition = bucket.partitionScene!;
+      const recIdx = bucket.drawIdToRecord!.get(drawId);
+      const removedEntry = bucket.localEntries[localSlot];
+      // Read the EFFECTIVE indexCount from masterShadow (already 0 for
+      // an inactive draw via setEffectiveIndexCount). Using the original
+      // count from localEntries would double-subtract for inactive draws
+      // (whose contribution was already removed when active flipped false).
+      const effectiveIndexCount = recIdx !== undefined
+        ? partition.masterShadow[recIdx * partition.recordU32 + 3]!
+        : (removedEntry?.indexCount ?? 0);
+      const instanceCount = removedEntry?.instanceCount ?? 0;
+      const removedCount = effectiveIndexCount * instanceCount;
+      if (recIdx !== undefined) {
+        const moved = partition.removeRecord(recIdx);
+        if (moved >= 0) {
+          // The record at `moved` (the old tail) now lives at recIdx.
+          // Fix maps for the moved drawId.
+          const movedDrawId = bucket.recordToDrawId![moved]!;
+          bucket.drawIdToRecord!.set(movedDrawId, recIdx);
+          bucket.recordToDrawId![recIdx] = movedDrawId;
+          bucket.recordToDrawId![moved] = -1;
+        } else {
+          bucket.recordToDrawId![recIdx] = -1;
+        }
+        bucket.drawIdToRecord!.delete(drawId);
+      }
+      // Mirror the count + emit-estimate decrement across every slot
+      // (both share the master's accounting).
+      for (const s of bucket.slots) {
+        s.recordCount = partition.numRecords;
+        s.totalEmitEstimate = Math.max(0, s.totalEmitEstimate - removedCount);
+        s.scanDirty = true;
+      }
+      bucket.partitionDirty = true;
+    } else {
       const slotIdx = drawIdToSlotIdx[drawId];
       const slot = slotIdx !== undefined ? bucket.slots[slotIdx]! : bucket.slots[0]!;
       const removedEntry = bucket.localEntries[localSlot];
-      const removedCount = removedEntry !== undefined
-        ? removedEntry.indexCount * removedEntry.instanceCount
-        : 0;
+      const localSlotRec = slot.slotToRecord[localSlot];
+      // Effective (post-active) indexCount, read from shadow so that
+      // inactive draws contribute 0 here (their contribution was
+      // already removed when active flipped false).
+      const effectiveIndexCount = localSlotRec !== undefined && localSlotRec >= 0
+        ? slot.drawTableShadow![localSlotRec * RECORD_U32 + 3]!
+        : (removedEntry?.indexCount ?? 0);
+      const instanceCount = removedEntry?.instanceCount ?? 0;
+      const removedCount = effectiveIndexCount * instanceCount;
       slot.totalEmitEstimate = Math.max(0, slot.totalEmitEstimate - removedCount);
       // Swap-pop: move the last record into the freed slot, decrement
       // recordCount. firstEmit is GPU-rewritten by the next scan, so
@@ -2282,9 +3460,9 @@ export function buildHeapScene(
 
     // Release pool entries — refcount drops; if zero, allocation freed.
     const avals = bucket.localPerDrawAvals[localSlot];
-    if (avals !== undefined) for (const av of avals) pool.release(arena.attrs, av);
+    if (avals !== undefined) for (const av of avals) pool.release(arena.attrs, av, bucket.chunkIdx);
     const idxAval = drawIdToIndexAval[drawId];
-    if (idxAval !== undefined) indexPool.release(arena.indices, idxAval);
+    if (idxAval !== undefined) indexPool.release(arena.indices, idxAval, bucket.chunkIdx);
     const atlasRel = bucket.localAtlasReleases[localSlot];
     if (atlasRel !== undefined) atlasRel();
     // Drop atlas-aval ref (if any). When the last ref is dropped we
@@ -2458,11 +3636,19 @@ export function buildHeapScene(
         for (const drawId of dirty) {
           const tracker = drawIdToModeTracker[drawId];
           if (tracker === undefined) continue;
+          const bucket = drawIdToBucket[drawId];
+          // Phase 5c.3: GPU-routed buckets never reslot CPU-side.
+          // The partition kernel handles re-routing per frame.
+          // Just mark the bucket so the next encodeComputePrep
+          // dispatches partition.
+          if (bucket !== undefined && bucket.gpuRouted) {
+            bucket.partitionDirty = true;
+            continue;
+          }
           const oldKey = tracker.modeKey;
           if (!tracker.recompute()) continue;
           if (tracker.modeKey === oldKey) continue;
 
-          const bucket = drawIdToBucket[drawId];
           const localSlot = drawIdToLocalSlot[drawId];
           const oldSlotIdx = drawIdToSlotIdx[drawId];
           if (bucket === undefined || localSlot === undefined || oldSlotIdx === undefined) continue;
@@ -2534,12 +3720,27 @@ export function buildHeapScene(
       if (allocDirty.size > 0) {
         for (const av of allocDirty) {
           pool.repack(device, arena.attrs, av, av.getValue(tok));
-          const e = pool.entry(av);
-          if (e !== undefined) totalDirtyBytes += e.dataBytes;
+          totalDirtyBytes += pool.totalDataBytes(av);
         }
         allocDirty.clear();
       }
 
+      // 1c. HeapDrawSpec.active drain — flip drawTable.indexCount
+      //     between origIndexCount (visible) and 0 (hidden) for any RO
+      //     whose active aval ticked since last frame. Set is small in
+      //     steady state (only the ROs whose visibility actually
+      //     changed). No pool / arena / freelist activity.
+      if (activeDirty.size > 0) {
+        for (const did of activeDirty) {
+          const av = drawIdToActiveAval.get(did);
+          if (av === undefined) continue;
+          const a = av.getValue(tok);
+          const orig = drawIdToOrigIndexCount.get(did) ?? 0;
+          setEffectiveIndexCount(did, a ? orig : 0);
+        }
+        activeDirty.clear();
+      }
+
       // 1b. Atlas-texture aval reactivity: an `aval<ITexture>` that
       //     drives an atlas placement was marked. Repack the pool entry
       //     and rewrite the drawHeader fields of every (bucket, slot)
@@ -2625,6 +3826,9 @@ export function buildHeapScene(
       }
       // Phase 5c.2: each slot has its own drawTable + shadow. Upload
       // the dirty range of every slot, not just slots[0].
+      // Phase 5c.3: GPU-routed buckets skip this entirely — the
+      // partition kernel writes slot drawTables directly each frame.
+      if (bucket.gpuRouted) continue;
       for (const slot of bucket.slots) {
         if (slot.drawTableDirtyMax <= slot.drawTableDirtyMin) continue;
         const shadow = slot.drawTableShadow!;
@@ -2698,15 +3902,24 @@ export function buildHeapScene(
       stats.derivedPullMs   = _t1 - _t0;
       stats.derivedUploadMs = _t2 - _t1;
       stats.derivedEncodeMs = _t3 - _t2;
-      stats.derivedRecords  = derivedScene.records.recordCount;
+      stats.derivedRecords  = derivedScene.totalRecordCount;
     }
     let anyDirty = false;
     outer: for (const b of buckets) {
+      if (b.gpuRouted && b.partitionDirty) { anyDirty = true; break outer; }
       for (const s of b.slots) {
         if (s.scanDirty) { anyDirty = true; break outer; }
       }
     }
     if (!anyDirty) return;
+    // Phase 5c.3: per GPU-routed bucket — dispatch partition (its own
+    // compute pass), then copyBufferToBuffer slot counts into scan
+    // paramsBuf. Must happen BEFORE the shared scan pass below.
+    for (const b of buckets) {
+      if (b.gpuRouted && b.partitionDirty) {
+        dispatchPartition(b, enc, token);
+      }
+    }
     const pass = enc.beginComputePass({ label: "heapScene/scan" });
     for (const b of buckets) {
       for (let i = 0; i < b.slots.length; i++) {
@@ -2867,8 +4080,18 @@ export function buildHeapScene(
       let tilesChecked = 0, tilesBad = 0;
       let vidChecks = 0, vidBad = 0;
       const push = (s: string) => { if (issues.length < 60) issues.push(s); };
-      const arenaSize = arena.attrs.buffer.size;
-      const indicesSize = arena.indices.buffer.size;
+      // §3 v1: validateHeap currently only diagnoses chunk 0 — a
+      // multi-chunk-aware validator needs per-bucket-chunkIdx
+      // staging which is a bigger refactor; assert for now so
+      // multi-chunk callers don't get false-passes.
+      if (arena.attrs.chunkCount > 1 || arena.indices.chunkCount > 1) {
+        throw new Error(
+          "heapScene/validateHeap: multi-chunk arenas not yet supported by this validator (chunk-0-only). " +
+          "Run with the default chunk cap (no second chunk opened) for now.",
+        );
+      }
+      const arenaSize = arena.attrs.chunk(0).buffer.size;
+      const indicesSize = arena.indices.chunk(0).buffer.size;
 
       const enc = device.createCommandEncoder({ label: "validateHeap" });
       const stage = (src: GPUBuffer, size: number): GPUBuffer => {
@@ -2880,8 +4103,8 @@ export function buildHeapScene(
         return c;
       };
 
-      const arenaCopy = stage(arena.attrs.buffer, arenaSize);
-      const indicesCopy = indicesSize > 0 ? stage(arena.indices.buffer, indicesSize) : undefined;
+      const arenaCopy = stage(arena.attrs.chunk(0).buffer, arenaSize);
+      const indicesCopy = indicesSize > 0 ? stage(arena.indices.chunk(0).buffer, indicesSize) : undefined;
       type DC = {
         bucket: typeof buckets[number];
         drawHeap: GPUBuffer;
@@ -2967,7 +4190,26 @@ export function buildHeapScene(
             const length = arenaU32[refU32 + 1]!;
 
             if (!KNOWN_TYPE_IDS.has(typeId)) {
-              push(`bucket#${bucketIdx} slot=${slot} field='${f.name}' alloc@0x${ref.toString(16)} typeId=${typeId} unknown`);
+              // Dump the first 8 u32s of the alloc to help diagnose
+              // what wrote garbage onto the header. Also peek the
+              // FOUR u32s BEFORE the alloc to see if a neighbour
+              // overran into us.
+              const before = refU32 >= 4
+                ? `prev=[${arenaU32[refU32 - 4]},${arenaU32[refU32 - 3]},${arenaU32[refU32 - 2]},${arenaU32[refU32 - 1]}] `
+                : "";
+              const here = `here=[${arenaU32[refU32]},${arenaU32[refU32 + 1]},${arenaU32[refU32 + 2]},${arenaU32[refU32 + 3]},${arenaU32[refU32 + 4]},${arenaU32[refU32 + 5]},${arenaU32[refU32 + 6]},${arenaU32[refU32 + 7]}]`;
+              // Compare CPU shadow vs GPU read-back. Differ → GPU
+              // write corrupted; match → bug is in CPU-side write path
+              // OR the alloc never went through pool.acquire.
+              const shadowChunk = arena.attrs.chunk(0);
+              const shadowU32 = shadowChunk.peekShadowU32(ref, 8);
+              const shadowStr = `shadow=[${shadowU32[0]},${shadowU32[1]},${shadowU32[2]},${shadowU32[3]},${shadowU32[4]},${shadowU32[5]},${shadowU32[6]},${shadowU32[7]}]`;
+              const cpuMatches = shadowU32[0] === arenaU32[refU32]
+                && shadowU32[1] === arenaU32[refU32 + 1]
+                && shadowU32[2] === arenaU32[refU32 + 2]
+                && shadowU32[3] === arenaU32[refU32 + 3];
+              const verdict = cpuMatches ? "GPU=CPU (likely CPU-write bug)" : "GPU≠CPU (likely GPU-write corruption)";
+              push(`bucket#${bucketIdx} slot=${slot} field='${f.name}' alloc@0x${ref.toString(16)} typeId=${typeId} unknown ${verdict} ${before}${here} ${shadowStr}`);
               attrAllocsBad++;
               continue;
             }
@@ -3075,11 +4317,18 @@ export function buildHeapScene(
                 tilesBad++;
               }
             }
+            // The scan kernel intentionally writes `numRecords - 1` as the
+            // sentinel (not `numRecords`) — the render VS's binary search
+            // uses `hi = firstDrawInTile[_tileIdx + 1u]` as an *inclusive*
+            // upper bound, so the sentinel must point at the last valid
+            // record slot. See scanKernel.ts `buildTileIndex` for the
+            // full rationale.
+            const expectedSentinel = recordCount === 0 ? 0 : recordCount - 1;
             const sentinel = fdt[dc.numTiles]!;
             tilesChecked++;
-            if (sentinel !== recordCount) {
+            if (sentinel !== expectedSentinel) {
               push(`bucket#${bucketIdx} firstDrawInTile[${dc.numTiles}] sentinel ` +
-                `got=${sentinel} expected=${recordCount}`);
+                `got=${sentinel} expected=${expectedSentinel}`);
               tilesBad++;
             }
             dc.firstDrawInTile.unmap();
@@ -3170,8 +4419,12 @@ export function buildHeapScene(
       let emitsChecked = 0;
       const push = (s: string) => { if (issues.length < 30) issues.push(s); };
 
-      const arenaSize = arena.attrs.buffer.size;
-      const indicesSize = arena.indices.buffer.size;
+      // §3 v1: chunk-0-only like validateHeap.
+      if (arena.attrs.chunkCount > 1 || arena.indices.chunkCount > 1) {
+        throw new Error("heapScene/simulateDraws: multi-chunk arenas not yet supported (chunk-0-only).");
+      }
+      const arenaSize = arena.attrs.chunk(0).buffer.size;
+      const indicesSize = arena.indices.chunk(0).buffer.size;
 
       // Stage all buffers we'll need.
       const enc = device.createCommandEncoder({ label: "simulateDraws" });
@@ -3182,8 +4435,8 @@ export function buildHeapScene(
         enc.copyBufferToBuffer(src, 0, c, 0, size);
         return c;
       };
-      const arenaCopy = stage(arena.attrs.buffer, arenaSize);
-      const indicesCopy = indicesSize > 0 ? stage(arena.indices.buffer, indicesSize) : undefined;
+      const arenaCopy = stage(arena.attrs.chunk(0).buffer, arenaSize);
+      const indicesCopy = indicesSize > 0 ? stage(arena.indices.chunk(0).buffer, indicesSize) : undefined;
       type DC = {
         bucket: typeof buckets[number];
         drawHeap: GPUBuffer;
@@ -3453,19 +4706,25 @@ export function buildHeapScene(
       // cross-RO triangle symptom.
       const allocClaims: { ref: number; bytes: number; owner: string }[] = [];
 
+      // §3 v1: chunk-0-only (see validateHeap).
+      if (arena.attrs.chunkCount > 1 || arena.indices.chunkCount > 1) {
+        throw new Error("heapScene/checkTriangleCoherence: multi-chunk arenas not yet supported (chunk-0-only).");
+      }
+      const arenaBuf0 = arena.attrs.chunk(0).buffer;
+      const indicesBuf0 = arena.indices.chunk(0).buffer;
       // Stage arena + arena.indices once (shared across buckets).
       const arenaCopy = device.createBuffer({
-        size: arena.attrs.buffer.size,
+        size: arenaBuf0.size,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
       });
-      const indicesCopy = arena.indices.buffer.size > 0 ? device.createBuffer({
-        size: arena.indices.buffer.size,
+      const indicesCopy = indicesBuf0.size > 0 ? device.createBuffer({
+        size: indicesBuf0.size,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
       }) : undefined;
       {
         const enc = device.createCommandEncoder({ label: "checkTriangleCoherence.arena" });
-        enc.copyBufferToBuffer(arena.attrs.buffer, 0, arenaCopy, 0, arena.attrs.buffer.size);
-        if (indicesCopy !== undefined) enc.copyBufferToBuffer(arena.indices.buffer, 0, indicesCopy, 0, arena.indices.buffer.size);
+        enc.copyBufferToBuffer(arenaBuf0, 0, arenaCopy, 0, arenaBuf0.size);
+        if (indicesCopy !== undefined) enc.copyBufferToBuffer(indicesBuf0, 0, indicesCopy, 0, indicesBuf0.size);
         device.queue.submit([enc.finish()]);
       }
       await arenaCopy.mapAsync(GPUMapMode.READ);
@@ -3898,7 +5157,7 @@ export function buildHeapScene(
           { binding: 0, resource: { buffer: target.slots[0]!.drawTableBuf!.buffer } },
           { binding: 1, resource: { buffer: target.slots[0]!.firstDrawInTileBuf!.buffer } },
           { binding: 2, resource: { buffer: sampleBuf } },
-          { binding: 3, resource: { buffer: arena.indices.buffer } },
+          { binding: 3, resource: { buffer: arena.indices.chunk(target.chunkIdx).buffer } },
           { binding: 4, resource: { buffer: outBuf } },
           { binding: 5, resource: { buffer: paramBuf } },
         ],
@@ -3921,12 +5180,13 @@ export function buildHeapScene(
       sampleBuf.destroy(); outBuf.destroy(); paramBuf.destroy();
 
       // Read drawTable + indices for CPU expectation.
+      const idxBuf = arena.indices.chunk(target.chunkIdx).buffer;
       const indicesCopy2 = device.createBuffer({
-        size: arena.indices.buffer.size,
+        size: idxBuf.size,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
       });
       const enc2 = device.createCommandEncoder();
-      enc2.copyBufferToBuffer(arena.indices.buffer, 0, indicesCopy2, 0, arena.indices.buffer.size);
+      enc2.copyBufferToBuffer(idxBuf, 0, indicesCopy2, 0, idxBuf.size);
       device.queue.submit([enc2.finish()]);
       await indicesCopy2.mapAsync(GPUMapMode.READ);
       const indicesU32 = new Uint32Array(indicesCopy2.getMappedRange().slice(0));
@@ -3980,5 +5240,7 @@ export function buildHeapScene(
     },
   };
 
-  return { frame, update, encodeIntoPass, encodeComputePrep, addDraw, removeDraw, stats, dispose, _debug } as HeapScene;
+  const __addDrawCallsGetter = (): number => __addDrawCalls;
+  const __removeDrawCallsGetter = (): number => __removeDrawCalls;
+  return { frame, update, encodeIntoPass, encodeComputePrep, addDraw, removeDraw, stats, dispose, _debug, __addDrawCalls: __addDrawCallsGetter, __removeDrawCalls: __removeDrawCallsGetter } as HeapScene;
 }