@aardworx/wombat.rendering 0.9.3 → 0.9.5

package/src/core/index.ts

@@ -74,6 +74,17 @@ export type {
   RenderObject,
 } from "./renderObject.js";
 
+export type {
+  IUniformProvider,
+  IAttributeProvider,
+} from "./provider.js";
+export {
+  UniformProvider,
+  AttributeProvider,
+  asUniformProvider,
+  asAttributeProvider,
+} from "./provider.js";
+
 export {
   RenderTree,
 } from "./renderTree.js";

package/src/core/provider.ts

@@ -0,0 +1,143 @@
+// IUniformProvider / IAttributeProvider — lazy, by-name lookup of a
+// RenderObject's uniform values and vertex/instance attribute views.
+//
+// Modelled on Aardvark.Rendering's `IUniformProvider` /
+// `IAttributeProvider`: the binding layer always pulls *shader-driven*
+// — for each name the compiled shader actually declares it calls
+// `tryGet(name)`. A name no shader reads is therefore never
+// materialised by a lazy provider. This is what lets the scene-graph
+// auto-inject all ~15 derived trafo uniforms (`ModelViewProjTrafo`,
+// `NormalMatrix`, the inverses, …) per leaf for free: their `compose`
+// / `inverse` aval chains are only built when some effect's interface
+// references the name.
+//
+// `names()` is the (cheap) enumeration surface — a lazy provider lists
+// the names it *could* produce without materialising their values. The
+// only consumers that enumerate (rather than pull by shader name) are
+// the texture-split in the Sg compile layer (operates on the user map,
+// not a provider) and the heap-eligibility stride check (iterates the
+// attribute provider's names — always map-backed in practice).
+
+import type { HashMap, aval } from "@aardworx/wombat.adaptive";
+import type { BufferView } from "./bufferView.js";
+
+export interface IUniformProvider {
+  /** Uniform value for `name`, or `undefined` if not provided. Pulled
+   *  once per shader-declared uniform; lazy providers materialise the
+   *  value here, on first request. */
+  tryGet(name: string): aval<unknown> | undefined;
+  /** Names this provider knows about (for enumeration / diagnostics).
+   *  A lazy provider lists derivable names without building them. */
+  names(): Iterable<string>;
+}
+
+export interface IAttributeProvider {
+  /** Vertex/instance attribute view for `name`, or `undefined`. */
+  tryGet(name: string): BufferView | undefined;
+  names(): Iterable<string>;
+}
+
+// ─── shared impl helpers ───────────────────────────────────────────────
+
+function mapKeys<K, V>(m: HashMap<K, V>): K[] {
+  const out: K[] = [];
+  for (const [k] of m) out.push(k);
+  return out;
+}
+
+function hasOwn(o: object, k: string): boolean {
+  return Object.prototype.hasOwnProperty.call(o, k);
+}
+
+const EMPTY_NAMES: readonly string[] = [];
+
+function makeProvider<T>(): {
+  empty: { tryGet(name: string): T | undefined; names(): Iterable<string> };
+  ofMap(m: HashMap<string, T>): { tryGet(name: string): T | undefined; names(): Iterable<string> };
+  ofObject(o: Readonly<Record<string, T>>): { tryGet(name: string): T | undefined; names(): Iterable<string> };
+  union(...ps: { tryGet(name: string): T | undefined; names(): Iterable<string> }[]): { tryGet(name: string): T | undefined; names(): Iterable<string> };
+  lazy(known: readonly string[], compute: (name: string) => T | undefined): { tryGet(name: string): T | undefined; names(): Iterable<string> };
+} {
+  type P = { tryGet(name: string): T | undefined; names(): Iterable<string> };
+  const empty: P = { tryGet: () => undefined, names: () => EMPTY_NAMES };
+  return {
+    empty,
+    ofMap(m: HashMap<string, T>): P {
+      if (m.containsKey === undefined) return empty; // defensive
+      return { tryGet: (n) => m.tryFind(n), names: () => mapKeys(m) };
+    },
+    ofObject(o: Readonly<Record<string, T>>): P {
+      return { tryGet: (n) => (hasOwn(o, n) ? o[n] : undefined), names: () => Object.keys(o) };
+    },
+    /** First non-`undefined` wins. Pass providers in priority order —
+     *  e.g. `[leafAttrs, scopeAttrs]` so a leaf shadows the scope, or
+     *  `[userUniforms, autoInjected]` so the user overrides defaults. */
+    union(...ps: P[]): P {
+      if (ps.length === 0) return empty;
+      if (ps.length === 1) return ps[0]!;
+      return {
+        tryGet: (n) => {
+          for (let i = 0; i < ps.length; i++) {
+            const v = ps[i]!.tryGet(n);
+            if (v !== undefined) return v;
+          }
+          return undefined;
+        },
+        names: () => {
+          const s = new Set<string>();
+          for (const p of ps) for (const n of p.names()) s.add(n);
+          return s;
+        },
+      };
+    },
+    /** `compute(name)` runs the first time `name` is requested; the
+     *  result (incl. `undefined`) is memoised. `known` is the cheap
+     *  list of names `compute` can produce. */
+    lazy(known: readonly string[], compute: (name: string) => T | undefined): P {
+      const cache = new Map<string, T | undefined>();
+      return {
+        tryGet: (n) => {
+          const hit = cache.get(n);
+          if (hit !== undefined || cache.has(n)) return hit;
+          const v = compute(n);
+          cache.set(n, v);
+          return v;
+        },
+        names: () => known,
+      };
+    },
+  };
+}
+
+export const UniformProvider = makeProvider<aval<unknown>>() as {
+  empty: IUniformProvider;
+  ofMap(m: HashMap<string, aval<unknown>>): IUniformProvider;
+  ofObject(o: Readonly<Record<string, aval<unknown>>>): IUniformProvider;
+  union(...ps: IUniformProvider[]): IUniformProvider;
+  lazy(known: readonly string[], compute: (name: string) => aval<unknown> | undefined): IUniformProvider;
+};
+
+export const AttributeProvider = makeProvider<BufferView>() as {
+  empty: IAttributeProvider;
+  ofMap(m: HashMap<string, BufferView>): IAttributeProvider;
+  ofObject(o: Readonly<Record<string, BufferView>>): IAttributeProvider;
+  union(...ps: IAttributeProvider[]): IAttributeProvider;
+  lazy(known: readonly string[], compute: (name: string) => BufferView | undefined): IAttributeProvider;
+};
+
+function isProvider(x: unknown): x is { tryGet(n: string): unknown; names(): Iterable<string> } {
+  return x !== null && typeof x === "object" && typeof (x as { tryGet?: unknown }).tryGet === "function";
+}
+
+/** Normalise a `RenderObject.uniforms` value: a real provider passes
+ *  through; a plain `HashMap<string, aval>` (legacy shape, still used
+ *  by some hand-built test fixtures) is wrapped as a map-backed
+ *  provider. Consumers call this at the boundary so both shapes work. */
+export function asUniformProvider(x: IUniformProvider | HashMap<string, aval<unknown>>): IUniformProvider {
+  return isProvider(x) ? x : UniformProvider.ofMap(x);
+}
+
+/** Likewise for `vertexAttributes` / `instanceAttributes`. */
+export function asAttributeProvider(x: IAttributeProvider | HashMap<string, BufferView>): IAttributeProvider {
+  return isProvider(x) ? x : AttributeProvider.ofMap(x);
+}

