@aardworx/wombat.rendering 0.19.8 → 0.19.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aardworx/wombat.rendering",
-  "version": "0.19.8",
+  "version": "0.19.10",
   "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/resources/preparedRenderObject.ts

@@ -29,8 +29,12 @@ import {
   type aval,
   HashMap,
   cval,
+  AVal,
 } from "@aardworx/wombat.adaptive";
 import type { Type } from "@aardworx/wombat.shader/ir";
+import { isDerivedRule } from "../runtime/derivedUniforms/rule.js";
+import { STANDARD_DERIVED_RULES, STANDARD_TRAFO_LEAVES } from "../runtime/derivedUniforms/recipes.js";
+import { interpretExpr } from "../runtime/derivedUniforms/cpuEval.js";
 import { prepareAdaptiveBuffer } from "./adaptiveBuffer.js";
 import { prepareAdaptiveTexture } from "./adaptiveTexture.js";
 import { prepareAdaptiveSampler } from "./adaptiveSampler.js";
@@ -785,11 +789,14 @@ function mergeUniformInputs(
   let merged = HashMap.empty<string, aval<unknown>>();
   for (const f of block.fields) {
     const u = user.tryGet(f.name);
-    if (u !== undefined) { merged = merged.add(f.name, u); continue; }
+    if (u !== undefined) { merged = merged.add(f.name, resolveUniform(u, user, bindings)); continue; }
     const getter = bindings?.[f.name];
-    if (getter === undefined) continue;
-    const v = getter();
-    merged = merged.add(f.name, isAval(v) ? (v as aval<unknown>) : cval(v));
+    if (getter !== undefined) { merged = merged.add(f.name, resolveUniform(getter(), user, bindings)); continue; }
+    // Standard derived recipe by name (ModelViewTrafo, …) — derive it CPU-side
+    // here just as the heap path derives it on the GPU, so the legacy path
+    // serves the same declared uniforms.
+    const recipe = STANDARD_DERIVED_RULES.get(f.name);
+    if (recipe !== undefined) merged = merged.add(f.name, ruleToAval(recipe, user, bindings));
   }
   return merged;
 }
@@ -798,6 +805,46 @@ function isAval(v: unknown): boolean {
   return typeof v === "object" && v !== null && typeof (v as { getValue?: unknown }).getValue === "function";
 }
 
+// A uniform binding value is either an aval/constant or a derivedUniform RULE.
+// Rules are evaluated on CPU (cpuEval) in double precision and exposed as a
+// derived aval — the legacy per-RO path's answer to the heap's §7 compute pass.
+type UProvider = import("../core/index.js").IUniformProvider;
+type Bindings = Readonly<Record<string, () => unknown>> | undefined;
+
+function resolveUniform(v: unknown, user: UProvider, bindings: Bindings): aval<unknown> {
+  if (isDerivedRule(v)) return ruleToAval(v, user, bindings);
+  return isAval(v) ? (v as aval<unknown>) : cval(v);
+}
+
+function ruleToAval(rule: import("../runtime/derivedUniforms/rule.js").DerivedRule, user: UProvider, bindings: Bindings): aval<unknown> {
+  return AVal.custom((token: AdaptiveToken) =>
+    interpretExpr(rule.ir, (leaf) => readLeaf(leaf, user, bindings, token)),
+  ) as aval<unknown>;
+}
+
+// Resolve a `u.<name>` leaf to its current value, recursing through nested
+// rules / standard recipes. Reading the leaf aval's value under `token`
+// registers the dependency, so the derived aval re-evaluates reactively.
+function readLeaf(name: string, user: UProvider, bindings: Bindings, token: AdaptiveToken): unknown {
+  const evalRule = (r: unknown): unknown =>
+    interpretExpr((r as import("../runtime/derivedUniforms/rule.js").DerivedRule).ir, (n) => readLeaf(n, user, bindings, token));
+  const lookup = (n: string): unknown => {
+    const u = user.tryGet(n);
+    if (u !== undefined) return isDerivedRule(u) ? evalRule(u) : isAval(u) ? (u as aval<unknown>).getValue(token) : u;
+    const getter = bindings?.[n];
+    if (getter !== undefined) { const v = getter(); return isDerivedRule(v) ? evalRule(v) : isAval(v) ? (v as aval<unknown>).getValue(token) : v; }
+    const recipe = STANDARD_DERIVED_RULES.get(n);
+    if (recipe !== undefined) return evalRule(recipe);
+    return undefined;
+  };
+  const direct = lookup(name);
+  if (direct !== undefined) return direct;
+  // Standard recipes read short trafo leaves (Model / View / Proj) that the RO
+  // binds under ModelTrafo / ViewTrafo / ProjTrafo — alias them like the heap.
+  const alias = STANDARD_TRAFO_LEAVES.get(name);
+  return alias !== undefined ? lookup(alias) : undefined;
+}
+
 function ubAsBlock(ub: import("../core/index.js").UniformBlockInfo): import("../core/index.js").UniformBlockInfo {
   return ub;
 }

