@aardworx/wombat.rendering 0.19.7 → 0.19.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.7",
+  "version": "0.19.9",
   "description": "WebGPU rendering layer for the Wombat TypeScript stack — RenderObject/RenderTask/runtime + window glue, port of Aardvark.Rendering's lower layers on top of WebGPU and wombat.shader.",
   "license": "MIT",
   "author": "krauthaufen",

package/src/runtime/heapAdapter.ts

@@ -27,13 +27,14 @@
 // `ro.samplers.count <= 1` are classifier invariants.
 
 import { type aval, type AdaptiveToken } from "@aardworx/wombat.adaptive";
-import type { IBuffer, HostBufferSource } from "../core/buffer.js";
-import type { BufferView } from "../core/bufferView.js";
+import { IBuffer, type HostBufferSource } from "../core/buffer.js";
+import { BufferView } from "../core/bufferView.js";
 import { ITexture, type HostTextureSource } from "../core/texture.js";
 import { ISampler } from "../core/sampler.js";
 import type { RenderObject } from "../core/renderObject.js";
 import { asAttributeProvider, asUniformProvider } from "../core/provider.js";
 import type { HeapDrawSpec, HeapTextureSet } from "./heapScene.js";
+import { isBufferView } from "./heapScene/pools.js";
 import { compileHeapEffect } from "./heapEffect.js";
 import { AtlasPool } from "./textureAtlas/atlasPool.js";
 
@@ -50,13 +51,29 @@ function asUint32(data: HostBufferSource): Uint32Array {
   return new Uint32Array(data);
 }
 
+// Widen 16-bit indices to u32 (the heap's indexStorage is u32). Copy, not a
+// reinterpret view — each u16 index becomes a u32 element.
+function widenU16(data: HostBufferSource): Uint32Array {
+  const u16 = data instanceof Uint16Array
+    ? data
+    : ArrayBuffer.isView(data)
+      ? new Uint16Array(data.buffer, data.byteOffset, data.byteLength / 2)
+      : new Uint16Array(data);
+  return Uint32Array.from(u16);
+}
+
 // IndexPool keys on aval identity → ROs sharing the same
 // `ro.indices.buffer` must produce the SAME downstream
 // `aval<Uint32Array>`. A fresh `.map(…)` per RO would defeat the
 // pool's identity-based sharing and balloon GPU memory (e.g. 11K
 // spheres each allocating their own copy of the 6144-index buffer
 // → 270 MB).
-const indicesAvalCache = new WeakMap<aval<IBuffer>, aval<Uint32Array>>();
+// Keyed by (buffer aval, baseVertex). baseVertex is baked into the index
+// VALUES (index[i] + baseVertex), so a buffer drawn with two different
+// baseVertex offsets needs two distinct transcoded arrays — but the common
+// case (baseVertex 0, or per-primitive index buffers that aren't shared)
+// keeps one entry per buffer and preserves the pool's identity sharing.
+const indicesAvalCache = new WeakMap<aval<IBuffer>, Map<number, aval<Uint32Array>>>();
 
 // Per-aval shared "current pool ref" cell. ROs that share an
 // `aval<ITexture>` (and therefore one AtlasPool entry) all read
@@ -71,20 +88,79 @@ function currentRefCellFor(av: aval<ITexture>, initial: number): { ref: number }
   }
   return c;
 }