package/src/core/renderObject.ts

@@ -16,6 +16,7 @@ import type { ISampler } from "./sampler.js";
 import type { ITexture } from "./texture.js";
 import type { PipelineState } from "./pipelineState.js";
 import type { Effect } from "./shader.js";
+import type { IAttributeProvider, IUniformProvider } from "./provider.js";
 
 export interface RenderObject {
   /**
@@ -39,17 +40,23 @@ export interface RenderObject {
   readonly pipelineState: PipelineState;
 
   /**
-   * name → vertex buffer view; e.g. "position", "normal", "uv".
-   *
-   * The set of attribute names is fixed structurally; only the
-   * individual buffer values are reactive. The shader's required-input
-   * set is fixed at compile; the map must contain at least those names.
+   * Vertex attributes, looked up by name. The binding layer pulls
+   * shader-driven (one `tryGet(name)` per declared vertex input), so a
+   * provider may compute views lazily — though in practice attribute
+   * providers are map-backed. `undefined` from `tryGet` for a name the
+   * shader requires is an error at prepare time.
+   */
+  readonly vertexAttributes: IAttributeProvider;
+  /** Instance attributes, looked up by name (same contract). */
+  readonly instanceAttributes?: IAttributeProvider;
+  /**
+   * Uniform values, looked up by name. The runtime packs the UBO from
+   * the shader's declared layout — for each declared uniform it calls
+   * `uniforms.tryGet(name)`. Names no shader reads are never pulled, so
+   * a lazy provider (e.g. the Sg layer's auto-injected derived trafos)
+   * never builds their aval chains.
    */
-  readonly vertexAttributes: HashMap<string, BufferView>;
-  /** name → instance buffer view; e.g. "modelMatrix", "instanceColor". */
-  readonly instanceAttributes?: HashMap<string, BufferView>;
-  /** name → uniform value; runtime packs into UBO based on shader layout. */
-  readonly uniforms: HashMap<string, aval<unknown>>;
+  readonly uniforms: IUniformProvider;
   /** name → texture source (CPU image or pre-built GPUTexture). */
   readonly textures: HashMap<string, aval<ITexture>>;
   /** name → sampler source (descriptor or pre-built GPUSampler). */

package/src/core/sampler.ts

@@ -1,12 +1,74 @@
 // ISampler — sampler source. Either a pre-built `GPUSampler` or a
 // descriptor for the runtime to materialise (samplers are cheap
 // and dedupable, so descriptors are the common path).
+//
+// Equality / hash protocol: `desc` samplers compare structurally over
+// the descriptor fields (all primitives) so two `fromDescriptor({...})`
+// with the same options collapse in `aval<ISampler>`-keyed caches;
+// `gpu` samplers compare by reference on the opaque `GPUSampler`.
+// `gpu` samplers are additionally interned by the handle so two
+// `fromGPU(sameSampler)` return the same object.
 
 export type ISampler =
   | { readonly kind: "gpu"; readonly sampler: GPUSampler }
   | { readonly kind: "desc"; readonly descriptor: GPUSamplerDescriptor };
 
+let _idCounter = 0;
+const _idHashes = new WeakMap<object, number>();
+function idHash(o: object): number {
+  let v = _idHashes.get(o);
+  if (v === undefined) { v = (++_idCounter) | 0; _idHashes.set(o, v); }
+  return v;
+}
+function hashStr(s: string): number {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+  return h;
+}
+// Stable serialisation of a GPUSamplerDescriptor (sorted keys, only
+// own enumerable primitive fields — the descriptor never contains
+// objects). Used for both equality and hashing.
+function descKey(d: GPUSamplerDescriptor): string {
+  const keys = Object.keys(d).sort();
+  let out = "";
+  for (const k of keys) {
+    const v = (d as Record<string, unknown>)[k];
+    out += `${k}=${String(v)};`;
+  }
+  return out;
+}
+
+function iSamplerEquals(a: ISampler, o: unknown): boolean {
+  if (a === o) return true;
+  if (o === null || typeof o !== "object") return false;
+  const b = o as ISampler;
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "gpu") return a.sampler === (b as { sampler: GPUSampler }).sampler;
+  return descKey(a.descriptor) === descKey((b as { descriptor: GPUSamplerDescriptor }).descriptor);
+}
+function iSamplerHash(a: ISampler): number {
+  if (a.kind === "gpu") return idHash(a.sampler);
+  return hashStr("desc:" + descKey(a.descriptor));
+}
+const ISAMPLER_PROTO = {
+  equals(this: ISampler, o: unknown): boolean { return iSamplerEquals(this, o); },
+  getHashCode(this: ISampler): number { return iSamplerHash(this) | 0; },
+};
+function withEq<T extends ISampler>(t: T): T {
+  return Object.assign(Object.create(ISAMPLER_PROTO) as object, t) as T;
+}
+
+const _gpuIntern = new WeakMap<GPUSampler, ISampler>();
+
 export const ISampler = {
-  fromGPU(sampler: GPUSampler): ISampler { return { kind: "gpu", sampler }; },
-  fromDescriptor(descriptor: GPUSamplerDescriptor): ISampler { return { kind: "desc", descriptor }; },
+  fromGPU(sampler: GPUSampler): ISampler {
+    const cached = _gpuIntern.get(sampler);
+    if (cached !== undefined) return cached;
+    const t = withEq({ kind: "gpu" as const, sampler });
+    _gpuIntern.set(sampler, t);
+    return t;
+  },
+  fromDescriptor(descriptor: GPUSamplerDescriptor): ISampler {
+    return withEq({ kind: "desc" as const, descriptor });
+  },
 } as const;

