@aardworx/wombat.rendering 0.8.0 → 0.9.0

package/dist/runtime/derivedUniforms/uberKernel.wgsl.js

@@ -0,0 +1,218 @@
+// §7 derived-uniforms uber kernel — single flat dispatch over leaves.
+//
+// Records are static-ish (only edited on RO add/remove). Each thread
+// processes one record:
+//   1. Load record (recipe_id, in0, in1, in2, out_byte).
+//   2. Switch on recipe_id, compute inline (df_mul + collapse), write
+//      f32 mat4/mat3 to MainHeap at out_byte.
+//
+// No dirty test on the kernel: when constituents don't change, the
+// kernel rewrites identical bits. Saves a CPU writeBuffer + a binding
+// per dispatch. GPU does ~64 FLOPs per record × N records — trivial at
+// the scales this runs at.
+//
+// df32 primitives mirror examples/df32-precision/. Two opacity hooks:
+//   - bitcast<f32>(bits & MASK) for Veltkamp split (integer ops, no
+//     algebraic identity).
+//   - fma(1.0, x, -y) for compensated subtractions.
+export const DERIVED_UBER_KERNEL_WGSL = /* wgsl */ `
+
+// ─── Bindings ─────────────────────────────────────────────────────
+@group(0) @binding(0) var<storage, read>       Constituents: array<vec2<f32>>;
+@group(0) @binding(1) var<storage, read_write> MainHeap:     array<f32>;
+
+struct Record {
+  recipe_id: u32,
+  in0:       u32,    // constituent slot index
+  in1:       u32,    // constituent slot index, 0 if unused
+  in2:       u32,    // constituent slot index, 0 if unused
+  out_byte:  u32,    // byte offset in MainHeap
+  _pad:      u32,    // bumps stride to 24 (defensively 16-aligned)
+}
+@group(0) @binding(2) var<storage, read>       Records: array<Record>;
+
+// Live record count. arrayLength(Records) reports the GPU buffer's
+// capacity (rounded up by allocator growth), not the live count —
+// trailing slots hold stale data from swap-removed records. Threads
+// past Count.count would read stale records and trample random
+// MainHeap bytes.
+struct CountUniform { count: u32 }
+@group(0) @binding(3) var<uniform>             Count: CountUniform;
+
+// ─── df32 primitives ──────────────────────────────────────────────
+
+fn split12(a: f32) -> vec2<f32> {
+  let hi = bitcast<f32>(bitcast<u32>(a) & 0xFFFFE000u);
+  let lo = a - hi;
+  return vec2<f32>(hi, lo);
+}
+
+fn two_sum(a: f32, b: f32) -> vec2<f32> {
+  let s  = a + b;
+  let bb = fma(1.0, s, -a);
+  let t1 = fma(1.0, s, -bb);
+  let t2 = fma(1.0, a, -t1);
+  let t3 = fma(1.0, b, -bb);
+  return vec2<f32>(s, t2 + t3);
+}
+
+fn quick_two_sum(a: f32, b: f32) -> vec2<f32> {
+  let s = a + b;
+  let t = fma(1.0, s, -a);
+  return vec2<f32>(s, fma(1.0, b, -t));
+}
+
+fn two_prod(a: f32, b: f32) -> vec2<f32> {
+  let p = a * b;
+  let A = split12(a);
+  let B = split12(b);
+  let err = ((A.x * B.x - p) + A.x * B.y + A.y * B.x) + A.y * B.y;
+  return vec2<f32>(p, err);
+}
+
+fn df_add(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+  let s = two_sum(a.x, b.x);
+  let t = two_sum(a.y, b.y);
+  let s3 = quick_two_sum(s.x, s.y + t.x);
+  return quick_two_sum(s3.x, s3.y + t.y);
+}
+
+fn df_mul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+  let p      = two_prod(a.x, b.x);
+  let cross1 = fma(a.x, b.y, p.y);
+  let cross  = fma(a.y, b.x, cross1);
+  return quick_two_sum(p.x, cross);
+}
+
+// ─── Constituents access ──────────────────────────────────────────
+//
+// One slot = 16 vec2<f32> = one df32 mat4 in row-major order
+// (matching Aardvark M44d convention). Element (row, col) of slot k
+// lives at vec2 index k*16 + row*4 + col.
+
+fn read_entry(slot: u32, row: u32, col: u32) -> vec2<f32> {
+  return Constituents[slot * 16u + row * 4u + col];
+}
+
+// (A · B) entry (r, c) in df32, both A and B in constituents.
+fn df_mul_entry(a_slot: u32, b_slot: u32, r: u32, c: u32) -> vec2<f32> {
+  var acc = vec2<f32>(0.0, 0.0);
+  for (var k: u32 = 0u; k < 4u; k = k + 1u) {
+    acc = df_add(acc, df_mul(read_entry(a_slot, r, k), read_entry(b_slot, k, c)));
+  }
+  return acc;
+}
+
+// Compute one full row of (A · B), returns 4 df32 entries.
+fn df_mul_row(a_slot: u32, b_slot: u32, r: u32) -> array<vec2<f32>, 4> {
+  var out: array<vec2<f32>, 4>;
+  for (var c: u32 = 0u; c < 4u; c = c + 1u) {
+    out[c] = df_mul_entry(a_slot, b_slot, r, c);
+  }
+  return out;
+}
+
+// Triple product (A · B · C) entry (r, c). Uses 4 df_muls per entry
+// — recomputes the inner row each call. Acceptable: at most one
+// such recipe per RO and only on dirty frames.
+fn df_mul3_entry(a_slot: u32, b_slot: u32, c_slot: u32, r: u32, c: u32) -> vec2<f32> {
+  // (A·B·C)[r,c] = sum_k (A·B)[r,k] · C[k,c]
+  var acc = vec2<f32>(0.0, 0.0);
+  for (var k: u32 = 0u; k < 4u; k = k + 1u) {
+    let ab_rk = df_mul_entry(a_slot, b_slot, r, k);
+    acc = df_add(acc, df_mul(ab_rk, read_entry(c_slot, k, c)));
+  }
+  return acc;
+}
+
+// ─── Writers ──────────────────────────────────────────────────────
+//
+// Mat4: 16 contiguous f32s, row-major.
+// Mat3: 3 rows × 4-stride (std140 mat3<f32>), 12 f32s; last column
+//       per row left untouched.
+
+fn write_mat4_entry(out_byte: u32, row: u32, col: u32, val: f32) {
+  MainHeap[(out_byte >> 2u) + row * 4u + col] = val;
+}
+
+fn write_mat3_entry(out_byte: u32, row: u32, col: u32, val: f32) {
+  MainHeap[(out_byte >> 2u) + row * 4u + col] = val;
+}
+
+// ─── Recipe arms ──────────────────────────────────────────────────
+
+fn run_collapse_mat4(in0: u32, out_byte: u32) {
+  for (var r: u32 = 0u; r < 4u; r = r + 1u) {
+    for (var c: u32 = 0u; c < 4u; c = c + 1u) {
+      let e = read_entry(in0, r, c);
+      write_mat4_entry(out_byte, r, c, e.x + e.y);
+    }
+  }
+}
+
+// NormalMatrix: (M⁻¹)ᵀ upper-3×3.
+//   NM[i, j] = MInv[j, i]
+fn run_collapse_mat3_normal(in0: u32, out_byte: u32) {
+  for (var i: u32 = 0u; i < 3u; i = i + 1u) {
+    for (var j: u32 = 0u; j < 3u; j = j + 1u) {
+      let e = read_entry(in0, j, i);
+      write_mat3_entry(out_byte, i, j, e.x + e.y);
+    }
+  }
+}
+
+fn run_dfmul2_collapse(in0: u32, in1: u32, out_byte: u32) {
+  for (var r: u32 = 0u; r < 4u; r = r + 1u) {
+    for (var c: u32 = 0u; c < 4u; c = c + 1u) {
+      let e = df_mul_entry(in0, in1, r, c);
+      write_mat4_entry(out_byte, r, c, e.x + e.y);
+    }
+  }
+}
+
+fn run_dfmul3_collapse(in0: u32, in1: u32, in2: u32, out_byte: u32) {
+  for (var r: u32 = 0u; r < 4u; r = r + 1u) {
+    for (var c: u32 = 0u; c < 4u; c = c + 1u) {
+      let e = df_mul3_entry(in0, in1, in2, r, c);
+      write_mat4_entry(out_byte, r, c, e.x + e.y);
+    }
+  }
+}
+
+// ─── Entry ────────────────────────────────────────────────────────
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= Count.count) { return; }
+  let r = Records[gid.x];
+  switch r.recipe_id {
+    case 0u: { run_collapse_mat4(r.in0, r.out_byte); }            // ModelTrafo
+    case 1u: { run_collapse_mat4(r.in0, r.out_byte); }            // ModelTrafoInv
+    case 2u: { run_collapse_mat3_normal(r.in0, r.out_byte); }     // NormalMatrix
+    case 3u: { run_dfmul2_collapse(r.in0, r.in1, r.out_byte); }   // ModelViewTrafo
+    case 4u: { run_dfmul2_collapse(r.in0, r.in1, r.out_byte); }   // ModelViewTrafoInv
+    case 5u: { run_dfmul3_collapse(r.in0, r.in1, r.in2, r.out_byte); } // ModelViewProjTrafo
+    case 6u: { run_dfmul3_collapse(r.in0, r.in1, r.in2, r.out_byte); } // ModelViewProjTrafoInv
+    case 7u: { run_collapse_mat4(r.in0, r.out_byte); }            // ViewTrafo
+    case 8u: { run_collapse_mat4(r.in0, r.out_byte); }            // ViewTrafoInv
+    case 9u: { run_dfmul2_collapse(r.in0, r.in1, r.out_byte); }   // ViewProjTrafo
+    case 10u:{ run_dfmul2_collapse(r.in0, r.in1, r.out_byte); }   // ViewProjTrafoInv
+    case 11u:{ run_collapse_mat4(r.in0, r.out_byte); }            // ProjTrafo
+    case 12u:{ run_collapse_mat4(r.in0, r.out_byte); }            // ProjTrafoInv
+    default: { return; }
+  }
+}
+
+`;
+/** Records are 5× u32 = 20 bytes. WGSL storage struct alignment of
+ *  4 means the array stride is 20 bytes. */
+export const RECORD_STRIDE_BYTES = 24;
+export const RECORD_STRIDE_U32 = 6;
+export const RECORD_FIELD = {
+    recipe_id: 0,
+    in0: 1,
+    in1: 2,
+    in2: 3,
+    out_byte: 4,
+};
+//# sourceMappingURL=uberKernel.wgsl.js.map