package/src/runtime/derivedUniforms/cpuEval.ts

@@ -0,0 +1,249 @@
+// CPU interpreter for derived-uniform rule IR (a wombat.shader `Expr`).
+//
+// Evaluates a `derivedUniform(u => …)` rule in DOUBLE precision (M44d / V3d /
+// …) — no df32 dual-float trick, no GPU constituent slots. The heap path
+// compiles rules into a §7 GPU compute pass (f32, df32 for the inverse trick);
+// here we just interpret the IR with f64 host math (`M44d.inverse()` is exact
+// enough that the backward-storage trick is unnecessary), and `writeField`
+// narrows the result to f32 at pack time.
+//
+// Used by the legacy per-RO uniform path so derived uniforms work on ROs that
+// aren't heap-eligible (a storage buffer, 2+ textures, …). The evaluator is a
+// standalone `Expr → value` function so other CPU rule paths can reuse it.
+
+import type { Expr, Type } from "@aardworx/wombat.shader/ir";
+import { V2d, V3d, V4d, M22d, M33d, M44d } from "@aardworx/wombat.base";
+
+/** A value produced by the interpreter (host doubles). */
+export type EvalValue = number | boolean | V2d | V3d | V4d | M22d | M33d | M44d;
+
+/** Resolve a `u.<name>` leaf to its current host value (Trafo3d | M44f | M44d |
+ *  V*f | number | …) — or undefined if unbound. */
+export type LeafReader = (name: string) => unknown;
+
+// ── runtime classification ───────────────────────────────────────────────
+function isVec(v: unknown): v is V2d | V3d | V4d {
+  return v instanceof V2d || v instanceof V3d || v instanceof V4d;
+}
+function isMat(v: unknown): v is M22d | M33d | M44d {
+  return v instanceof M22d || v instanceof M33d || v instanceof M44d;
+}
+function data(v: EvalValue): Float64Array { return (v as unknown as { _data: Float64Array })._data; }
+function num(v: EvalValue): number {
+  if (typeof v === "number") return v;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  throw new Error("derived eval: expected scalar, got " + describe(v));
+}
+function describe(v: unknown): string {
+  if (isVec(v)) return "vec" + data(v as EvalValue).length;
+  if (isMat(v)) return "mat";
+  return typeof v;
+}
+function vecOf(d: ArrayLike<number>): V2d | V3d | V4d {
+  switch (d.length) {
+    case 2: return new V2d(d[0]!, d[1]!);
+    case 3: return new V3d(d[0]!, d[1]!, d[2]!);
+    case 4: return new V4d(d[0]!, d[1]!, d[2]!, d[3]!);
+    default: throw new Error("derived eval: bad vector arity " + d.length);
+  }
+}
+
+// ── leaf coercion (by the IR leaf type) ──────────────────────────────────
+function toM44(raw: unknown): M44d {
+  if (raw instanceof M44d) return raw;
+  const o = raw as { forward?: unknown; _data?: ArrayLike<number> };
+  if (o && o.forward !== undefined) return toM44(o.forward);          // Trafo3d → forward
+  if (o && o._data !== undefined && o._data.length >= 16) return M44d.fromArray(o._data); // M44f
+  throw new Error("derived eval: leaf is not a mat4: " + describe(raw));
+}
+function upperLeft3(m: M44d): M33d {
+  const d = data(m); // row-major r*4+c
+  return M33d.fromArray([d[0]!, d[1]!, d[2]!, d[4]!, d[5]!, d[6]!, d[8]!, d[9]!, d[10]!]);
+}
+function toM33(raw: unknown): M33d {
+  if (raw instanceof M33d) return raw;
+  const o = raw as { forward?: unknown; _data?: ArrayLike<number> };
+  if (raw instanceof M44d) return upperLeft3(raw);
+  if (o && o.forward !== undefined) return upperLeft3(toM44(o.forward));
+  if (o && o._data !== undefined && o._data.length === 9) return M33d.fromArray(o._data);
+  if (o && o._data !== undefined && o._data.length >= 16) return upperLeft3(toM44(raw));
+  throw new Error("derived eval: leaf is not a mat3: " + describe(raw));
+}
+function toM22(raw: unknown): M22d {
+  if (raw instanceof M22d) return raw;
+  const o = raw as { _data?: ArrayLike<number> };
+  if (o && o._data !== undefined && o._data.length === 4) return M22d.fromArray(o._data);
+  throw new Error("derived eval: leaf is not a mat2: " + describe(raw));
+}
+function toVec(raw: unknown, n: 2 | 3 | 4): V2d | V3d | V4d {
+  if (isVec(raw)) return raw;
+  const o = raw as { _data?: ArrayLike<number> };
+  if (o && o._data !== undefined) {
+    const d = o._data;
+    return vecOf(n === 2 ? [d[0]!, d[1]!] : n === 3 ? [d[0]!, d[1]!, d[2]!] : [d[0]!, d[1]!, d[2]!, d[3]!]);
+  }
+  throw new Error("derived eval: leaf is not a vec" + n + ": " + describe(raw));
+}
+function coerce(raw: unknown, t: Type): EvalValue {
+  switch (t.kind) {
+    case "Matrix": return t.rows === 4 ? toM44(raw) : t.rows === 3 ? toM33(raw) : toM22(raw);
+    case "Vector": return toVec(raw, t.dim);
+    case "Float":  return Number(raw);
+    case "Int":    return Math.trunc(Number(raw));
+    case "Bool":   return Boolean(raw);
+    default: throw new Error("derived eval: unsupported leaf type " + t.kind);
+  }
+}
+
+// ── arithmetic over scalar / vector / matrix ─────────────────────────────
+function negate(x: EvalValue): EvalValue {
+  if (typeof x === "number") return -x;
+  if (isVec(x) || isMat(x)) return remap(x, (a) => -a);
+  throw new Error("derived eval: cannot negate " + describe(x));
+}
+/** Map a vector/matrix's components through `f`, returning the same shape. */
+function remap(v: V2d | V3d | V4d | M22d | M33d | M44d, f: (x: number) => number): EvalValue {
+  const d = data(v); const out = new Array<number>(d.length);
+  for (let i = 0; i < d.length; i++) out[i] = f(d[i]!);
+  return isMat(v) ? matOf(out) : vecOf(out);
+}
+function matOf(d: ArrayLike<number>): M22d | M33d | M44d {
+  switch (d.length) {
+    case 4:  return M22d.fromArray(d);
+    case 9:  return M33d.fromArray(d);
+    case 16: return M44d.fromArray(d);
+    default: throw new Error("derived eval: bad matrix arity " + d.length);
+  }
+}
+/** Element-wise binary op, broadcasting a scalar against a vector/matrix. */
+function elementwise(a: EvalValue, b: EvalValue, f: (x: number, y: number) => number): EvalValue {
+  if (typeof a === "number" && typeof b === "number") return f(a, b);
+  if (isVec(a) || isMat(a)) {
+    const da = data(a);
+    const out = new Array<number>(da.length);
+    if (typeof b === "number") { for (let i = 0; i < da.length; i++) out[i] = f(da[i]!, b); }
+    else { const db = data(b as EvalValue); for (let i = 0; i < da.length; i++) out[i] = f(da[i]!, db[i]!); }
+    return isMat(a) ? matOf(out) : vecOf(out);
+  }
+  if (typeof a === "number" && (isVec(b) || isMat(b))) {
+    const db = data(b); const out = new Array<number>(db.length);
+    for (let i = 0; i < db.length; i++) out[i] = f(a, db[i]!);
+    return isMat(b) ? matOf(out) : vecOf(out);
+  }
+  throw new Error(`derived eval: cannot combine ${describe(a)} and ${describe(b)}`);
+}
+/** `Mul` node — scalar·scalar, scalar·(vec|mat) broadcast, or component-wise
+ *  vec·vec (mat·mat / mat·vec / vec·mat have their own node kinds). */
+function mulNode(a: EvalValue, b: EvalValue): EvalValue {
+  if (typeof a === "number" && isMat(b)) return (b as M44d).mul(a) as EvalValue;
+  if (typeof b === "number" && isMat(a)) return (a as M44d).mul(b) as EvalValue;
+  return elementwise(a, b, (x, y) => x * y);
+}
+function vlen(v: EvalValue): number {
+  if (typeof v === "number") return Math.abs(v);
+  const d = data(v); let s = 0; for (let i = 0; i < d.length; i++) s += d[i]! * d[i]!;
+  return Math.sqrt(s);
+}
+function dot(a: EvalValue, b: EvalValue): number {
+  const da = data(a), db = data(b); let s = 0;
+  for (let i = 0; i < da.length; i++) s += da[i]! * db[i]!;
+  return s;
+}
+function normalize(v: EvalValue): EvalValue {
+  const len = vlen(v); return len === 0 ? v : remap(v as V3d, (x) => x / len);
+}
+function swizzle(v: EvalValue, comps: readonly string[]): EvalValue {
+  const d = data(v); const idx = (c: string): number => ({ x: 0, y: 1, z: 2, w: 3 }[c] ?? 0);
+  if (comps.length === 1) return d[idx(comps[0]!)]!;
+  return vecOf(comps.map((c) => d[idx(c)]!));
+}
+function convertMatrix(v: EvalValue, t: Type): EvalValue {
+  if (t.kind === "Matrix" && t.rows === 3 && v instanceof M44d) return upperLeft3(v);
+  if (isMat(v)) return v; // identity-ish convert
+  throw new Error("derived eval: ConvertMatrix on " + describe(v));
+}
+
+// ── intrinsics (vec-componentwise where natural) ─────────────────────────
+const UNARY: Record<string, (x: number) => number> = {
+  sin: Math.sin, cos: Math.cos, tan: Math.tan, abs: Math.abs, floor: Math.floor,
+  ceil: Math.ceil, sqrt: Math.sqrt, exp: Math.exp, log: Math.log,
+  exp2: (x) => 2 ** x, log2: Math.log2, sign: Math.sign, fract: (x) => x - Math.floor(x),
+};
+const BINARY: Record<string, (x: number, y: number) => number> = {
+  min: Math.min, max: Math.max, pow: (x, y) => x ** y, atan2: Math.atan2,
+};
+function intrinsic(name: string, a: EvalValue[]): EvalValue {
+  if (UNARY[name]) return typeof a[0] === "number" ? UNARY[name]!(a[0]) : remap(a[0] as V3d, UNARY[name]!);
+  if (BINARY[name]) return elementwise(a[0]!, a[1]!, BINARY[name]!);
+  switch (name) {
+    case "normalize": return normalize(a[0]!);
+    case "length":    return vlen(a[0]!);
+    case "dot":       return dot(a[0]!, a[1]!);
+    case "cross":     return (a[0] as V3d).cross(a[1] as V3d);
+    case "distance":  return vlen(elementwise(a[0]!, a[1]!, (x, y) => x - y));
+    case "step":      return elementwise(a[1]!, a[0]!, (x, edge) => (x < edge ? 0 : 1));
+    case "clamp":     return elementwise(elementwise(a[0]!, a[1]!, Math.max), a[2]!, Math.min);
+    case "mix": {     // a + (b - a) * t
+      const diff = elementwise(a[1]!, a[0]!, (y, x) => y - x);
+      const scaled = elementwise(diff, a[2]!, (d, t) => d * t);
+      return elementwise(a[0]!, scaled, (x, s) => x + s);
+    }
+    case "reflect": { const d = dot(a[0]!, a[1]!); return elementwise(a[0]!, elementwise(a[1]!, 2 * d, (n, k) => n * k), (i, s) => i - s); }
+    default: throw new Error("derived eval: unsupported intrinsic '" + name + "'");
+  }
+}
+
+/**
+ * Interpret a derived-uniform rule IR, reading `u.<name>` leaves via
+ * `readLeaf`. Returns a host double value (`M44d` / `V3d` / number / …) that
+ * `writeField` narrows to f32 when packing the UBO.
+ */
+export function interpretExpr(ir: Expr, readLeaf: LeafReader): EvalValue {
+  const ev = (e: Expr): EvalValue => {
+    switch (e.kind) {
+      case "Const": {
+        const v = e.value;
+        if (v.kind === "Bool") return v.value;
+        if (v.kind === "Int" || v.kind === "Float") return v.value;
+        throw new Error("derived eval: null const");
+      }
+      case "ReadInput": {
+        if (e.scope !== "Uniform") throw new Error("derived eval: non-uniform leaf scope " + e.scope);
+        const raw = readLeaf(e.name);
+        if (raw === undefined) throw new Error("derived eval: missing uniform leaf '" + e.name + "'");
+        return coerce(raw, e.type);
+      }
+      case "Neg": return negate(ev(e.value));
+      case "Not": return !(ev(e.value) as boolean);
+      case "Add": return elementwise(ev(e.lhs), ev(e.rhs), (x, y) => x + y);
+      case "Sub": return elementwise(ev(e.lhs), ev(e.rhs), (x, y) => x - y);
+      case "Div": return elementwise(ev(e.lhs), ev(e.rhs), (x, y) => x / y);
+      case "Mod": return elementwise(ev(e.lhs), ev(e.rhs), (x, y) => x % y);
+      case "Mul": return mulNode(ev(e.lhs), ev(e.rhs));
+      case "MulMatMat": return (ev(e.lhs) as M44d).mul(ev(e.rhs) as M44d) as EvalValue;
+      case "MulMatVec": return (ev(e.lhs) as M44d).mul(ev(e.rhs) as V4d) as EvalValue;
+      case "MulVecMat": return (ev(e.rhs) as M44d).transpose().mul(ev(e.lhs) as V4d) as EvalValue;
+      case "Transpose": return (ev(e.value) as M44d).transpose();
+      case "Inverse": return (ev(e.value) as M44d).inverse();
+      case "Determinant": return (ev(e.value) as M44d).determinant();
+      case "Dot": return dot(ev(e.lhs), ev(e.rhs));
+      case "Cross": return (ev(e.lhs) as V3d).cross(ev(e.rhs) as V3d);
+      case "Length": return vlen(ev(e.value));
+      case "ConvertMatrix": return convertMatrix(ev(e.value), e.type);
+      case "VecSwizzle": return swizzle(ev(e.value), e.comps);
+      case "NewVector": return vecOf(e.components.map((c) => num(ev(c))));
+      case "And": return (ev(e.lhs) as boolean) && (ev(e.rhs) as boolean);
+      case "Or": return (ev(e.lhs) as boolean) || (ev(e.rhs) as boolean);
+      case "Eq":  return num(ev(e.lhs)) === num(ev(e.rhs));
+      case "Neq": return num(ev(e.lhs)) !== num(ev(e.rhs));
+      case "Lt":  return num(ev(e.lhs)) <   num(ev(e.rhs));
+      case "Le":  return num(ev(e.lhs)) <=  num(ev(e.rhs));
+      case "Gt":  return num(ev(e.lhs)) >   num(ev(e.rhs));
+      case "Ge":  return num(ev(e.lhs)) >=  num(ev(e.rhs));
+      case "Conditional": return (ev(e.cond) as boolean) ? ev(e.ifTrue) : ev(e.ifFalse);
+      case "CallIntrinsic": return intrinsic(e.op.name, e.args.map(ev));
+      default: throw new Error("derived eval: unsupported IR node '" + e.kind + "'");
+    }
+  };
+  return ev(ir);
+}

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.
+  //    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) : 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,19 +439,20 @@ export function renderObjectToHeapSpec(
     );
   }
 