package/src/resources/adaptiveTexture.ts

@@ -127,6 +127,13 @@ class AdaptiveTexture extends AdaptiveResource<GPUTexture> {
       }
       return src.texture;
     }
+    if (src.kind === "url") {
+      // URL textures are an authoring shorthand the wombat.dom Sg layer
+      // resolves before binding. Reaching adaptiveTexture means the
+      // caller bypassed that — give them a clear error instead of a
+      // cryptic TypeError from `src.source.kind`.
+      throw new Error(`adaptiveTexture: ITexture.kind === "url" must be resolved before binding (url: ${src.url})`);
+    }
     const desc = descFor(src.source);
     const usage =
       (this.opts.usage ?? 0)

package/src/resources/preparedRenderObject.ts

@@ -14,8 +14,11 @@
 
 import {
   AdaptiveResource,
+  AttributeProvider,
   BufferView,
   ElementType,
+  asAttributeProvider,
+  asUniformProvider,
   type CompiledEffect,
   type FramebufferSignature,
   type ProgramInterface,
@@ -508,8 +511,10 @@ export function prepareRenderObject(
   // The set of attribute names is fixed structurally; only the
   // per-attribute BufferView avals are reactive. We resolve names →
   // step-mode now (vertex vs instance) from the maps directly.
-  const vertexMap = obj.vertexAttributes;
-  const instanceMap = obj.instanceAttributes ?? emptyAttrMap();
+  const vertexMap = asAttributeProvider(obj.vertexAttributes);
+  const instanceMap = obj.instanceAttributes !== undefined
+    ? asAttributeProvider(obj.instanceAttributes)
+    : AttributeProvider.empty;
 
   // Per-attribute resolution + grouping. Multiple attributes can
   // share one underlying GPUBuffer slot when they all point at the
@@ -534,8 +539,8 @@ export function prepareRenderObject(
   }
   const resolved: ResolvedBinding[] = [];
   for (const vb of vertexBindings) {
-    const fromVertex = vertexMap.tryFind(vb.name);
-    const fromInstance = instanceMap.tryFind(vb.name);
+    const fromVertex = vertexMap.tryGet(vb.name);
+    const fromInstance = instanceMap.tryGet(vb.name);
     if (fromVertex === undefined && fromInstance === undefined) {
       throw new Error(`prepareRenderObject: missing vertex attribute "${vb.name}"`);
     }
@@ -665,7 +670,7 @@ export function prepareRenderObject(
   for (let g = 0; g <= maxGroup; g++) perGroup.push([]);
 
   for (const ub of iface.uniformBlocks) {
-    const merged = mergeUniformInputs(obj.uniforms, effect.avalBindings, ub);
+    const merged = mergeUniformInputs(asUniformProvider(obj.uniforms), effect.avalBindings, ub);
     const block = ubAsBlock(ub);
     const res = prepareUniformBuffer(device, block, merged, {
       ...(opts.label !== undefined ? { label: `${opts.label}.${ub.name}` } : {}),
@@ -739,10 +744,6 @@ export function prepareRenderObject(
   );
 }
 
-function emptyAttrMap(): HashMap<string, BufferView> {
-  return HashMap.empty<string, BufferView>();
-}
-
 /**
  * Sentinel pipeline placeholder. PreparedRenderObject's `pipeline`
  * field is non-null for ergonomic typing; before the first
@@ -757,19 +758,23 @@ const SENTINEL_PIPELINE = { __sentinel: "PreparedRenderObject.pipeline" } as unk
 // ---------------------------------------------------------------------------
 
 function mergeUniformInputs(
-  user: HashMap<string, aval<unknown>>,
+  user: import("../core/index.js").IUniformProvider,
   bindings: Readonly<Record<string, () => unknown>> | undefined,
   block: import("../core/index.js").UniformBlockInfo,
 ): HashMap<string, aval<unknown>> {
-  let merged = user;
-  if (bindings === undefined) return merged;
+  // Shader-driven: walk the block's declared fields and pull each from
+  // the user provider (lazy providers materialise only the names a
+  // shader actually declares), falling back to the effect's
+  // closure-captured `avalBindings` default. Uniforms the user provides
+  // but the shader doesn't declare are correctly dropped.
+  let merged = HashMap.empty<string, aval<unknown>>();
   for (const f of block.fields) {
-    if (merged.tryFind(f.name) !== undefined) continue;
-    const getter = bindings[f.name];
+    const u = user.tryGet(f.name);
+    if (u !== undefined) { merged = merged.add(f.name, u); continue; }
+    const getter = bindings?.[f.name];
     if (getter === undefined) continue;
     const v = getter();
-    if (isAval(v)) merged = merged.add(f.name, v as aval<unknown>);
-    else merged = merged.add(f.name, cval(v));
+    merged = merged.add(f.name, isAval(v) ? (v as aval<unknown>) : cval(v));
   }
   return merged;
 }

package/src/resources/uniformBuffer.ts

@@ -153,6 +153,27 @@ export function writeField(
     view.u32.set(value, offset >> 2);
     return;
   }
+  // Trafo3d: pack its forward matrix. The runtime treats `Trafo3d`
+  // uniforms uniformly as their forward-mat4 — callers who want the
+  // inverse should bind a derived uniform that exposes `.backward`
+  // (or use the derived-uniforms compute pass which handles both).
+  // Recognised via duck-type on `.forward._data` to stay decoupled
+  // from the wombat.base import.
+  if (
+    value !== null && typeof value === "object" &&
+    "forward" in (value as object) &&
+    (value as { forward: unknown }).forward !== null &&
+    typeof (value as { forward: unknown }).forward === "object" &&
+    "_data" in ((value as { forward: object }).forward as object)
+  ) {
+    const data = ((value as { forward: { _data: unknown } }).forward._data);
+    if (data instanceof Float32Array) { view.f32.set(data, offset >> 2); return; }
+    if (data instanceof Float64Array) {
+      const dst = view.f32.subarray(offset >> 2, (offset >> 2) + data.length);
+      for (let i = 0; i < data.length; i++) dst[i] = data[i]!;
+      return;
+    }
+  }
   if (value !== null && typeof value === "object" && "_data" in (value as object)) {
     const data = (value as { _data: unknown })._data;
     if (data instanceof Float32Array) { view.f32.set(data, offset >> 2); return; }

package/src/runtime/derivedUniforms/slots.ts

@@ -73,6 +73,10 @@ function packMat4ToSlot(mirror: Float32Array, slotIdx: number, m: M44d): void {
 
 export class ConstituentSlots {
   private readonly pool = new IndexPool();
+  // Keyed by `aval<Trafo3d>` *by reference* (plain JS `Map`). Keys
+  // here are per-object `cval<Trafo3d>`s in practice; content-keying
+  // would buy nothing and cost the reactive-aval identity-hash detour
+  // (see the note on `UniformPool.byAval`).
   private readonly byAval = new Map<aval<Trafo3d>, ConstituentEntry>();
   private readonly dirtyAvals = new Set<aval<Trafo3d>>();
   private mirror: Float32Array;

package/src/runtime/heapAdapter.ts

@@ -32,6 +32,7 @@ import type { 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 { AtlasPool } from "./textureAtlas/atlasPool.js";
 
@@ -120,6 +121,9 @@ function describeTexture(t: ITexture): TextureDescriptor | null {
       mipLevelCount: tex.mipLevelCount,
     };
   }
+  // URL-deferred textures are resolved at the Sg layer (placeholder
+  // checker until ready); they should never reach the heap adapter.
+  if (t.kind === "url") return null;
   const src = t.source;
   if (src.kind === "raw") {
     return {
@@ -170,21 +174,52 @@ export function renderObjectToHeapSpec(
   token: AdaptiveToken,
   pool?: AtlasPool,
 ): HeapDrawSpec {
-  // 1. Inputs map: vertex attributes (BufferView) + uniforms.
+  // 1. Inputs map: vertex attributes (BufferView) + uniforms, pulled
+  //    SHADER-DRIVEN from the providers. We compile `ro.effect` (cached
+  //    per Effect by the module-level compile cache) to discover the
+  //    names it declares, then `tryGet` exactly those — so a lazy
+  //    uniform provider (the Sg layer's auto-injected derived trafos)
+  //    only ever materialises the ~2-4 trafos an effect actually reads,
+  //    not all ~15. Compiling without a `fragmentOutputLayout` yields
+  //    the *unreduced* interface — a superset of what the heap
+  //    drawHeader ends up with — so we never under-provide; the
+  //    over-provided handful (uniforms that feed only pruned outputs)
+  //    is harmless (no drawHeader field → ignored).
+  const vAttr = asAttributeProvider(ro.vertexAttributes);
+  const uProv = asUniformProvider(ro.uniforms);
+  const iface = ro.effect.compile({ target: "wgsl" }).interface;
   const inputs: { [name: string]: aval<unknown> | unknown } = {};
-  ro.vertexAttributes.iter((name, bv: BufferView) => { inputs[name] = bv; });
-  ro.uniforms.iter((name, av) => { inputs[name] = av; });
+  for (const a of iface.attributes) {
+    const bv = vAttr.tryGet(a.name);
+    if (bv !== undefined) inputs[a.name] = bv;
+  }
+  const pullUniform = (name: string): void => {
+    if (Object.prototype.hasOwnProperty.call(inputs, name)) return;
+    const av = uProv.tryGet(name);
+    if (av !== undefined) inputs[name] = av;
+  };
+  for (const b of iface.uniformBlocks) for (const f of b.fields) pullUniform(f.name);
+  for (const u of iface.uniforms) pullUniform(u.name);
+  // §7 derived-uniforms constituents — cheap (these are the raw
+  // `state.model/view/proj` avals, no `compose`/`inverse`) and the
+  // compute pre-pass needs them even when the effect itself doesn't
+  // declare them. No-ops if the provider doesn't carry them.
+  for (const n of ["ModelTrafo", "ViewTrafo", "ProjTrafo"]) pullUniform(n);
 
-  // 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).
+  // 1b. Instance attributes — provider is map-backed (user-supplied via
+  //     `Sg.instanced({attributes})`), so enumerate its names. Threaded
+  //     via the heap path's per-RO instancing fast path.
   let instanceAttributes: { [name: string]: aval<unknown> | unknown } | undefined;
-  if (ro.instanceAttributes !== undefined && ro.instanceAttributes.count > 0) {
-    instanceAttributes = {};
-    ro.instanceAttributes.iter((name, bv: BufferView) => {
-      instanceAttributes![name] = bv;
-    });
+  if (ro.instanceAttributes !== undefined) {
+    const iAttr = asAttributeProvider(ro.instanceAttributes);
+    const names = [...iAttr.names()];
+    if (names.length > 0) {
+      instanceAttributes = {};
+      for (const n of names) {
+        const bv = iAttr.tryGet(n);
+        if (bv !== undefined) instanceAttributes[n] = bv;
+      }
+    }
   }
 
   // 2. Indices: BufferView → aval<Uint32Array>. Map the underlying
@@ -194,22 +229,21 @@ export function renderObjectToHeapSpec(
   }
   const indices: aval<Uint32Array> = indicesAvalFor(ro.indices.buffer);
 
-  // 3. Texture/sampler: single-pair v1. Classifier already capped
-  //    counts at 1 each.
+  // 3. Texture/sampler: single-pair v1. The Sg compile layer binds
+  //    each texture aval under both `name` and `${name}_view` so the
+  //    WGSL schema's binding shape doesn't matter at scene time — that
+  //    leaves us with two HashMap entries pointing at the same aval.
+  //    Dedupe by identity before applying the single-pair rule.
+  const distinctTexAvals = new Set<aval<ITexture>>();
+  ro.textures.iter((_n, av) => { distinctTexAvals.add(av as aval<ITexture>); });
+  const distinctSamplerAvals = new Set<aval<ISampler>>();
+  ro.samplers.iter((_n, av) => { distinctSamplerAvals.add(av as aval<ISampler>); });
   let textures: HeapTextureSet | undefined;
-  if (ro.textures.count === 1 && ro.samplers.count === 1) {
-    let texAval: aval<unknown> | undefined;
-    let texVal: ITexture | undefined;
-    let samplerAval: aval<unknown> | undefined;
-    let samplerVal: ISampler | undefined;
-    ro.textures.iter((_n, av) => {
-      texAval = av;
-      texVal = av.getValue(token) as ITexture;
-    });
-    ro.samplers.iter((_n, av) => {
-      samplerAval = av;
-      samplerVal = av.getValue(token) as ISampler;
-    });
+  if (distinctTexAvals.size === 1 && distinctSamplerAvals.size === 1) {
+    const texAval = [...distinctTexAvals][0]!;
+    const samplerAval = [...distinctSamplerAvals][0]!;
+    const texVal = texAval.getValue(token);
+    const samplerVal = samplerAval.getValue(token);
     void samplerAval;
     if (texVal === undefined || samplerVal === undefined) {
       throw new Error("heapAdapter: missing texture/sampler value");
@@ -288,9 +322,9 @@ export function renderObjectToHeapSpec(
         sampler: ISampler.fromGPU(samplerVal.sampler),
       };
     }
-  } else if (ro.textures.count > 0 || ro.samplers.count > 0) {
+  } else if (distinctTexAvals.size > 0 || distinctSamplerAvals.size > 0) {
     throw new Error(
-      `heapAdapter: RO has ${ro.textures.count} texture(s) and ${ro.samplers.count} sampler(s); ` +
+      `heapAdapter: RO has ${distinctTexAvals.size} distinct texture aval(s) and ${distinctSamplerAvals.size} distinct sampler aval(s); ` +
       `single-pair only in v1 (classifier should have caught this)`,
     );
   }