package/dist/runtime/derivedUniforms/uberKernel.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uberKernel.wgsl.js","sourceRoot":"","sources":["../../../src/runtime/derivedUniforms/uberKernel.wgsl.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,EAAE;AACF,qEAAqE;AACrE,wBAAwB;AACxB,yDAAyD;AACzD,sEAAsE;AACtE,8CAA8C;AAC9C,EAAE;AACF,mEAAmE;AACnE,sEAAsE;AACtE,uEAAuE;AACvE,2BAA2B;AAC3B,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2BAA2B;AAC3B,oDAAoD;AAEpD,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4LlD,CAAC;AAEF;4CAC4C;AAC5C,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,SAAS,EAAE,CAAC;IACZ,GAAG,EAAQ,CAAC;IACZ,GAAG,EAAQ,CAAC;IACZ,GAAG,EAAQ,CAAC;IACZ,QAAQ,EAAG,CAAC;CACJ,CAAC"}

package/dist/runtime/flattenTree.d.ts

@@ -0,0 +1,5 @@
+import { type aset } from "@aardworx/wombat.adaptive";
+import type { RenderObject } from "../core/renderObject.js";
+import type { RenderTree } from "../core/renderTree.js";
+export declare function flattenRenderTree(tree: RenderTree): aset<RenderObject>;
+//# sourceMappingURL=flattenTree.d.ts.map

