@aardworx/wombat.rendering 0.9.33 → 0.19.0

package/dist/runtime/heapScene.js

@@ -52,10 +52,14 @@ import { DerivedUniformsScene, registerRoDerivations, deregisterRoDerivations, i
 import { packerForWgslType, PACKER_MAT4 } from "./heapScene/packers.js";
 import { HEAP_SCAN_WGSL, SCAN_TILE_SIZE, SCAN_WG_SIZE, SCAN_MAX_RECORDS, TILE_K, RECORD_U32, RECORD_BYTES, } from "./heapScene/scanKernel.js";
 import { GrowBuffer, MIN_BUFFER_BYTES, POW2, ALIGN16, } from "./heapScene/growBuffer.js";
-import { UniformPool, IndexPool, DrawHeap, AttributeArena, IndexAllocator, insertSortedFreeBlock, buildArenaState, arenaBytes, writeAttribute, asAval, isBufferView, asFloat32, ALLOC_HEADER_BYTES, ALLOC_HEADER_PAD_TO, ENC_V3F_TIGHT, SEM_POSITIONS, SEM_NORMALS, } from "./heapScene/pools.js";
+import { UniformPool, IndexPool, DrawHeap, AttributeArena, IndexAllocator, buildArenaState, arenaBytes, writeAttribute, asAval, isBufferView, asFloat32, ALLOC_HEADER_BYTES, ALLOC_HEADER_PAD_TO, ENC_V3F_TIGHT, SEM_POSITIONS, SEM_NORMALS, } from "./heapScene/pools.js";
 import { encodeModeKey } 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 {} from "./derivedModes/rule.js";
 import { addMarkingCallback } from "@aardworx/wombat.adaptive";
+import { analyseOutputSet, evaluateStructural, evaluateStructuralSet, stableStringify, } from "@aardworx/wombat.shader/ir";
 export function buildHeapScene(device, sig, initialDraws, opts = {}) {
     const atlasPool = opts.atlasPool;
     const colorAttachmentName = sig.colorNames[0];
@@ -82,7 +86,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
     // demand. Skip per-draw enumeration since aval-keyed sharing makes
     // the actual allocated size hard to predict (10K instanced draws
     // sharing the same Positions array → 1 alloc, not 10K).
-    const arena = buildArenaState(device, 64 * 1024, 16 * 1024, "heapScene", GPUBufferUsage.STORAGE);
+    const arena = buildArenaState(device, 64 * 1024, 16 * 1024, "heapScene", GPUBufferUsage.STORAGE, opts.maxChunkBytes);
     // ─── Per-draw global bookkeeping (sparse, indexed by drawId) ──────
     const drawIdToBucket = [];
     const drawIdToLocalSlot = [];
@@ -115,6 +119,96 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
      */
     const modeAvalToDrawIds = new Map();
     const modeAvalCallbacks = new Map();
+    // ─── 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();
+    const drawIdToOrigIndexCount = new Map();
+    const drawIdToActiveCallback = new Map();
+    const activeAvalToDrawIds = new Map();
+    const activeDirty = new Set();
+    function subscribeActive(av, drawId) {
+        let set = activeAvalToDrawIds.get(av);
+        if (set === undefined) {
+            set = new Set();
+            activeAvalToDrawIds.set(av, set);
+        }
+        set.add(drawId);
+        const cb = addMarkingCallback(av, () => { activeDirty.add(drawId); });
+        drawIdToActiveCallback.set(drawId, cb);
+    }
+    function unsubscribeActive(drawId) {
+        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, newIndexCount) {
+        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, drawId) {
         let set = modeAvalToDrawIds.get(av);
         if (set === undefined) {
@@ -307,7 +401,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         inputChanged(_t, o) {
             // Pool avals are stored as `aval<unknown>`; the IAdaptiveObject
             // identity matches.
-            if (pool.has(o)) {
+            if (pool.hasAny(o)) {
                 allocDirty.add(o);
                 return;
             }
@@ -331,11 +425,22 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
     // `enableDerivedUniforms: false` to opt out.
     const enableDerivedUniforms = opts.enableDerivedUniforms !== false;
     const derivedScene = 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) => {
+            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();
@@ -798,11 +903,12 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         // 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 = [
-            { 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];
@@ -815,7 +921,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             // binary search. Minimum one zero-record to satisfy WebGPU non-
             // zero size constraint when the bucket is empty.
             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: 6, resource: { buffer: s.firstDrawInTileBuf.buffer } });
+            entries.push({ binding: 4, resource: { buffer: s.drawTableBuf.buffer, offset: 0, size: dtBytes } }, { binding: 5, resource: { buffer: arena.indices.chunk(bucket.chunkIdx).buffer } }, { binding: 6, resource: { buffer: s.firstDrawInTileBuf.buffer } });
             s.renderBoundRecordCount = s.recordCount;
         }
         // Schema-driven texture + sampler entries. v1 user surface still
@@ -911,17 +1017,39 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             }
         }
     }