-function indicesAvalFor(ibAval: aval<IBuffer>): aval<Uint32Array> {
-  let av = indicesAvalCache.get(ibAval);
+function indicesAvalFor(ibAval: aval<IBuffer>, indexFormat: GPUIndexFormat, baseVertex: number): aval<Uint32Array> {
+  let byBase = indicesAvalCache.get(ibAval);
+  if (byBase === undefined) {
+    byBase = new Map();
+    indicesAvalCache.set(ibAval, byBase);
+  }
+  let av = byBase.get(baseVertex);
   if (av === undefined) {
     av = ibAval.map((ib: IBuffer) => {
       if (ib.kind !== "host") {
         throw new Error("heapAdapter: index buffer flipped to native GPUBuffer; classifier should have caught this");
       }
-      return asUint32(ib.data);
+      const u32 = indexFormat === "uint16" ? widenU16(ib.data) : asUint32(ib.data);
+      if (baseVertex === 0) return u32;
+      // Fold baseVertex into the index values so the megacall decode
+      // (vid = indexStorage[...]) lands on the right vertex with no
+      // extra record field. Copy (don't mutate the shared view).
+      const out = new Uint32Array(u32.length);
+      for (let i = 0; i < u32.length; i++) out[i] = u32[i]! + baseVertex;
+      return out;
     });
-    indicesAvalCache.set(ibAval, av);
+    byBase.set(baseVertex, av);
   }
   return av;
 }
 
+// Byte view over a host buffer source (for the de-interleave gather).
+function bytesOf(data: HostBufferSource): Uint8Array {
+  if (data instanceof Uint8Array) return data;
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return new Uint8Array(data);
+}
+
+// De-interleaved (tight, offset-0) views, keyed by (source buffer aval,
+// offset, stride) so ROs sharing one interleaved buffer + the same attribute
+// share a single gathered allocation.
+const deinterleaveCache = new WeakMap<aval<IBuffer>, Map<string, aval<IBuffer>>>();
+
+/**
+ * Make a tight, offset-0 BufferView the arena can ingest. Tight/broadcast
+ * views pass through unchanged; interleaved or offset views are gathered
+ * into a fresh packed host buffer (every `stride` bytes from `offset`,
+ * `byteSize` each) wrapped as a new whole-buffer view.
+ */
+function tightenBufferView(bv: BufferView): BufferView {
+  if (bv.singleValue !== undefined) return bv; // broadcast → lowered to a uniform
+  const byteSize = bv.elementType.byteSize;
+  const offset = bv.offset ?? 0;
+  const stride = (bv.stride !== undefined && bv.stride > 0) ? bv.stride : byteSize;
+  if (offset === 0 && stride === byteSize) return bv; // already tight
+  let byKey = deinterleaveCache.get(bv.buffer);
+  if (byKey === undefined) { byKey = new Map(); deinterleaveCache.set(bv.buffer, byKey); }
+  const key = `${offset}:${stride}:${byteSize}`;
+  let tight = byKey.get(key);
+  if (tight === undefined) {
+    tight = bv.buffer.map((ib: IBuffer): IBuffer => {
+      if (ib.kind !== "host") {
+        throw new Error("heapAdapter: interleaved attribute buffer flipped to native GPUBuffer; classifier should have caught this");
+      }
+      const src = bytesOf(ib.data);
+      const count = Math.max(0, Math.floor((src.byteLength - offset - byteSize) / stride) + 1);
+      const out = new Uint8Array(count * byteSize);
+      for (let i = 0; i < count; i++) {
+        const s = offset + i * stride;
+        out.set(src.subarray(s, s + byteSize), i * byteSize);
+      }
+      return IBuffer.fromHost(out);
+    });
+    byKey.set(key, tight);
+  }
+  return BufferView.ofBuffer(tight, bv.elementType);
+}
+
 /**
  * Pull `(format, width, height, mipLevelCount)` out of an ITexture so
  * we can run Tier-S eligibility against it. Both variants expose this:
@@ -197,7 +273,7 @@ export function renderObjectToHeapSpec(
   const inputs: { [name: string]: aval<unknown> | unknown } = {};
   for (const a of schema.attributes) {
     const bv = vAttr.tryGet(a.name);
-    if (bv !== undefined) inputs[a.name] = bv;
+    if (bv !== undefined) inputs[a.name] = isBufferView(bv) ? tightenBufferView(bv) : bv;
   }
   const pullUniform = (name: string): void => {
     if (Object.prototype.hasOwnProperty.call(inputs, name)) return;
@@ -222,17 +298,25 @@ export function renderObjectToHeapSpec(
       instanceAttributes = {};
       for (const n of names) {
         const bv = iAttr.tryGet(n);
-        if (bv !== undefined) instanceAttributes[n] = bv;
+        if (bv !== undefined) instanceAttributes[n] = isBufferView(bv) ? tightenBufferView(bv) : bv;
       }
     }
   }
 
+  // DrawCall: read once (snapshot — like instanceCount/vertexCount).
+  //    Slice offsets fold in here: firstIndex → record indexStart,
+  //    indexCount → record slice length, baseVertex → baked into the
+  //    transcoded index values (so it needs no record field).
+  const dc = ro.drawCall.getValue(token);
+  const baseVertex = dc.kind === "indexed" ? dc.baseVertex : 0;
+
   // 2. Indices: BufferView → aval<Uint32Array>. Map the underlying
-  //    IBuffer aval; the heap path's IndexPool will key on this aval.
-  if (ro.indices === undefined) {
-    throw new Error("heapAdapter: RenderObject without indices not supported (heap is indexed-only)");
-  }
-  const indices: aval<Uint32Array> = indicesAvalFor(ro.indices.buffer);
+  //    IBuffer aval; the heap path's IndexPool will key on this aval
+  //    (and on baseVertex, since it's baked into the values).
+  //    Non-indexed ROs (no `ro.indices`) carry no index aval — the spec
+  //    then sets `vertexCount` and the megacall decodes the vertex directly.
+  const indices: aval<Uint32Array> | undefined =
+    ro.indices !== undefined ? indicesAvalFor(ro.indices.buffer, ro.indices.elementType.indexFormat ?? "uint32", baseVertex) : undefined;
 
   // 3. Texture/sampler: single-pair v1. The Sg compile layer binds
   //    each texture aval under both `name` and `${name}_view` so the
@@ -355,12 +439,21 @@ export function renderObjectToHeapSpec(
     );
   }
 
-  // 4. DrawCall: read once. Classifier validates fields are heap-
-  //    compatible (indexed, instanceCount=1, zero offsets).
-  const dc = ro.drawCall.getValue(token);
-  if (dc.kind !== "indexed") {
-    throw new Error("heapAdapter: non-indexed drawCall; classifier should have caught this");
+  // 4. DrawCall geometry. Classifier validates fields are heap-
+  //    compatible (instanceCount≥1, firstInstance=0, non-indexed firstVertex=0).
+  if (dc.kind === "indexed" && indices === undefined) {
+    throw new Error("heapAdapter: indexed drawCall without indices");
+  }
+  if (dc.kind === "non-indexed" && indices !== undefined) {
+    throw new Error("heapAdapter: non-indexed drawCall with an index buffer");
   }
+  // Indexed → carry the index aval + the firstIndex/indexCount slice (folded
+  // into the record's indexStart/indexCount; baseVertex is already baked into
+  // the index values). Non-indexed → carry the vertex count; the megacall uses
+  // the local vertex index directly (no index lookup).
+  const geom = dc.kind === "indexed"
+    ? { indices: indices!, firstIndex: dc.firstIndex, indexCount: dc.indexCount }
+    : { vertexCount: dc.vertexCount };
 
   return {
     effect: ro.effect,
@@ -368,7 +461,7 @@ export function renderObjectToHeapSpec(
     inputs,
     ...(instanceAttributes !== undefined ? { instanceAttributes } : {}),
     ...(dc.instanceCount > 1 ? { instanceCount: dc.instanceCount } : {}),
-    indices,
+    ...geom,
     ...(textures !== undefined ? { textures } : {}),
     ...(ro.modeRules !== undefined ? { modeRules: ro.modeRules } : {}),
     // Pass `active` through unforced so the heap path can subscribe

package/src/runtime/heapEffect.ts

@@ -839,5 +839,5 @@ export function megacallSearchPrelude(): string {
   // to receive them as `u32` parameters — module-scope `var<private>`
   // is rejected by some WGSL parsers (Safari/WebKit), so we thread the
   // values through helper signatures instead.
-  return `  let _tileIdx = emitIdx >> 6u;\n  var lo: u32 = firstDrawInTile[_tileIdx];\n  var hi: u32 = firstDrawInTile[_tileIdx + 1u];\n  loop {\n    if (lo >= hi) { break; }\n    let _mid = (lo + hi + 1u) >> 1u;\n    if (drawTable[_mid * 5u] <= emitIdx) { lo = _mid; } else { hi = _mid - 1u; }\n  }\n  let _slot = lo;\n  let _firstEmit  = drawTable[_slot * 5u + 0u];\n  let heap_drawIdx: u32 = drawTable[_slot * 5u + 1u];\n  let _indexStart = drawTable[_slot * 5u + 2u];\n  let _indexCount = drawTable[_slot * 5u + 3u];\n  let _local      = emitIdx - _firstEmit;\n  let instId: u32 = _local / _indexCount;\n  let vid: u32    = indexStorage[_indexStart + (_local % _indexCount)];\n`;
+  return `  let _tileIdx = emitIdx >> 6u;\n  var lo: u32 = firstDrawInTile[_tileIdx];\n  var hi: u32 = firstDrawInTile[_tileIdx + 1u];\n  loop {\n    if (lo >= hi) { break; }\n    let _mid = (lo + hi + 1u) >> 1u;\n    if (drawTable[_mid * 5u] <= emitIdx) { lo = _mid; } else { hi = _mid - 1u; }\n  }\n  let _slot = lo;\n  let _firstEmit  = drawTable[_slot * 5u + 0u];\n  let heap_drawIdx: u32 = drawTable[_slot * 5u + 1u];\n  let _indexStart = drawTable[_slot * 5u + 2u];\n  let _indexCount = drawTable[_slot * 5u + 3u];\n  let _local      = emitIdx - _firstEmit;\n  let instId: u32 = _local / _indexCount;\n  let _li: u32    = _local % _indexCount;\n  var vid: u32    = _li;\n  if (_indexStart != 0xffffffffu) { vid = indexStorage[_indexStart + _li]; }\n`;
 }

package/src/runtime/heapEligibility.ts

@@ -185,27 +185,17 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     return AVal.constant(false);
   }
 
-  // 2. BufferView stride wedge — only tight per-vertex/per-instance
-  //    layouts (and broadcasts via `singleValue` / stride 0) are
-  //    ingested. The shader-side cyclic addressing (`vid % length`,
-  //    `iidx % length`) makes broadcasts a degenerate length-1 case,
-  //    so we don't reject them here — but interleaved strides remain
-  //    unsupported. Per-instance attributes follow the same rule.
-  let strideBlocked = false;
-  const checkStride = (v: BufferView): void => {
-    const stride = v.stride ?? v.elementType.byteSize;
-    const isBroadcast = v.singleValue !== undefined || stride === 0;
-    if (!isBroadcast && stride !== v.elementType.byteSize) strideBlocked = true;
-  };
-  for (const v of attrViews(asAttributeProvider(ro.vertexAttributes))) checkStride(v);
-  if (ro.instanceAttributes !== undefined) {
-    for (const v of attrViews(asAttributeProvider(ro.instanceAttributes))) checkStride(v);
-  }
-  if (strideBlocked) return AVal.constant(false);
+  // 2. Interleaved / offset attributes are handled by de-interleaving at
+  //    ingest (heapAdapter.tightenBufferView gathers a tight, offset-0
+  //    copy keyed by (buffer, offset, stride) so sharing is preserved), so
+  //    no stride/offset wedge remains. Broadcasts (singleValue / stride 0)
+  //    still pass through as a degenerate length-1 case.
 
-  // 3. Index-format wedge — heap stores indices as u32.
-  if (ro.indices !== undefined && ro.indices.elementType.indexFormat !== "uint32") {
-    return AVal.constant(false);
+  // 3. Index-format wedge — heap stores indices as u32; u16 is widened
+  //    to u32 at ingest (heapAdapter.widenU16). Anything else is rejected.
+  if (ro.indices !== undefined) {
+    const fmt = ro.indices.elementType.indexFormat;
+    if (fmt !== "uint32" && fmt !== "uint16") return AVal.constant(false);
   }
 
   const buffers  = bufferAvals(ro);
@@ -229,29 +219,25 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     for (const av of textures) if (!isHeapServableTexture(av.getValue(token))) return false;
     for (const av of samplers) if (!isHeapServableSampler(av.getValue(token))) return false;
     const dc = ro.drawCall.getValue(token);
-    if (dc.kind !== "indexed") return false;
     if (dc.instanceCount < 1) return false;
-    if (dc.baseVertex !== 0) return false;
-    if (dc.firstIndex !== 0) return false;
     if (dc.firstInstance !== 0) return false;
-    // Whole-buffer wedge: the heap ingests the ENTIRE index + vertex
-    // buffers for an RO (IndexPool/AttributeArena copy `arr.length`,
-    // not the drawCall slice). An RO that consumes only a PREFIX of a
-    // shared index buffer (firstIndex=0 but indexCount < bufferCount —
-    // e.g. one glyph in a multi-glyph text run whose glyphs share a
-    // single atlas index buffer) would therefore drag the rest of the
-    // buffer into its draw: the trailing indices reference vertices
-    // past this RO's range (including the next sub-mesh's / this
-    // glyph's band vertices), painting stray triangles. Until the heap
-    // honours the drawCall slice, only ROs that own their whole index
-    // buffer are eligible. Single-mesh ROs (indexCount === bufferCount)
-    // pass; shared-atlas slices fall to the legacy ScenePass.
-    if (ro.indices !== undefined) {
-      const ib = ro.indices.buffer.getValue(token);
-      if (ib.kind === "host") {
-        const idxBufCount = ib.sizeBytes >>> 2; // u32 indices
-        if (dc.indexCount !== idxBufCount) return false;
-      }
+    if (dc.kind === "indexed") {
+      if (ro.indices === undefined) return false;
+      // Offsets and shared sub-buffer slices are all eligible now: the heap
+      // still ingests the WHOLE index + vertex buffers (one shared arena
+      // allocation per buffer aval — sharing is the heap's whole point), but
+      // the record now honours the drawCall slice. firstIndex folds into the
+      // record's indexStart, indexCount becomes the slice length (so a single
+      // glyph of a multi-glyph run reads only its run of indices), and
+      // baseVertex is baked into the transcoded index values at ingest
+      // (heapAdapter.indicesAvalFor). No drawCall wedge remains here.
+    } else {
+      // Non-indexed: the megacall uses the local vertex index directly, so a
+      // prefix read is safe (vid = 0..vertexCount-1). firstVertex must be 0 —
+      // a non-indexed vertex offset would need a per-record field (the index
+      // bake-in trick doesn't apply with no index buffer), so it's deferred.
+      if (ro.indices !== undefined) return false;
+      if (dc.firstVertex !== 0) return false;
     }
     return true;
   });

package/src/runtime/heapIrBuilders.ts

@@ -354,11 +354,21 @@ export function buildMegacallPrelude(emitIdx: Expr): { stmts: Stmt[]; locals: Me
   stmts.push({ kind: "Declare", var: localOff, init: { kind: "Expr", value: sub(emitIdx, varExpr(firstEmit), Tu32) } });
   // let instId = _local / _indexCount;
   stmts.push({ kind: "Declare", var: instId, init: { kind: "Expr", value: div(varExpr(localOff), varExpr(indexCount), Tu32) } });
-  // let vid = indexStorage[_indexStart + (_local % _indexCount)];
+  // Non-indexed records carry _indexStart == 0xffffffff (HEAP_NONINDEXED): the
+  // vertex is the local index directly; otherwise decode through indexStorage.
+  //   let vid = (_indexStart == 0xffffffff)
+  //     ? (_local % _indexCount)
+  //     : indexStorage[_indexStart + (_local % _indexCount)];
+  const liExpr = (): Expr => mod(varExpr(localOff), varExpr(indexCount), Tu32);
   stmts.push({
     kind: "Declare",
     var: vid,
-    init: { kind: "Expr", value: item(indexStorage, add(varExpr(indexStart), mod(varExpr(localOff), varExpr(indexCount), Tu32), Tu32), Tu32) },
+    init: { kind: "Expr", value: select(
+      eqU32(varExpr(indexStart), constU32(0xffffffff)),
+      liExpr(),
+      item(indexStorage, add(varExpr(indexStart), liExpr(), Tu32), Tu32),
+      Tu32,
+    ) },
   });
 
   return { stmts, locals: { heapDrawIdx, instId, vid } };

package/src/runtime/heapScene.ts

@@ -143,6 +143,11 @@ import {
  * Geometry triple. Tightly-packed Float32 positions / normals (3
  * floats per vertex) plus Uint32 indices.
  */
+/** drawTable `firstIndex` sentinel marking a non-indexed record: the megacall
+ *  prelude then uses the local vertex index directly (no indexStorage lookup).
+ *  Must match the literal in heapEffect.ts's `megacallSearchPrelude`. */
+export const HEAP_NONINDEXED = 0xffffffff;
+
 export interface HeapGeometry {
   readonly positions: Float32Array;
   readonly normals:   Float32Array;
@@ -453,8 +458,24 @@ export interface HeapDrawSpec {
   /**
    * Index buffer for this draw. Indices live in their own `INDEX`-
    * usage `GPUBuffer` (WebGPU forces this), separate from the arena.
+   * Omit for a NON-INDEXED draw — then `vertexCount` is required and the
+   * megacall uses the local vertex index directly (no index-buffer lookup,
+   * no index-pool allocation). See the megacall prelude's `vid` select.
+   */
+  readonly indices?: aval<Uint32Array> | Uint32Array;
+  /** Vertex count for a non-indexed draw (when `indices` is omitted). */
+  readonly vertexCount?: number;
+  /**
+   * Optional index slice into a (possibly shared) index buffer. The heap
+   * still allocates/uploads the WHOLE `indices` buffer once per aval (so N
+   * draws sharing it cost one allocation), but this draw emits only
+   * `[firstIndex, firstIndex+indexCount)`. Folds into the record's
+   * indexStart (`alloc.firstIndex + firstIndex`) and indexCount. Omit for a
+   * whole-buffer draw (defaults: firstIndex 0, indexCount = buffer length).
+   * (baseVertex is handled upstream by baking it into the index values.)
    */
-  readonly indices: aval<Uint32Array> | Uint32Array;
+  readonly firstIndex?: number;
+  readonly indexCount?: number;
   /**
    * Optional texture set. When present, adds a `texture_2d<f32>` at
    * binding 4 and a sampler at binding 5; the FS must declare them.
@@ -3005,10 +3026,21 @@ export function buildHeapScene(
 
     // Indices live in their own INDEX-usage buffer (WebGPU constraint).
     // Aval-keyed: 19K instanced clones of the same mesh share one
-    // index allocation + one upload.
-    const indicesAval = asAval(spec.indices) as aval<Uint32Array>;
-    const indicesArr = readPlain(spec.indices) as Uint32Array;
-    const idxAlloc = indexPool.acquire(device, arena.indices, indicesAval, bucket.chunkIdx, indicesArr);
+    // index allocation + one upload. NON-INDEXED draws (spec.indices
+    // omitted) skip the index pool entirely: the drawTable record stores
+    // firstIndex = HEAP_NONINDEXED (sentinel) and indexCount = vertexCount,
+    // and the megacall prelude uses the local vertex index directly.
+    const hasIndices = spec.indices !== undefined;
+    const indicesAval = hasIndices ? (asAval(spec.indices!) as aval<Uint32Array>) : undefined;
+    const idxAlloc = hasIndices
+      ? indexPool.acquire(device, arena.indices, indicesAval!, bucket.chunkIdx, readPlain(spec.indices!) as Uint32Array)
+      : undefined;
+    // Emit count per instance + the firstIndex field written to the record.
+    // Slice: emit only [firstIndex, firstIndex+indexCount) of the (shared,
+    // whole-buffer) index allocation. firstIndex folds into indexStart;
+    // indexCount defaults to the whole buffer.
+    const emitCount = hasIndices ? (spec.indexCount ?? idxAlloc!.count) : (spec.vertexCount ?? 0);
+    const firstIndexField = hasIndices ? (idxAlloc!.firstIndex + (spec.firstIndex ?? 0)) : HEAP_NONINDEXED;
 
     const localSlot = bucket.drawHeap.alloc();
     // Per-RO instancing: read `spec.instanceCount` (defaults to 1).
@@ -3101,7 +3133,7 @@ export function buildHeapScene(
     bucket.localPosRefs[localSlot] = perDrawRefs.get("Positions");
     bucket.localNorRefs[localSlot] = perDrawRefs.get("Normals");
     bucket.localEntries[localSlot] = {
-      indexCount: idxAlloc.count, firstIndex: idxAlloc.firstIndex, instanceCount,
+      indexCount: emitCount, firstIndex: firstIndexField, instanceCount,
     };
     bucket.localToDrawId[localSlot] = drawId;
     bucket.drawSlots.add(localSlot);
@@ -3217,7 +3249,7 @@ export function buildHeapScene(
       const uniformRefs: number[] = (bucket.uniformOrder ?? []).map(
         name => perDrawRefs.get(name) ?? 0,
       );
-      partition.appendRecord(localSlot, idxAlloc.firstIndex, idxAlloc.count, instanceCount, roComboId, uniformRefs);
+      partition.appendRecord(localSlot, firstIndexField, emitCount, instanceCount, roComboId, uniformRefs);
       bucket.drawIdToRecord!.set(drawId, recIdx);
       bucket.recordToDrawId![recIdx] = drawId;
       bucket.drawIdToComboId!.set(drawId, roComboId);
@@ -3228,7 +3260,7 @@ export function buildHeapScene(
       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;
+      const emitDelta = emitCount * instanceCount;
       for (const s of bucket.slots) {
         s.drawTableBuf!.ensureCapacity(recBytes);
         s.drawTableBuf!.setUsed(Math.max(s.drawTableBuf!.usedBytes, recBytes));
@@ -3261,15 +3293,15 @@ export function buildHeapScene(
       // firstEmit is GPU-overwritten by the prefix-sum pass; 0 is fine.
       shadow[recIdx * RECORD_U32 + 0] = 0;
       shadow[recIdx * RECORD_U32 + 1] = localSlot;
-      shadow[recIdx * RECORD_U32 + 2] = idxAlloc.firstIndex;
-      shadow[recIdx * RECORD_U32 + 3] = idxAlloc.count;
+      shadow[recIdx * RECORD_U32 + 2] = firstIndexField;
+      shadow[recIdx * RECORD_U32 + 3] = emitCount;
       shadow[recIdx * RECORD_U32 + 4] = instanceCount;
       roSlot.recordCount = recIdx + 1;
       roSlot.slotToRecord[localSlot] = recIdx;
       roSlot.recordToSlot[recIdx] = localSlot;
       if (byteOff < roSlot.drawTableDirtyMin) roSlot.drawTableDirtyMin = byteOff;
       if (byteOff + RECORD_BYTES > roSlot.drawTableDirtyMax) roSlot.drawTableDirtyMax = byteOff + RECORD_BYTES;
-      roSlot.totalEmitEstimate += idxAlloc.count * instanceCount;
+      roSlot.totalEmitEstimate += emitCount * instanceCount;
       const newNumTiles = Math.max(1, Math.ceil(roSlot.totalEmitEstimate / TILE_K));
       roSlot.firstDrawInTileBuf!.ensureCapacity((newNumTiles + 1) * 4);
       roSlot.scanDirty = true;
@@ -3286,7 +3318,7 @@ export function buildHeapScene(
     // `subscribeActive` → `activeDirty` and drained in `update()`.
     if (spec.active !== undefined) {
       drawIdToActiveAval.set(drawId, spec.active);
-      drawIdToOrigIndexCount.set(drawId, idxAlloc.count);
+      drawIdToOrigIndexCount.set(drawId, emitCount);
       const initial = spec.active.getValue(outerTok);
       subscribeActive(spec.active, drawId);
       if (initial === false) {
@@ -5157,7 +5189,9 @@ export function buildHeapScene(
           let _instCount  = drawTable[_slot * 5u + 4u];
           let _local      = emitIdx - _firstEmit;
           let _instId     = _local / _indexCount;
-          let _vid        = indexStorage[_indexStart + (_local % _indexCount)];
+          let _li         = _local % _indexCount;
+          var _vid: u32   = _li;
+          if (_indexStart != 0xffffffffu) { _vid = indexStorage[_indexStart + _li]; }
           let base = i * 8u;
           outRows[base + 0u] = _slot;
           outRows[base + 1u] = _drawIdx;