package/dist/runtime/flattenTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenTree.d.ts","sourceRoot":"","sources":["../../src/runtime/flattenTree.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAQ,KAAK,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,CAwBtE"}

package/dist/runtime/flattenTree.js

@@ -0,0 +1,45 @@
+// flattenTree — reactive `RenderTree → aset<RenderObject>`.
+//
+// Inside a single Render command, draw order is not load-bearing
+// (formal contract: an `aset` of objects, not a sequence). The two
+// node-kinds `Ordered` and `Unordered` collapse to the same flat
+// set — anything ordering-sensitive belongs at the Command level
+// (separate Render passes, in the Command list's declared order).
+//
+// Reactive variants (`Adaptive`, `OrderedFromList`, `UnorderedFromSet`)
+// stay reactive: marks propagate through `bind` / `collect`, and the
+// resulting aset reflects current tree state without a manual rebuild.
+//
+// `OrderedFromList`'s `alist<RenderTree>` is converted via
+// `AListBridges.toASet` — this drops index/order info, which we
+// wouldn't honor anyway.
+import { ASet } from "@aardworx/wombat.adaptive";
+import { AListBridges } from "@aardworx/wombat.adaptive";
+export function flattenRenderTree(tree) {
+    switch (tree.kind) {
+        case "Empty":
+            return ASet.empty();
+        case "Leaf":
+            return ASet.single(tree.object);
+        case "Ordered":
+        case "Unordered": {
+            // N-ary union via `unionMany(aset<aset<T>>)`. The naïve
+            // `children.reduce(ASet.union)` builds a 2N-deep nested-union
+            // tree; the reader's traversal recurses through it and blows
+            // the stack at ~2K leaves. `unionMany` is O(1)-deep regardless.
+            const children = tree.children.map(flattenRenderTree);
+            if (children.length === 0)
+                return ASet.empty();
+            if (children.length === 1)
+                return children[0];
+            return ASet.unionMany(ASet.ofArray(children));
+        }
+        case "Adaptive":
+            return ASet.bind(flattenRenderTree, tree.tree);
+        case "OrderedFromList":
+            return ASet.collect(flattenRenderTree, AListBridges.toASet(tree.children));
+        case "UnorderedFromSet":
+            return ASet.collect(flattenRenderTree, tree.children);
+    }
+}
+//# sourceMappingURL=flattenTree.js.map