-    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).
     // Every member effect in the family shares one bucket per
@@ -958,6 +1086,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         });
         const slot = {
             pipeline, modeKey,
+            cpuDescriptor: descriptor,
             drawTableDirtyMin: Infinity, drawTableDirtyMax: 0,
             recordCount: 0, slotToRecord: [], recordToSlot: [],
             totalEmitEstimate: 0, scanDirty: false,
@@ -985,6 +1114,11 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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);
@@ -998,7 +1132,654 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
     }
     /** Side map from Bucket → family. Populated by findOrCreateBucket. */
     const familyForBucket = new WeakMap();
-    function findOrCreateBucket(effect, _textures, pipelineState, 
+    /** 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 = [
+        "cull", "frontFace", "topology",
+        "depthCompare", "depthWrite", "alphaToCoverage",
+    ];
+    function collectRules(modeRules) {
+        const out = [];
+        for (const axis of AXIS_ORDER) {
+            const r = modeRules[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, axis, value) {
+        switch (axis) {
+            case "cull": return { ...base, cullMode: value };
+            case "frontFace": return { ...base, frontFace: value };
+            case "topology": {
+                const topology = value;
+                return { ...base, topology, stripIndexFormat: stripFormatForTopology(topology) };
+            }
+            case "depthCompare":
+                return base.depth !== undefined
+                    ? { ...base, depth: { ...base.depth, compare: value } }
+                    : base;
+            case "depthWrite":
+                return base.depth !== undefined
+                    ? { ...base, depth: { ...base.depth, write: value } }
+                    : base;
+            case "alphaToCoverage": return { ...base, alphaToCoverage: value };
+            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;
+                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) {
+        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 = {
+        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(rule, value) {
+        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(rule, tok) {
+        const d = rule.declared;
+        if (d === undefined)
+            return 0;
+        const v = (typeof d === "object" && d !== null && "getValue" in d)
+            ? d.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) {
+        const tmpl = rule.expr.template;
+        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();
+    let nextAvalIdentity = 0;
+    function avalIdentity(av) {
+        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) {
+        const dec = rule.declared;
+        let dKey;
+        if (dec === undefined) {
+            dKey = "u";
+        }
+        else if (typeof dec === "object" && dec !== null && "getValue" in dec) {
+            dKey = `a${avalIdentity(dec)}`;
+        }
+        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, axis) {
+        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) {
+        const Tu32 = { kind: "Int", signed: false, width: 32 };
+        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(AXIS_ORDER.map(a => [a, axisValueOfDesc(base, a)]));
+        const activeAxes = 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;
+        });
+        const perAxisRules = new Map();
+        for (const axis of activeAxes) {
+            const list = [];
+            for (const hash of axisRuleOrder.get(axis)) {
+                const entry = rulesByAxis.get(axis).get(hash);
+                const declaredU32 = resolveDeclaredU32(entry.rule, AdaptiveToken.top);
+                const declaredConst = {
+                    kind: "Const", type: Tu32,
+                    value: { kind: "Int", value: declaredU32 >>> 0, signed: false },
+                };
+                const bakedBody = substituteReadInputInStmt(entry.body, "Uniform", "declared", declaredConst);
+                const symbolic = analyseOutputSet(bakedBody);
+                const env = new Map([["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);
+        }
+        const axisInfos = [];
+        for (const axis of activeAxes) {
+            const list = perAxisRules.get(axis) ?? [];
+            const dummyRule = { axis };
+            const byKey = new Map();
+            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]));
+            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 = [];
+        for (const info of axisInfos) {
+            const list = perAxisRules.get(info.axis);
+            const dummyRule = { axis: info.axis };
+            for (const p of list) {
+                const env = new Map([["declared", p.declaredU32]]);
+                const exprToAxisIdx = (e) => {
+                    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 = [];
+        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", 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", 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 = [];
+        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 = 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, slotDescs) {
+        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, axisRules, baseDesc) {
+        let cpuMigration;
+        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(AXIS_ORDER.map(a => [a, axisValueOfDesc(baseDesc, a)]));
+                const synthByKey = new Map();
+                for (const m of cpuMigration) {
+                    const axisFixedValues = new Map();
+                    const keyParts = [];
+                    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();
+        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 = [];
+        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();
+            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, enc, tok) {
+        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, _textures, pipelineState, chunkIdx, 
     /**
      * Optional precomputed descriptor. addDrawImpl passes this when
      * the spec carries `modeRules` so the bucket key reflects the
@@ -1010,12 +1791,13 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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;
@@ -1024,7 +1806,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         const drawHeapBuf = new GrowBuffer(device, `heapScene/${bk}/drawHeap`, GPUBufferUsage.STORAGE, Math.max(layout.drawHeaderBytes, 64));
         const drawHeap = new DrawHeap(drawHeapBuf, layout.drawHeaderBytes);
         const bucket = {
-            label: bk, textures: undefined, layout,
+            label: bk, textures: undefined, layout, chunkIdx,
             slots: [], // populated lazily by ensureSlot per modeKey
             bindGroup: null, // legacy field; slot.bindGroup is the real one
             drawHeap,
@@ -1038,6 +1820,19 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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);
         drawHeap.onResize(() => {
@@ -1219,6 +2014,11 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
     // 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.__addDrawCalls = () => __addDrawCalls;
+    sceneObj.__removeDrawCalls = () => __removeDrawCalls;
     function addDraw(spec) {
         let id = -1;
         sceneObj.evaluateAlways(AdaptiveToken.top, (tok) => {
@@ -1227,6 +2027,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         return id;
     }
     function addDrawImpl(spec, outerTok) {
+        __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.
@@ -1258,12 +2059,63 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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;
+        {
+            let preferred;
+            for (const [, val] of Object.entries(spec.inputs)) {
+                const av = (typeof val === "object" && val !== null && "getValue" in val)
+                    ? val : 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);
@@ -1272,7 +2124,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         // index allocation + one upload.
         const indicesAval = asAval(spec.indices);
         const indicesArr = readPlain(spec.indices);
-        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).
         const instanceCount = spec.instanceCount !== undefined
@@ -1305,7 +2157,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 // overwrites the arena data each frame the inputs are dirty.
                 if (ruleForUniform(spec, f.name) !== undefined) {
                     const dummyAval = AVal.constant(M44d.zero);
-                    const ref = pool.acquire(device, arena.attrs, dummyAval, M44d.zero, PACKER_MAT4.dataBytes, PACKER_MAT4.typeId, 1, PACKER_MAT4.pack);
+                    const ref = pool.acquire(device, arena.attrs, dummyAval, bucket.chunkIdx, M44d.zero, PACKER_MAT4.dataBytes, PACKER_MAT4.typeId, 1, PACKER_MAT4.pack);
                     perDrawRefs.set(f.name, ref);
                     perDrawAvals.push(dummyAval);
                     continue;
@@ -1347,7 +2199,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                         ? perInstancePlacementFor(f, value, instanceCount)
                         : poolPlacementFor(f, value);
                 }
-                const ref = pool.acquire(device, arena.attrs, av, value, placement.dataBytes, placement.typeId, placement.length, placement.pack);
+                const ref = pool.acquire(device, arena.attrs, av, bucket.chunkIdx, value, placement.dataBytes, placement.typeId, placement.length, placement.pack);
                 perDrawRefs.set(f.name, ref);
                 perDrawAvals.push(av);
             }
@@ -1366,6 +2218,47 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         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, spec.textures.size.x, spec.textures.size.y, { wantsMips: spec.textures.numMips > 1 });
+                    spec.textures.pageId = acq.pageId;
+                    spec.textures.origin = acq.origin;
+                    spec.textures.size = acq.size;
+                    spec.textures.numMips = acq.numMips;
+                    spec.textures.page = acq.page;
+                    spec.textures.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.__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
@@ -1390,7 +2283,50 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         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 = (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) {
@@ -1427,6 +2363,22 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         drawIdToLocalSlot[drawId] = localSlot;
         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
@@ -1455,34 +2407,19 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         });
         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, 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 = { ...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)) {
+                if (rule === undefined)
+                    continue;
+                const d = rule.declared;
+                if (typeof d === "object" && d !== null && "getValue" in d) {
+                    subscribeModeLeaf(d, drawId);
                 }
             }
         }
@@ -1529,16 +2466,13 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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);
             }
@@ -1548,10 +2482,14 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         return drawId;
     }
     function removeDraw(drawId) {
+        __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);
@@ -1560,13 +2498,56 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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
@@ -1600,10 +2581,10 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         const avals = bucket.localPerDrawAvals[localSlot];
         if (avals !== undefined)
             for (const av of avals)
-                pool.release(arena.attrs, av);
+                pool.release(arena.attrs, av, bucket.chunkIdx);
         const idxAval = drawIdToIndexAval[drawId];
         if (idxAval !== undefined)
-            indexPool.release(arena.indices, idxAval);
+            indexPool.release(arena.indices, idxAval, bucket.chunkIdx);
         const atlasRel = bucket.localAtlasReleases[localSlot];
         if (atlasRel !== undefined)
             atlasRel();
@@ -1778,12 +2759,20 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                     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)
@@ -1856,12 +2845,26 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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)
@@ -1948,6 +2951,10 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             }
             // 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;
@@ -2018,10 +3025,14 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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;
@@ -2031,6 +3042,14 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         }
         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++) {
@@ -2166,8 +3185,16 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             let vidChecks = 0, vidBad = 0;
             const push = (s) => { 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, size) => {
                 const c = device.createBuffer({
@@ -2177,8 +3204,8 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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;
             const TILE_K_LOCAL = 64;
             const dcs = [];
             for (const b of buckets) {
@@ -2259,7 +3286,26 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                         const typeId = arenaU32[refU32];
                         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;
                         }
@@ -2363,11 +3409,18 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                                 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();
@@ -2454,8 +3507,12 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             let emitsChecked = 0;
             const push = (s) => { 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" });
             const stage = (src, size) => {
@@ -2465,8 +3522,8 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                 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;
             const dcs = [];
             for (const b of buckets) {
                 if (b.slots[0].recordCount === 0 || b.slots[0].totalEmitEstimate === 0)
@@ -2717,20 +3774,26 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             // bytes to two avals → two ROs reading each other's data → the
             // cross-RO triangle symptom.
             const allocClaims = [];
+            // §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);
+                enc.copyBufferToBuffer(arenaBuf0, 0, arenaCopy, 0, arenaBuf0.size);
                 if (indicesCopy !== undefined)
-                    enc.copyBufferToBuffer(arena.indices.buffer, 0, indicesCopy, 0, arena.indices.buffer.size);
+                    enc.copyBufferToBuffer(indicesBuf0, 0, indicesCopy, 0, indicesBuf0.size);
                 device.queue.submit([enc.finish()]);
             }
             await arenaCopy.mapAsync(GPUMapMode.READ);
@@ -3167,7 +4230,7 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                     { 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 } },
                 ],
@@ -3191,12 +4254,13 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             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));
@@ -3245,6 +4309,8 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             return { emitsChecked: sampleCount, gpuMismatches, issues };
         },
     };
-    return { frame, update, encodeIntoPass, encodeComputePrep, addDraw, removeDraw, stats, dispose, _debug };
+    const __addDrawCallsGetter = () => __addDrawCalls;
+    const __removeDrawCallsGetter = () => __removeDrawCalls;
+    return { frame, update, encodeIntoPass, encodeComputePrep, addDraw, removeDraw, stats, dispose, _debug, __addDrawCalls: __addDrawCallsGetter, __removeDrawCalls: __removeDrawCallsGetter };
 }
 //# sourceMappingURL=heapScene.js.map