@aardworx/wombat.rendering 0.19.24 → 0.20.0

package/src/runtime/heapAdapter.ts

@@ -113,6 +113,8 @@ import type { HeapDrawSpec, HeapTextureSet } from "./heapScene.js";
 import { isBufferView } from "./heapScene/pools.js";
 import { compileHeapEffect } from "./heapEffect.js";
 import { AtlasPool } from "./textureAtlas/atlasPool.js";
+import { STANDARD_DERIVED_RULES, STANDARD_TRAFO_LEAVES } from "./derivedUniforms/recipes.js";
+import { inputsOf } from "./derivedUniforms/flatten.js";
 
 /**
  * View `HostBufferSource` as `Uint32Array`. Index buffers are u32 in
@@ -326,6 +328,7 @@ export function renderObjectToHeapSpec(
   ro: RenderObject,
   token: AdaptiveToken,
   pool?: AtlasPool,
+  opts?: { readonly enableDerivedUniforms?: boolean },
 ): HeapDrawSpec {
   // 1. Inputs map: vertex attributes (BufferView) + uniforms, pulled
   //    SHADER-DRIVEN from the providers. We compile `ro.effect` (cached
@@ -356,12 +359,38 @@ export function renderObjectToHeapSpec(
     const av = uProv.tryGet(name);
     if (av !== undefined) inputs[name] = av;
   };
-  for (const u of schema.uniforms) pullUniform(u.name);
+  // §7-covered derived trafos (ModelViewProjTrafo, NormalMatrix, …) are
+  // GPU-computed from the M/V/P constituents — addDraw never reads their
+  // `spec.inputs` entry when the rule applies. Deferring the pull keeps
+  // the provider from materialising a per-RO derived-aval chain (MapVal +
+  // nested closure contexts + a never-forced lazy constant) that would sit
+  // in `inputs` as pure ballast. Pulled after all as a fallback only when
+  // the recipe's base leaves turn out not to be bound (mirrors
+  // heapScene's `ruleForUniform` applicability test).
+  const deriveOnGpu = opts?.enableDerivedUniforms !== false;
+  const deferredDerived: string[] = [];
+  for (const u of schema.uniforms) {
+    if (deriveOnGpu && STANDARD_DERIVED_RULES.has(u.name)) {
+      deferredDerived.push(u.name);
+      continue;
+    }
+    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);
+  for (const name of deferredDerived) {
+    const rule = STANDARD_DERIVED_RULES.get(name)!;
+    let leavesBound = true;
+    for (const inp of inputsOf(rule.ir)) {
+      if (inp.name === "Model" && ro.modelChain !== undefined) continue;
+      const specName = STANDARD_TRAFO_LEAVES.get(inp.name) ?? inp.name;
+      if (inputs[specName] === undefined) { leavesBound = false; break; }
+    }
+    if (!leavesBound) pullUniform(name);
+  }
 
   // 1b. Instance attributes — provider is map-backed (user-supplied via
   //     `Sg.instanced({attributes})`), so enumerate its names. Threaded
@@ -399,9 +428,11 @@ export function renderObjectToHeapSpec(
   //    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>>();
+  // `let` + nulled after use: the spec's long-lived closures share
+  // this scope context — a leftover Set here is per-RO ballast.
+  let distinctTexAvals: Set<aval<ITexture>> | undefined = new Set<aval<ITexture>>();
+  ro.textures.iter((_n, av) => { distinctTexAvals!.add(av as aval<ITexture>); });
+  let distinctSamplerAvals: Set<aval<ISampler>> | undefined = new Set<aval<ISampler>>();
   // Shader-defined sampler state (from a `sampler2d { filter …; addressU … }`
   // builder, carried through the IR) overrides the scene's default sampler.
   const stateBinding = schema.samplers.find(b => b.state !== undefined);
@@ -418,7 +449,7 @@ export function renderObjectToHeapSpec(
       AVal.constant(ISampler.fromDescriptor(desc)) as aval<ISampler>,
     );
   } else {
-    ro.samplers.iter((_n, av) => { distinctSamplerAvals.add(av as aval<ISampler>); });
+    ro.samplers.iter((_n, av) => { distinctSamplerAvals!.add(av as aval<ISampler>); });
   }
   let textures: HeapTextureSet | undefined;
   if (distinctTexAvals.size === 1 && distinctSamplerAvals.size === 1) {
@@ -531,6 +562,9 @@ export function renderObjectToHeapSpec(
       `single-pair only in v1 (classifier should have caught this)`,
     );
   }
+  // Drop the dedup scratch — see the `let` note above.
+  distinctTexAvals = undefined;
+  distinctSamplerAvals = undefined;
 
   // 4. DrawCall geometry. Classifier validates fields are heap-
   //    compatible (instanceCount≥1, firstInstance=0, non-indexed firstVertex=0).
@@ -550,12 +584,16 @@ export function renderObjectToHeapSpec(
 
   return {
     effect: ro.effect,
+    ...(ro.pickId !== undefined ? { pickId: ro.pickId } : {}),
     pipelineState: ro.pipelineState,
     inputs,
     ...(instanceAttributes !== undefined ? { instanceAttributes } : {}),
     ...(dc.instanceCount > 1 ? { instanceCount: dc.instanceCount } : {}),
     ...geom,
     ...(textures !== undefined ? { textures } : {}),
+    ...(ro.injectedStorage !== undefined && ro.injectedStorage.count > 0
+      ? { storageBuffers: (() => { const m = new Map<string, aval<IBuffer>>(); ro.injectedStorage!.iter((n, av) => { m.set(n, av); }); return m; })() }
+      : {}),
     ...(ro.modeRules !== undefined ? { modeRules: ro.modeRules } : {}),
     ...(ro.modelChain !== undefined ? { modelChain: ro.modelChain } : {}),
     // Pass `active` through unforced so the heap path can subscribe

package/src/runtime/heapDecoder.ts

@@ -46,6 +46,7 @@ import {
   Tu32, Tf32,
 } from "@aardworx/wombat.shader/ir";
 import type { BucketLayout, DrawHeaderField } from "./heapEffect.js";
+import { isInlineHeaderField } from "./heapEffect.js";
 import {
   Tvec2, Tvec3, Tvec4, Tmat4, TarrU32,
   constU32, add, mul, div, item, newVec, readScope,
@@ -307,9 +308,13 @@ function addUniformOutput(
   }
   const irType = wgslTypeToIrType(wgslType);
   const refExpr = loadHeaderRef(drawIdxExpr, f.byteOffset, layout.strideU32);
-  const value = layout.perInstanceUniforms.has(f.name)
-    ? loadInstanceByRef(refExpr, instIdExpr, wgslType)
-    : loadUniformByRef(refExpr, wgslType);
+  // Inline fields (PickId, __layoutId family): the header word IS the
+  // u32 value — no arena indirection, no pool entry per draw.
+  const value = isInlineHeaderField(f)
+    ? refExpr
+    : layout.perInstanceUniforms.has(f.name)
+      ? loadInstanceByRef(refExpr, instIdExpr, wgslType)
+      : loadUniformByRef(refExpr, wgslType);
 
   outputs.push({
     name: f.name,

package/src/runtime/heapEffect.ts

@@ -75,6 +75,10 @@ export interface HeapEffectSchema {
   readonly fragmentOutputs: readonly { readonly name: string; readonly location: number; readonly wgslType: string }[];
   readonly textures: readonly HeapTextureBinding[];
   readonly samplers: readonly HeapSamplerBinding[];
+  /** User-declared storage buffers (the OIT node pool & co) — bound at
+   *  bucket level from scene-shared avals (`HeapDrawSpec.storageBuffers`).
+   *  Absent/empty for ordinary effects. */
+  readonly storageBuffers?: readonly { readonly name: string; readonly access: "read" | "read_write" }[];
 }
 
 export interface CompiledHeapEffect {
@@ -104,7 +108,21 @@ export interface FragmentOutputLayout {
 // and on quota; every failure simply degrades to "recompute".
 
 /** Cache-generation stamp for the persistent (localStorage) tier. */
-export const HEAP_PERSIST_VERSION = "h2";
+export const HEAP_PERSIST_VERSION = "h7"; // h7: OIT resolve early-exit
+
+/**
+ * Uniforms whose drawHeader word IS the u32 value (no arena
+ * indirection, no pool entry, no per-RO aval) — the `__layoutId`
+ * mechanism generalised. Values come from first-class RenderObject
+ * fields (`ro.pickId`), not the uniform provider. Fields must be
+ * u32-typed.
+ */
+export const INLINE_HEADER_UNIFORMS: ReadonlySet<string> = new Set(["PickId"]);
+
+/** True for fields read inline from the drawHeader word. */
+export function isInlineHeaderField(f: { kind: string; name: string }): boolean {
+  return f.kind === "uniform-ref" && (f.name === "__layoutId" || INLINE_HEADER_UNIFORMS.has(f.name));
+}
 export const HEAP_PERSIST_PREFIX = "wbt.heapfx.";
 
 export function persistKey(version: string, kind: string, contentKey: string): string {
@@ -261,7 +279,11 @@ function buildSchema(iface: ProgramInterface): HeapEffectSchema {
     name: s.name, wgslType: isComparison(s.type) ? "sampler_comparison" : "sampler",
     ...(s.state !== undefined ? { state: s.state } : {}),
   }));
-  return { attributes, uniforms, varyings, fragmentOutputs, textures, samplers };
+  const storageBuffers = iface.storageBuffers.map(sb => ({ name: sb.name, access: sb.access }));
+  return {
+    attributes, uniforms, varyings, fragmentOutputs, textures, samplers,
+    ...(storageBuffers.length > 0 ? { storageBuffers } : {}),
+  };
 }
 
 function irTypeToWgsl(t: IrType): string {
@@ -375,6 +397,15 @@ export interface BucketLayout {
    * `atlasSample(...)` helper for these names only.
    */
   readonly atlasTextureBindings: ReadonlySet<string>;
+  /**
+   * User storage-buffer bindings (allocated from
+   * HEAP_USER_STORAGE_BINDING_BASE, above the atlas range). Bound at
+   * bucket level from `HeapDrawSpec.storageBuffers` — every RO in the
+   * bucket shares the same buffers (they are scene-level injections
+   * like the OIT node pool). FRAGMENT visibility only (WebGPU forbids
+   * writable storage in vertex stages).
+   */
+  readonly storageBindings: readonly { readonly name: string; readonly access: "read" | "read_write"; readonly binding: number }[];
 }
 
 /**
@@ -398,6 +429,8 @@ export const ATLAS_LINEAR_BINDING_BASE = 11;
 export const ATLAS_SRGB_BINDING_BASE = ATLAS_LINEAR_BINDING_BASE + ATLAS_ARRAY_SIZE;
 /** Atlas sampler binding (= linear base + 2N). */
 export const ATLAS_SAMPLER_BINDING = ATLAS_LINEAR_BINDING_BASE + 2 * ATLAS_ARRAY_SIZE;
+/** First user storage-buffer binding (above the whole atlas range). */
+export const HEAP_USER_STORAGE_BINDING_BASE = ATLAS_SAMPLER_BINDING + 1;
 
 export function buildBucketLayout(
   schema: HeapEffectSchema,
@@ -522,10 +555,18 @@ export function buildBucketLayout(
     isAtlasBucket,
   );
 
+  // User storage buffers: deterministic order (by name) starting above
+  // the atlas binding range.
+  let nextStorageBinding = HEAP_USER_STORAGE_BINDING_BASE;
+  const storageBindings = [...(schema.storageBuffers ?? [])]
+    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+    .map(sb => ({ name: sb.name, access: sb.access, binding: nextStorageBinding++ }));
+
   const base = {
     drawHeaderFields, drawHeaderBytes, preludeWgsl, strideU32,
     perInstanceUniforms, perInstanceAttributes,
     textureBindings, samplerBindings, atlasTextureBindings,
+    storageBindings,
   };
   return { id: bucketLayoutId(base), ...base };
 }
@@ -553,6 +594,7 @@ export function bucketLayoutId(l: Omit<BucketLayout, "id">): string {
   parts.push("PIA:" + [...l.perInstanceAttributes].sort().join(","));
   for (const t of l.textureBindings) parts.push(`T:${t.name}|${t.wgslType}|${t.binding}`);
   for (const s of l.samplerBindings) parts.push(`S:${s.name}|${s.wgslType}|${s.binding}`);
+  for (const sb of l.storageBindings) parts.push(`SB:${sb.name}|${sb.access}|${sb.binding}`);
   parts.push("ATB:" + [...l.atlasTextureBindings].sort().join(","));
   // The prelude is derived from the above, but fold its hash in too —
   // cheap insurance against any generator path the field list misses.

package/src/runtime/heapEffectIR.ts

@@ -18,8 +18,10 @@
 // consumes is identical to the one heapScene.ts already builds.
 
 import { compileModule, stage as makeStage, effect as makeEffect } from "@aardworx/wombat.shader";
+import { isInlineHeaderField } from "./heapEffect.js";
 import type { Effect, CompileOptions } from "@aardworx/wombat.shader";
-import { substituteInputsInStage, readInputs, mapExpr, mapStmt, liftReturns, uniformsToInputs } from "@aardworx/wombat.shader/passes";
+import { substituteInputsInStage, readInputs, mapExpr, mapStmt, liftReturns, uniformsToInputs, resolveHoles } from "@aardworx/wombat.shader/passes";
+import type { HoleValue } from "@aardworx/wombat.shader/passes";
 import { synthesizeHeapDecoderModule } from "./heapDecoder.js";
 import {
   type Module, type Expr, type Stmt, type Type, type ValueDef,
@@ -278,9 +280,12 @@ function buildVertexUniformMap(layout: BucketLayout): Map<string, Expr> {
   for (const f of layout.drawHeaderFields) {
     if (f.kind !== "uniform-ref") continue;
     const refExpr = loadHeaderRef(drawIdx, f.byteOffset, stride);
-    const value = layout.perInstanceUniforms.has(f.name)
-      ? loadInstanceByRef(refExpr, iidx, f.uniformWgslType ?? "")
-      : loadUniformByRef(refExpr, f.uniformWgslType ?? "");
+    // Inline fields: the header word IS the u32 value.
+    const value = isInlineHeaderField(f)
+      ? refExpr
+      : layout.perInstanceUniforms.has(f.name)
+        ? loadInstanceByRef(refExpr, iidx, f.uniformWgslType ?? "")
+        : loadUniformByRef(refExpr, f.uniformWgslType ?? "");
     out.set(f.name, value);
   }
   return out;
@@ -420,9 +425,11 @@ function rewriteFsUniformsDirect(m: Module, layout: BucketLayout): Module {
     const f = fieldByName.get(name);
     if (f === undefined || f.kind !== "uniform-ref") continue;
     const refExpr = loadHeaderRef(drawIdxExpr, f.byteOffset, layout.strideU32);
-    const value = layout.perInstanceUniforms.has(name)
-      ? loadInstanceByRef(refExpr, instIdExpr, f.uniformWgslType ?? "")
-      : loadUniformByRef(refExpr, f.uniformWgslType ?? "");
+    const value = isInlineHeaderField(f)
+      ? refExpr
+      : layout.perInstanceUniforms.has(name)
+        ? loadInstanceByRef(refExpr, instIdExpr, f.uniformWgslType ?? "")
+        : loadUniformByRef(refExpr, f.uniformWgslType ?? "");
     fsSubst.set(name, value);
   }
   return substituteInputsInStage(m, "fragment", "Uniform", n => fsSubst.get(n));
@@ -541,9 +548,12 @@ function rewriteFsUniforms(m: Module, layout: BucketLayout): Module {
       value: { kind: "Expr", value: refExprWriter },
     });
     const refReadFs = readScope("Input", refParamName, Tu32);
-    const value = layout.perInstanceUniforms.has(name)
-      ? loadInstanceByRef(refReadFs, readScope("Input", "_iidx", Tu32), f.uniformWgslType ?? "")
-      : loadUniformByRef(refReadFs, f.uniformWgslType ?? "");
+    // Inline fields: the threaded varying already carries the value.
+    const value = isInlineHeaderField(f)
+      ? refReadFs
+      : layout.perInstanceUniforms.has(name)
+        ? loadInstanceByRef(refReadFs, readScope("Input", "_iidx", Tu32), f.uniformWgslType ?? "")
+        : loadUniformByRef(refReadFs, f.uniformWgslType ?? "");
     fsSubst.set(name, value);
   }
 
@@ -1011,6 +1021,22 @@ function compileHeapEffectIRViaDecoder(
   // from the carrier varyings the decoder wrote).
   combined = rewriteFsAtlasTexturesViaCarrier(combined, layout);
 
+  // 6b. USER storage buffers (the OIT node pool & co): pin each to the
+  // slot the bucket's BGL committed to. `keep: true` makes the emitter
+  // use it verbatim (and stops `reduceUniforms` dropping an unreferenced
+  // one). Without this the emitter auto-assigns sequentially and collides
+  // with the heap's own reserved bindings.
+  if (layout.storageBindings.length > 0) {
+    const userStorageSlot = new Map(layout.storageBindings.map(b => [b.name, b.binding]));
+    combined = {
+      ...combined,
+      values: combined.values.map(v =>
+        v.kind === "StorageBuffer" && userStorageSlot.has(v.name)
+          ? { ...v, binding: { group: 0, slot: userStorageSlot.get(v.name)! }, keep: true }
+          : v),
+    };
+  }
+
   // 7. Compile.
   const compiled = compileModule(combined, compileOptions);
   if ((globalThis as { __HEAP_DEBUG_FULL__?: boolean }).__HEAP_DEBUG_FULL__) {
@@ -1557,7 +1583,24 @@ function mergeStages(eff: Effect): Module {
   // Combine all stages' templates into one module by concatenating
   // their values + types arrays. The compile pipeline's composeStages
   // pass will fuse same-stage entries afterwards.
+  //
+  // Closure holes are resolved here (per stage, with that stage's
+  // getters) — Effect.compile does this on the classic path, but the
+  // heap pipeline compiles the raw templates directly, and an
+  // unresolved `ReadInput("Closure", …)` emits as a bare identifier
+  // ("unresolved value" at pipeline compile). Constant captures like
+  // an OIT writer's node-pool capacity are the norm in composed
+  // effects.
   const types = eff.stages.flatMap(s => [...s.template.types]);
-  const values = eff.stages.flatMap(s => [...s.template.values]);
+  const values = eff.stages.flatMap(s => {
+    let hasHoles = false;
+    const sampled: Record<string, HoleValue> = {};
+    for (const [name, getter] of Object.entries(s.holes ?? {})) {
+      sampled[name] = getter();
+      hasHoles = true;
+    }
+    const filled = hasHoles ? resolveHoles(s.template, sampled) : s.template;
+    return [...filled.values];
+  });
   return { types, values };
 }

package/src/runtime/heapEligibility.ts

@@ -34,7 +34,7 @@
 // grows feature support each becomes a per-buffer eligibility
 // question instead of a blanket "no".
 
-import { AVal, type aval } from "@aardworx/wombat.adaptive";
+import { AVal, AdaptiveToken, type aval } from "@aardworx/wombat.adaptive";
 import type { IBuffer } from "../core/buffer.js";
 import type { BufferView } from "../core/bufferView.js";
 import type { ITexture } from "../core/texture.js";
@@ -174,14 +174,14 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
   // per-RO path, which at scale (thousands of textured ROs ⇒ thousands
   // of draw calls + bind-group switches) is far slower than the heap
   // megacall sampling one shared atlas page.
-  const distinctTextureAvals = new Set<aval<ITexture>>();
-  ro.textures.iter((_n, av) => { distinctTextureAvals.add(av); });
-  if (distinctTextureAvals.size > 1) {
+  // NOTE identity-dedup WITHOUT a Set: the long-lived AVal.custom
+  // closure below shares this function's V8 scope context, so any
+  // temporary Set here would be retained per-RO for the scene's
+  // lifetime (measured: 1 Set/RO of pure ballast at heap scale).
+  if (countDistinct(ro.textures) > 1) {
     return AVal.constant(false);
   }
-  const distinctSamplerAvals = new Set<aval<ISampler>>();
-  ro.samplers.iter((_n, av) => { distinctSamplerAvals.add(av); });
-  if (distinctSamplerAvals.size > 1) {
+  if (countDistinct(ro.samplers) > 1) {
     return AVal.constant(false);
   }
 
@@ -202,11 +202,16 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
   const textures = textureAvals(ro);
   const samplers = samplerAvals(ro);
 
-  // Reactive AND-fold over all participating avals. We also subscribe
-  // to drawCall (instanceCount/baseVertex/firstIndex/firstInstance
-  // can flip; if they violate heap constraints the RO routes to the
-  // legacy path that frame).
-  return AVal.custom(token => {
+  // Constant collapse: when every participating aval is constant the
+  // answer can never change — evaluate once and return a plain
+  // constant. This keeps the hybrid partition from holding a custom
+  // aval + subscriptions per static RO (the overwhelmingly common
+  // case at heap scale).
+  let allConstant = ro.drawCall.isConstant;
+  if (allConstant) for (const av of buffers)  { if (!av.isConstant) { allConstant = false; break; } }
+  if (allConstant) for (const av of textures) { if (!av.isConstant) { allConstant = false; break; } }
+  if (allConstant) for (const av of samplers) { if (!av.isConstant) { allConstant = false; break; } }
+  const evaluate = (token: AdaptiveToken): boolean => {
     let payloadBytes = 0;
     for (const av of buffers) {
       const b = av.getValue(token);
@@ -240,5 +245,27 @@ export function isHeapEligible(ro: RenderObject): aval<boolean> {
       if (dc.firstVertex !== 0) return false;
     }
     return true;
+  };
+  if (allConstant) return AVal.constant(evaluate(AdaptiveToken.top));
+  // Reactive AND-fold over all participating avals. We also subscribe
+  // to drawCall (instanceCount/baseVertex/firstIndex/firstInstance
+  // can flip; if they violate heap constraints the RO routes to the
+  // legacy path that frame).
+  return AVal.custom(evaluate);
+}
+
+
+/** Count distinct avals in a name→aval map by identity, allocation-free
+ *  for the 0/1/2-distinct cases that matter (we only compare > 1). */
+function countDistinct(m: { iter(f: (n: string, av: aval<unknown>) => void): void }): number {
+  let first: aval<unknown> | undefined;
+  let second: aval<unknown> | undefined;
+  let n = 0;
+  m.iter((_n, av) => {
+    if (av === first || av === second) return;
+    if (first === undefined) { first = av; n = 1; }
+    else if (second === undefined) { second = av; n = 2; }
+    else n++;
   });
+  return n;
 }

package/src/runtime/heapIrBuilders.ts

@@ -62,6 +62,23 @@ export const shr = (lhs: Expr, rhs: Expr, type: Type): Expr => ({
 export const select = (cond: Expr, ifTrue: Expr, ifFalse: Expr, type: Type): Expr => ({
   kind: "Conditional", cond, ifTrue, ifFalse, type,
 });
+export const bitAnd = (lhs: Expr, rhs: Expr, type: Type): Expr => ({
+  kind: "BitAnd", lhs, rhs, type,
+});
+export const ltF32 = (lhs: Expr, rhs: Expr): Expr => ({ kind: "Lt", lhs, rhs, type: Tbool });
+export const geF32 = (lhs: Expr, rhs: Expr): Expr => ({ kind: "Ge", lhs, rhs, type: Tbool });
+/** u32 → f32 numeric conversion. */
+export const toF32 = (value: Expr): Expr => ({ kind: "Convert", value, type: Tf32 } as Expr);
+/** Pure WGSL/GLSL intrinsic call (same emit name unless glsl differs). */
+const callIntrinsic = (wgsl: string, glsl: string, ret: Type, args: Expr[]): Expr => ({
+  kind: "CallIntrinsic",
+  op: { name: wgsl, returnTypeOf: () => ret, pure: true, emit: { wgsl, glsl } },
+  args, type: ret,
+} as Expr);
+export const absF32 = (e: Expr): Expr => callIntrinsic("abs", "abs", Tf32, [e]);
+export const normalize3 = (e: Expr): Expr => callIntrinsic("normalize", "normalize", Tvec3, [e]);
+export const unpack4x8unorm = (e: Expr): Expr =>
+  callIntrinsic("unpack4x8unorm", "unpackUnorm4x8", Tvec4, [e]);
 export const newVec = (components: Expr[], type: Type): Expr => ({
   kind: "NewVector", components, type,
 });
@@ -174,14 +191,40 @@ export function loadAttributeByRef(refIdent: Expr, idx: Expr, wgslType: string):
     const length = item(heapU32, add(div(refIdent, constU32(4), Tu32), constU32(1), Tu32), Tu32);
     return mul(mod(idx, length, Tu32), constU32(elemSize), Tu32);
   };
+  /** Header typeId (word 0 — same 16-byte cache line as the length the
+   *  broadcast modulo already loads, so the packed-encoding branch costs
+   *  no extra memory round-trip and is warp-coherent per field). */
+  const typeId = item(heapU32, div(refIdent, constU32(4), Tu32), Tu32);
+  /** One u32 element at the cyclic index (packed encodings: 4 B/elt). */
+  const packedWord = (): Expr => add(dataF32Base, cyclic(1), Tu32);
   switch (wgslType) {
     case "vec3<f32>": {
       const base = add(dataF32Base, cyclic(3), Tu32);
-      return newVec([
+      const tight = newVec([
         item(heapF32, base, Tf32),
         item(heapF32, add(base, constU32(1), Tu32), Tf32),
         item(heapF32, add(base, constU32(2), Tu32), Tf32),
       ], Tvec3);
+      // ENC_OCT32 (typeId 2): one u32/element — x = low unorm16, y = high
+      // unorm16, both → [-1,1]; octahedral fold when z<0 (matches
+      // build_vienna.py's oct_pack and the CPU decoder in renderbench).
+      const u = item(heapU32, packedWord(), Tu32);
+      const toSnorm = (word: Expr): Expr =>
+        add(mul(toF32(word), constF32(2 / 65535), Tf32), constF32(-1.0), Tf32);
+      const fx = toSnorm(bitAnd(u, constU32(0xffff), Tu32));
+      const fy = toSnorm(shr(u, constU32(16), Tu32));
+      const z = sub(sub(constF32(1.0), absF32(fx), Tf32), absF32(fy), Tf32);
+      const neg = ltF32(z, constF32(0.0));
+      const signOf = (v: Expr): Expr =>
+        select(geF32(v, constF32(0.0)), constF32(1.0), constF32(-1.0), Tf32);
+      const fold = (a: Expr, b: Expr): Expr =>   // (1-|b|) * sign(a)
+        mul(sub(constF32(1.0), absF32(b), Tf32), signOf(a), Tf32);
+      const oct = normalize3(newVec([
+        select(neg, fold(fx, fy), fx, Tf32),
+        select(neg, fold(fy, fx), fy, Tf32),
+        z,
+      ], Tvec3));
+      return select(eqU32(typeId, constU32(2 /* ENC_OCT32 */)), oct, tight, Tvec3);
     }
     case "vec4<f32>": {
       const strideBytes = item(heapU32, add(div(refIdent, constU32(4), Tu32), constU32(2), Tu32), Tu32);
@@ -190,12 +233,17 @@ export function loadAttributeByRef(refIdent: Expr, idx: Expr, wgslType: string):
       const off = mul(cycled, strideF, Tu32);
       const base = add(dataF32Base, off, Tu32);
       const w = select(eqU32(strideF, constU32(4)), item(heapF32, add(base, constU32(3), Tu32), Tf32), constF32(1.0), Tf32);
-      return newVec([
+      const tight = newVec([
         item(heapF32, base, Tf32),
         item(heapF32, add(base, constU32(1), Tu32), Tf32),
         item(heapF32, add(base, constU32(2), Tu32), Tf32),
         w,
       ], Tvec4);
+      // ENC_C4B (typeId 3): one u32/element, RGBA8 unorm — a single
+      // hardware unpack. (Vienna colours ship as C4b; storing them raw is
+      // 4 B/vertex instead of the 12 B tight-RGB expansion.)
+      const c4b = unpack4x8unorm(item(heapU32, packedWord(), Tu32));
+      return select(eqU32(typeId, constU32(3 /* ENC_C4B */)), c4b, tight, Tvec4);
     }
     case "vec2<f32>": {
       const base = add(dataF32Base, cyclic(2), Tu32);