package/dist/runtime/flattenTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenTree.js","sourceRoot":"","sources":["../../src/runtime/flattenTree.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,EAAE;AACF,iEAAiE;AACjE,mEAAmE;AACnE,iEAAiE;AACjE,iEAAiE;AACjE,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,qEAAqE;AACrE,uEAAuE;AACvE,EAAE;AACF,2DAA2D;AAC3D,gEAAgE;AAChE,yBAAyB;AAEzB,OAAO,EAAE,IAAI,EAAa,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAIzD,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAChD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,KAAK,EAAgB,CAAC;QACpC,KAAK,MAAM;YACT,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClC,KAAK,SAAS,CAAC;QACf,KAAK,WAAW,CAAC,CAAC,CAAC;YACjB,wDAAwD;YACxD,8DAA8D;YAC9D,6DAA6D;YAC7D,gEAAgE;YAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;YACtD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC,KAAK,EAAgB,CAAC;YAC7D,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,QAAQ,CAAC,CAAC,CAAE,CAAC;YAC/C,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,UAAU;YACb,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,KAAK,iBAAiB;YACpB,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7E,KAAK,kBAAkB;YACrB,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC"}

package/dist/runtime/heapAdapter.d.ts

@@ -0,0 +1,16 @@
+import { type AdaptiveToken } from "@aardworx/wombat.adaptive";
+import type { RenderObject } from "../core/renderObject.js";
+import type { HeapDrawSpec } from "./heapScene.js";
+import { AtlasPool } from "./textureAtlas/atlasPool.js";
+/**
+ * Convert a heap-eligible `RenderObject` into a `HeapDrawSpec`. The
+ * caller (hybrid render task) is responsible for ensuring eligibility
+ * before calling — this adapter throws on any disagreement.
+ *
+ * The `token` is used once to read `drawCall` and the (single) texture
+ * + sampler avals at addDraw time. Per-frame data updates flow
+ * through the heap path's pool/repack machinery via the returned
+ * spec's avals — this function does not subscribe to anything.
+ */
+export declare function renderObjectToHeapSpec(ro: RenderObject, token: AdaptiveToken, pool?: AtlasPool): HeapDrawSpec;
+//# sourceMappingURL=heapAdapter.d.ts.map

