@aardworx/wombat.rendering 0.9.32 → 0.18.1

package/dist/runtime/heapScene.js

@@ -52,12 +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 { GpuDerivedModesScene } from "./derivedModes/gpuDispatcher.js";
-import { U32_TO_CULL } from "./derivedModes/gpuKernel.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];
@@ -84,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 = [];
@@ -125,12 +127,6 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
             modeAvalCallbacks.set(av, addMarkingCallback(av, () => {
                 for (const id of set)
                     dirtyModeKeyDrawIds.add(id);
-                // Mark the GPU mode-rules dispatcher dirty too — at least one
-                // of those drawIds may carry a GPU rule whose input changed.
-                // The dispatch path checks consumeDirty() before encoding, so
-                // an unrelated aval mark (e.g. Color change on hover) leaves
-                // the kernel quiet.
-                gpuModesScene?.markDirty();
             }));
         }
         set.add(drawId);
@@ -315,7 +311,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;
             }
@@ -339,21 +335,31 @@ 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();
-    // ─── GPU-eval mode rules (Task 2 Phase 5, narrow) ─────────────────
-    // Lazily allocated on first registration; one dispatcher per scene.
-    let gpuModesScene;
-    /** Last per-RO GPU output we routed to a bucket. Diff against
-     *  newly-readback values to decide rebuckets without re-bucketing
-     *  un-changed ROs. */
-    const gpuModesLastKey = new Map();
+    // (Phase 5c.2: the per-RO routing decision is CPU-driven via
+    // tracker.recompute(). The previous GpuDerivedModesScene dispatch +
+    // mapAsync readback path is gone — its output was never consumed
+    // after the rebucket-via-spec-patch approach was removed. If a
+    // future rule's inputs only exist GPU-side, a partition-kernel-
+    // driven scatter would put routing on the GPU; see Phase 5c.3.)
     /** The derived-uniform rule for a uniform binding on this RO, if any: an explicit
      *  `derivedUniform(...)` value in `spec.inputs`, or a standard trafo recipe by name
      *  (recipes apply only when their base-trafo leaves are actually bound on this RO —
@@ -807,11 +813,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];
@@ -824,7 +831,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
@@ -920,17 +927,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
@@ -967,6 +996,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,
@@ -994,6 +1024,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);
@@ -1007,7 +1042,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
@@ -1019,12 +1701,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;
@@ -1033,7 +1716,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,
@@ -1047,6 +1730,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(() => {
@@ -1267,16 +1963,64 @@ 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);
-        if (spec.modeRules !== undefined && drawId < 8) {
-            console.debug(`[heapScene] addDraw drawId=${drawId} bucket=${bucket.label} slotIdx=${roSlotIdx}/${bucket.slots.length} cullMode=${roDescriptor.cullMode} recordCount=${roSlot.recordCount}`);
-        }
         const fam = familyFor(spec.effect);
         const effectFields = fam.fieldsForEffect.get(spec.effect.id);
         // Indices live in their own INDEX-usage buffer (WebGPU constraint).
@@ -1284,7 +2028,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
@@ -1317,7 +2061,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;
@@ -1359,7 +2103,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);
             }
@@ -1402,7 +2146,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) {
@@ -1467,46 +2254,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 && gpuRule.kernel === "flipCullByDeterminant") {
-                const inputRef = perDrawRefs.get(gpuRule.inputUniform);
-                if (inputRef !== undefined) {
-                    if (gpuModesScene === undefined)
-                        gpuModesScene = new GpuDerivedModesScene(device);
-                    gpuModesScene.registerRo(drawId, inputRef, gpuRule.declared);
-                    // If declared is reactive (e.g. a shared cullModeC cval),
-                    // subscribe so flipping it marks the dispatcher dirty.
-                    // Plain values: no subscription needed.
-                    if (typeof gpuRule.declared !== "string") {
-                        subscribeModeLeaf(gpuRule.declared, drawId);
-                    }
-                    if (drawId < 3 || drawId % 20 === 0) {
-                        console.debug(`[heapScene] GPU rule registered drawId=${drawId} input='${gpuRule.inputUniform}' ref=${inputRef} declared=${typeof gpuRule.declared === "string" ? gpuRule.declared : "<aval>"}`);
-                    }
-                }
-                else {
-                    console.warn(`[heapScene] GPU rule input '${gpuRule.inputUniform}' not in spec.inputs for drawId=${drawId}; rule disabled`);
-                }
-            }
-            // ─── 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);
                 }
             }
         }
@@ -1553,16 +2313,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);
             }
@@ -1584,7 +2341,38 @@ 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];
+            const removedCount = removedEntry !== undefined
+                ? removedEntry.indexCount * removedEntry.instanceCount
+                : 0;
+            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];
@@ -1624,10 +2412,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();
@@ -1681,10 +2469,6 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         }
         drawIdToModeTracker[drawId] = undefined;
         dirtyModeKeyDrawIds.delete(drawId);
-        if (gpuModesScene !== undefined) {
-            gpuModesScene.deregisterRo(drawId);
-            gpuModesLastKey.delete(drawId);
-        }
         stats.totalDraws--;
         stats.geometryBytes = arenaBytes(arena);
         // GC the bucket if it just emptied (common after reactive
@@ -1806,12 +2590,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)
@@ -1884,9 +2676,7 @@ 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();
             }
@@ -1976,6 +2766,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;
@@ -1991,15 +2785,13 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
      * begin/end — caller owns the pass. Used by both the convenience
      * `frame()` below and (eventually) the hybrid render task.
      */