-  // 4. DrawCall: read once. Classifier validates fields are heap-
-  //    compatible (indexed, instanceCount=1, zero offsets).
-  const dc = ro.drawCall.getValue(token);
+  // 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; non-indexed → carry the vertex count and
-  // the megacall uses the local vertex index directly (no index lookup).
+  // 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! }
+    ? { indices: indices!, firstIndex: dc.firstIndex, indexCount: dc.indexCount }
     : { vertexCount: dc.vertexCount };
 
   return {

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);
@@ -233,27 +223,19 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
     if (dc.firstInstance !== 0) return false;
     if (dc.kind === "indexed") {
       if (ro.indices === undefined) return false;
-      if (dc.baseVertex !== 0) return false;
-      if (dc.firstIndex !== 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, painting stray triangles. Until the heap
-      // honours the drawCall slice, only ROs that own their whole index
-      // buffer are eligible.
-      const ib = ro.indices.buffer.getValue(token);
-      if (ib.kind === "host") {
-        const idxBufCount = ib.sizeBytes >>> 2; // u32 indices
-        if (dc.indexCount !== idxBufCount) 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) — no whole-buffer wedge.
-      // firstVertex must be 0 (the heap maps vid → attribute[vid] from base 0).
+      // 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;
     }

package/src/runtime/heapScene.ts

@@ -465,6 +465,17 @@ export interface HeapDrawSpec {
   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 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.
@@ -3025,8 +3036,11 @@ export function buildHeapScene(
       ? 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.
-    const emitCount = hasIndices ? idxAlloc!.count : (spec.vertexCount ?? 0);
-    const firstIndexField = hasIndices ? idxAlloc!.firstIndex : HEAP_NONINDEXED;
+    // 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).