package/dist/runtime/heapAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heapAdapter.d.ts","sourceRoot":"","sources":["../../src/runtime/heapAdapter.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAa,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAK1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AA0HxD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE,SAAS,GACf,YAAY,CA8Id"}

package/dist/runtime/heapAdapter.js

@@ -0,0 +1,263 @@
+// heapAdapter — `RenderObject → HeapDrawSpec`.
+//
+// Reactive: returns the same `HeapDrawSpec` shape the heap path
+// already accepts. Per-input wiring:
+//
+//   - vertexAttributes   → spec.inputs[name] = BufferView (heap path
+//                          handles BufferView ingest natively, pivots
+//                          the pool aval-key onto the underlying
+//                          `aval<IBuffer>` for share-by-identity).
+//   - uniforms           → spec.inputs[name] = aval<unknown>.
+//   - textures/samplers  → folded into a HeapTextureSet (single pair
+//                          v1; the eligibility classifier already
+//                          rejects multi-binding ROs).
+//   - indices            → BufferView's `aval<IBuffer>` mapped to
+//                          `aval<Uint32Array>` for the heap path's
+//                          IndexPool.
+//   - effect             → passed through.
+//   - pipelineState      → passed through (heap path bucket-keys it).
+//
+// Drawcall wedges (instanceCount > 1, baseVertex/firstIndex/
+// firstInstance != 0, non-indexed) are screened out by
+// `isHeapEligible`; this adapter is the partner that converts the
+// heap-eligible subset. If we see something we can't handle, throw —
+// that's a classifier/adapter mismatch, a bug.
+//
+// No multi-binding texture API yet: `ro.textures.count <= 1` and
+// `ro.samplers.count <= 1` are classifier invariants.
+import {} from "@aardworx/wombat.adaptive";
+import { ITexture } from "../core/texture.js";
+import { ISampler } from "../core/sampler.js";
+import { AtlasPool } from "./textureAtlas/atlasPool.js";
+/**
+ * View `HostBufferSource` as `Uint32Array`. Index buffers are u32 in
+ * the heap path; non-u32 indices would have to be transcoded (out
+ * of scope — eligibility doesn't currently inspect index format).
+ */
+function asUint32(data) {
+    if (data instanceof Uint32Array)
+        return data;
+    if (ArrayBuffer.isView(data)) {
+        return new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4);
+    }
+    return new Uint32Array(data);
+}
+// 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();
+// Per-aval shared "current pool ref" cell. ROs that share an
+// `aval<ITexture>` (and therefore one AtlasPool entry) all read
+// through the same cell; `repack` updates `cell.ref` so every
+// `release` closure frees the latest sub-rect after a swap.
+const currentRefCellCache = new WeakMap();
+function currentRefCellFor(av, initial) {
+    let c = currentRefCellCache.get(av);
+    if (c === undefined) {
+        c = { ref: initial };
+        currentRefCellCache.set(av, c);
+    }
+    return c;
+}
+function indicesAvalFor(ibAval) {
+    let av = indicesAvalCache.get(ibAval);
+    if (av === undefined) {
+        av = ibAval.map((ib) => {
+            if (ib.kind !== "host") {
+                throw new Error("heapAdapter: index buffer flipped to native GPUBuffer; classifier should have caught this");
+            }
+            return asUint32(ib.data);
+        });
+        indicesAvalCache.set(ibAval, av);
+    }
+    return av;
+}
+function describeTexture(t) {
+    if (t.kind === "gpu") {
+        const tex = t.texture;
+        return {
+            format: tex.format,
+            width: tex.width,
+            height: tex.height,
+            mipLevelCount: tex.mipLevelCount,
+        };
+    }
+    const src = t.source;
+    if (src.kind === "raw") {
+        return {
+            format: src.format,
+            width: src.width,
+            height: src.height,
+            mipLevelCount: src.mipLevelCount ?? 1,
+            host: src,
+        };
+    }
+    // external — read width/height off the source. Most types have it,
+    // HTMLVideoElement uses `videoWidth/videoHeight`.
+    const ext = src.source;
+    let w = 0, h = 0;
+    if (typeof HTMLVideoElement !== "undefined" && ext instanceof HTMLVideoElement) {
+        w = ext.videoWidth;
+        h = ext.videoHeight;
+    }
+    else if (typeof ImageData !== "undefined" && ext instanceof ImageData) {
+        w = ext.width;
+        h = ext.height;
+    }
+    else {
+        const any = ext;
+        w = any.width ?? 0;
+        h = any.height ?? 0;
+    }
+    if (w <= 0 || h <= 0)
+        return null;
+    return {
+        format: src.format ?? "rgba8unorm",
+        width: w,
+        height: h,
+        mipLevelCount: src.generateMips ? Math.floor(Math.log2(Math.max(w, h))) + 1 : 1,
+        host: src,
+    };
+}
+/**
+ * Convert a heap-eligible `RenderObject` into a `HeapDrawSpec`. The
+ * caller (hybrid render task) is responsible for ensuring eligibility
+ * before calling — this adapter throws on any disagreement.
+ *
+ * The `token` is used once to read `drawCall` and the (single) texture
+ * + sampler avals at addDraw time. Per-frame data updates flow
+ * through the heap path's pool/repack machinery via the returned
+ * spec's avals — this function does not subscribe to anything.
+ */
+export function renderObjectToHeapSpec(ro, token, pool) {
+    // 1. Inputs map: vertex attributes (BufferView) + uniforms.
+    const inputs = {};
+    ro.vertexAttributes.iter((name, bv) => { inputs[name] = bv; });
+    ro.uniforms.iter((name, av) => { inputs[name] = av; });
+    // 1b. Instance attributes — same shape, threaded via the heap path's
+    //     per-RO instancing fast path (one record / one drawIndirect for
+    //     `instanceCount > 1`, with per-instance attribute reads indexed
+    //     by the in-RO instance idx).
+    let instanceAttributes;
+    if (ro.instanceAttributes !== undefined && ro.instanceAttributes.count > 0) {
+        instanceAttributes = {};
+        ro.instanceAttributes.iter((name, bv) => {
+            instanceAttributes[name] = bv;
+        });
+    }
+    // 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 = indicesAvalFor(ro.indices.buffer);
+    // 3. Texture/sampler: single-pair v1. Classifier already capped
+    //    counts at 1 each.
+    let textures;
+    if (ro.textures.count === 1 && ro.samplers.count === 1) {
+        let texAval;
+        let texVal;
+        let samplerAval;
+        let samplerVal;
+        ro.textures.iter((_n, av) => {
+            texAval = av;
+            texVal = av.getValue(token);
+        });
+        ro.samplers.iter((_n, av) => {
+            samplerAval = av;
+            samplerVal = av.getValue(token);
+        });
+        void samplerAval;
+        if (texVal === undefined || samplerVal === undefined) {
+            throw new Error("heapAdapter: missing texture/sampler value");
+        }
+        // Inspect format/dimensions/mipLevels from ITexture. Both
+        // variants expose enough to classify:
+        //   - kind: "host" → carries width/height/format on the source
+        //     descriptor (raw) or implicit (external; default rgba8unorm).
+        //   - kind: "gpu"  → resolved GPUTexture exposes .format/.width/
+        //     .height/.mipLevelCount.
+        const dims = describeTexture(texVal);
+        // Tier-S routing: pool present, format eligible, dims ≤ cap. Mips
+        // are honoured if the source advertises them.
+        const atlasFormat = dims === null ? null : AtlasPool.eligibleFormat(dims.format);
+        if (pool !== undefined &&
+            dims !== null &&
+            atlasFormat !== null &&
+            AtlasPool.eligibleSize(dims.width, dims.height)) {
+            const wantsMips = dims.mipLevelCount > 1;
+            const acq = pool.acquire(atlasFormat, texAval, dims.width, dims.height, {
+                wantsMips,
+                ...(dims.host !== undefined ? { source: { width: dims.width, height: dims.height, host: dims.host } } : {}),
+            });
+            const texAvalTyped = texAval;
+            // Per-aval shared current-ref cell so all ROs sharing a single
+            // `aval<ITexture>` see the same "live" pool ref. After a repack
+            // every release closure reads the cell and frees the LATEST
+            // sub-rect — no leaks even when multiple ROs are bucket-shared.
+            const cell = currentRefCellFor(texAvalTyped, acq.ref);
+            textures = {
+                kind: "atlas",
+                format: atlasFormat,
+                pageId: acq.pageId,
+                origin: acq.origin,
+                size: acq.size,
+                numMips: acq.numMips,
+                sampler: samplerVal,
+                page: acq.page,
+                poolRef: acq.ref,
+                release: () => pool.release(cell.ref),
+                // Reactivity hooks: heapScene subscribes to `sourceAval`; on
+                // mark, drains via `repack(newTex)` — the pool frees the old
+                // sub-rect, acquires a new one, and the heap path rewrites
+                // the drawHeader fields. Mirrors UniformPool.repack(av, val).
+                sourceAval: texAvalTyped,
+                repack: (newTex) => {
+                    const next = pool.repack(texAvalTyped, newTex, {
+                        wantsMips: dims.mipLevelCount > 1,
+                    });
+                    cell.ref = next.ref;
+                    return next;
+                },
+            };
+        }
+        else {
+            // Tier-L fallback: keep the existing standalone path, which
+            // requires a resolved GPUTexture/GPUSampler.
+            if (texVal.kind !== "gpu") {
+                throw new Error("heapAdapter: standalone path requires ITexture.kind === 'gpu'");
+            }
+            if (samplerVal.kind !== "gpu") {
+                throw new Error("heapAdapter: standalone path requires ISampler.kind === 'gpu'");
+            }
+            textures = {
+                kind: "standalone",
+                texture: ITexture.fromGPU(texVal.texture),
+                sampler: ISampler.fromGPU(samplerVal.sampler),
+            };
+        }
+    }
+    else if (ro.textures.count > 0 || ro.samplers.count > 0) {
+        throw new Error(`heapAdapter: RO has ${ro.textures.count} texture(s) and ${ro.samplers.count} sampler(s); ` +
+            `single-pair only in v1 (classifier should have caught this)`);
+    }
+    // 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");
+    }
+    return {
+        effect: ro.effect,
+        pipelineState: ro.pipelineState,
+        inputs,
+        ...(instanceAttributes !== undefined ? { instanceAttributes } : {}),
+        ...(dc.instanceCount > 1 ? { instanceCount: dc.instanceCount } : {}),
+        indices,
+        ...(textures !== undefined ? { textures } : {}),
+    };
+}
+//# sourceMappingURL=heapAdapter.js.map

package/dist/runtime/heapAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heapAdapter.js","sourceRoot":"","sources":["../../src/runtime/heapAdapter.ts"],"names":[],"mappings":"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"}