-    let _encodeLogged = false;
     function encodeIntoPass(pass) {
         let curBg = null;
-        let drawCount = 0;
-        const slotInfo = [];
         for (const b of buckets) {
-            for (let i = 0; i < b.slots.length; i++) {
-                const slot = b.slots[i];
-                slotInfo.push(`b=${b.label.slice(7, 15)} s=${i} rc=${slot.recordCount} bg=${slot.bindGroup !== undefined ? 'Y' : 'N'} ib=${slot.indirectBuf !== undefined ? 'Y' : 'N'}`);
+            // Phase 5c.2: iterate the bucket's slots, drawIndirect per
+            // non-empty slot. Empty slots draw zero (skipped to save the
+            // setPipeline/setBindGroup overhead).
+            for (const slot of b.slots) {
                 if (slot.recordCount === 0)
                     continue;
                 const bg = slot.bindGroup;
@@ -2008,16 +2800,10 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
                     curBg = bg;
                 }
                 pass.setPipeline(slot.pipeline);
-                if (slot.indirectBuf !== undefined) {
+                if (slot.indirectBuf !== undefined)
                     pass.drawIndirect(slot.indirectBuf, 0);
-                    drawCount++;
-                }
             }
         }
-        if (!_encodeLogged) {
-            console.debug(`[heapScene] encode: ${drawCount} drawIndirect; slots:`, slotInfo);
-            _encodeLogged = true;
-        }
     }
     /**
      * Compute prep — must be called BEFORE `beginRenderPass`. For each
@@ -2030,40 +2816,6 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
      * we just swap the bind group + dispatch shape per bucket.
      */
     function encodeComputePrep(enc, token) {
-        // GPU-eval derived-mode rules (Task 2 Phase 5): dispatch the
-        // hardcoded determinant-flip-cull kernel + start readback.
-        // Resolved on the next frame's update() — one-frame lag for the
-        // first appearance of a state transition. CPU fallback runs at
-        // addDraw time so the initial bucket assignment is still correct.
-        if (gpuModesScene !== undefined
-            && gpuModesScene.registered > 0
-            && gpuModesScene.consumeDirty()) {
-            // Dirty-gate: skip the kernel + readback when no rule input
-            // changed since the last dispatch. Unrelated avals (Color on
-            // hover, etc.) don't trigger dirty, so steady state has zero
-            // GPU mode-rule work per frame.
-            const numROs = nextDrawId; // upper bound; sparse entries are skipped via 0xFFFFFFFF sentinel
-            gpuModesScene.dispatch(arena.attrs.buffer, numROs, enc);
-            // mapAsync the staging buffer AFTER the caller's submit. The
-            // microtask queued by Promise.resolve() runs after the current
-            // synchronous block — by which time `frame()` has already
-            // submitted the enc. Without this deferral, mapAsync fires
-            // before submit and WebGPU rejects the next dispatch's
-            // copy-to-staging with "buffer used in submit while mapped".
-            // No readback: v1's patch-spec.modeRules approach broke
-            // reactivity (a second cullModeC flip stopped re-bucketing
-            // because the patched constant closure never produces a new
-            // modeKey). The CPU fallback is authoritative for now —
-            // tracker.recompute drives the rebucket flow correctly.
-            //
-            // Phase 5c.2 (no-readback by design): pre-warm all slot
-            // pipelines at scene-build via static analysis; kernel writes
-            // per-RO slot index; partition kernel produces per-slot
-            // indirect args; encode iterates fixed slots. The
-            // GpuDerivedModesScene kernel dispatch stays here as a
-            // demonstration of the GPU path — its output is currently
-            // unused but proves the kernel runs against arena data.
-        }
         // §7: derived-uniforms dispatch first — writes into per-bucket
         // drawHeap regions before the scan reads anything. One dispatcher
         // per bucket; constituents are shared so dirty state propagates
@@ -2088,10 +2840,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;
@@ -2101,6 +2857,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++) {
@@ -2197,7 +2961,6 @@ export function buildHeapScene(device, sig, initialDraws, opts = {}) {
         arena.indices.destroy();
         for (const b of buckets)
             destroyBucketResources(b);
-        gpuModesScene?.dispose();
     }
     // Test-only escape hatch for inspecting megacall bucket state. Not
     // part of the public API surface — keep cast at use-site.
@@ -2237,8 +3000,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({
@@ -2248,8 +3019,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) {
@@ -2525,8 +3296,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) => {
@@ -2536,8 +3311,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)
@@ -2788,20 +3563,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);
@@ -3238,7 +4019,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 } },
                 ],
@@ -3262,12 +4043,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));