@aardworx/wombat.rendering 0.9.32 → 0.18.1

package/dist/runtime/derivedModes/partitionKernel.js

@@ -0,0 +1,127 @@
+// Phase 5c.3 partition kernel — GPU-driven record routing.
+//
+// Each frame the kernel runs over a bucket's master record pool. For
+// each record, it evaluates the rule (currently hard-coded: flip
+// cullMode by sign of det(upperLeft3x3) of the record's ModelTrafo),
+// picks the destination slot index (0 = declared, 1 = flipped),
+// atomically reserves a write offset in that slot, and copies the
+// record into `slotDrawTable[slotIdx][offset]`.
+//
+// Buffer layout (one bucket):
+//
+//   masterRecords: array<Record>            // CPU populates at addRO
+//   numRecords:    u32 (uniform)
+//   slot0Indirect: array<u32, 4>            // (indexCount, instanceCount=1, 0, 0)
+//   slot1Indirect: array<u32, 4>            // ditto
+//   slot0DrawTable: array<Record>           // partition output
+//   slot1DrawTable: array<Record>           // partition output
+//   slot0ScanParams: { numRecords: u32 ... }
+//   slot1ScanParams: { numRecords: u32 ... }
+//
+// The existing scan (HEAP_SCAN_WGSL in heapScene/scanKernel.ts) runs
+// per slot AFTER partition: it reads the slot's drawTable, computes
+// firstEmit prefix sums, and writes the final indirect[0] = totalEmit.
+//
+// What this kernel does NOT do:
+//   - Generalize beyond the determinant-flip-cull rule (v1 only).
+//   - Handle >2 slots per bucket. (For multi-output rules, future
+//     work: dynamic slot count, modeKey-table lookup.)
+//   - Manage record removal — that's CPU at removeDraw time (swap-pop
+//     the master pool).
+import { CULL_TO_U32 } from "./gpuKernel.js";
+/** Record layout: 6 × u32 = 24 bytes per record. Matches the heap
+ *  scan's record format (5 × u32) plus a `modelRef` byte offset. */
+export const PARTITION_RECORD_U32 = 6;
+export const PARTITION_RECORD_BYTES = PARTITION_RECORD_U32 * 4;
+/** Per-bucket partition kernel WGSL. Two output slots: declared
+ *  + flipped. */
+export const PARTITION_FLIP_CULL_BY_DET_WGSL = /* wgsl */ `
+struct Record {
+  // firstEmit is GPU-written by the scan; leave as 0 here.
+  firstEmit:     u32,
+  drawIdx:       u32,
+  indexStart:    u32,
+  indexCount:    u32,
+  instanceCount: u32,
+  modelRef:      u32,
+};
+struct PartitionParams {
+  numRecords:     u32,
+  declaredCull:   u32,   // 0=none, 1=front, 2=back
+  _pad0:          u32,
+  _pad1:          u32,
+};
+
+@group(0) @binding(0) var<storage, read>        arena:           array<u32>;
+@group(0) @binding(1) var<storage, read>        masterRecords:   array<Record>;
+@group(0) @binding(2) var<uniform>              params:          PartitionParams;
+// Slot 0 = declared cull mode. Slot 1 = flipped cull mode.
+@group(0) @binding(3) var<storage, read_write>  slot0Count:      array<atomic<u32>>;  // length 1
+@group(0) @binding(4) var<storage, read_write>  slot1Count:      array<atomic<u32>>;
+// Slot draw tables hold scan-format records (5 × u32 per record:
+// firstEmit, drawIdx, indexStart, indexCount, instanceCount). We
+// drop modelRef on scatter — only the partition kernel needs it,
+// and including it would force the scan to read a 6-u32 stride.
+@group(0) @binding(5) var<storage, read_write>  slot0DrawTable:  array<u32>;
+@group(0) @binding(6) var<storage, read_write>  slot1DrawTable:  array<u32>;
+
+const SCAN_REC_U32: u32 = 5u;
+
+fn loadUpper3x3(refBytes: u32) -> array<f32, 9> {
+  let baseU32 = (refBytes + 16u) >> 2u;
+  return array<f32, 9>(
+    bitcast<f32>(arena[baseU32 + 0u]),  bitcast<f32>(arena[baseU32 + 1u]),  bitcast<f32>(arena[baseU32 + 2u]),
+    bitcast<f32>(arena[baseU32 + 4u]),  bitcast<f32>(arena[baseU32 + 5u]),  bitcast<f32>(arena[baseU32 + 6u]),
+    bitcast<f32>(arena[baseU32 + 8u]),  bitcast<f32>(arena[baseU32 + 9u]),  bitcast<f32>(arena[baseU32 + 10u]),
+  );
+}
+
+fn det3x3(m: array<f32, 9>) -> f32 {
+  return m[0] * (m[4] * m[8] - m[5] * m[7])
+       - m[1] * (m[3] * m[8] - m[5] * m[6])
+       + m[2] * (m[3] * m[7] - m[4] * m[6]);
+}
+
+@compute @workgroup_size(64)
+fn clear(@builtin(global_invocation_id) gid: vec3<u32>) {
+  // One thread total clears both atomics. Cheap pass.
+  if (gid.x != 0u) { return; }
+  atomicStore(&slot0Count[0], 0u);
+  atomicStore(&slot1Count[0], 0u);
+}
+
+@compute @workgroup_size(64)
+fn partition(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x;
+  if (i >= params.numRecords) { return; }
+  let r = masterRecords[i];
+  let m = loadUpper3x3(r.modelRef);
+  let flipped = det3x3(m) < 0.0;
+  // slotIdx 0 = declared (not flipped), 1 = flipped.
+  // Atomic-add into the appropriate slot's count, then scatter the
+  // record into the slot's drawTable at the reserved offset.
+  if (flipped) {
+    let off = atomicAdd(&slot1Count[0], 1u);
+    let base = off * SCAN_REC_U32;
+    slot1DrawTable[base + 0u] = 0u;              // firstEmit (scan rewrites)
+    slot1DrawTable[base + 1u] = r.drawIdx;
+    slot1DrawTable[base + 2u] = r.indexStart;
+    slot1DrawTable[base + 3u] = r.indexCount;
+    slot1DrawTable[base + 4u] = r.instanceCount;
+  } else {
+    let off = atomicAdd(&slot0Count[0], 1u);
+    let base = off * SCAN_REC_U32;
+    slot0DrawTable[base + 0u] = 0u;
+    slot0DrawTable[base + 1u] = r.drawIdx;
+    slot0DrawTable[base + 2u] = r.indexStart;
+    slot0DrawTable[base + 3u] = r.indexCount;
+    slot0DrawTable[base + 4u] = r.instanceCount;
+  }
+}
+`;
+/** WGSL helper: pack a Trafo3d's upper-left 3×3 + a CullMode enum
+ *  into the partition kernel's expected uniform layout. */
+export function cullModeToU32(c) {
+    return CULL_TO_U32[c];
+}
+//# sourceMappingURL=partitionKernel.js.map

package/dist/runtime/derivedModes/partitionKernel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionKernel.js","sourceRoot":"","sources":["../../../src/runtime/derivedModes/partitionKernel.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,EAAE;AACF,qEAAqE;AACrE,iEAAiE;AACjE,qEAAqE;AACrE,gEAAgE;AAChE,kEAAkE;AAClE,gDAAgD;AAChD,EAAE;AACF,8BAA8B;AAC9B,EAAE;AACF,sEAAsE;AACtE,iCAAiC;AACjC,mFAAmF;AACnF,qDAAqD;AACrD,gEAAgE;AAChE,gEAAgE;AAChE,6CAA6C;AAC7C,6CAA6C;AAC7C,EAAE;AACF,qEAAqE;AACrE,oEAAoE;AACpE,uEAAuE;AACvE,EAAE;AACF,gCAAgC;AAChC,kEAAkE;AAClE,kEAAkE;AAClE,uDAAuD;AACvD,sEAAsE;AACtE,wBAAwB;AAGxB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;oEACoE;AACpE,MAAM,CAAC,MAAM,oBAAoB,GAAK,CAAC,CAAC;AACxC,MAAM,CAAC,MAAM,sBAAsB,GAAG,oBAAoB,GAAG,CAAC,CAAC;AAE/D;iBACiB;AACjB,MAAM,CAAC,MAAM,+BAA+B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFzD,CAAC;AAEF;2DAC2D;AAC3D,MAAM,UAAU,aAAa,CAAC,CAAW;IACvC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC;AACxB,CAAC"}

package/dist/runtime/derivedModes/partitionKernelLayout.d.ts

@@ -0,0 +1,4 @@
+export declare const PARTITION_RECORD_PREFIX_U32 = 6;
+export declare function partitionRecordU32(numUniforms: number): number;
+export declare function partitionRecordBytes(numUniforms: number): number;
+//# sourceMappingURL=partitionKernelLayout.d.ts.map

package/dist/runtime/derivedModes/partitionKernelLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionKernelLayout.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/partitionKernelLayout.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AACD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhE"}

package/dist/runtime/derivedModes/partitionKernelLayout.js

@@ -0,0 +1,24 @@
+// Partition kernel record layout — shared by the codegen + dispatcher.
+//
+// Each record in the master buffer has a FIXED 6-u32 prefix and a
+// per-bucket variable tail of K uniform refs:
+//
+//   [firstEmit, drawIdx, indexStart, indexCount, instanceCount, comboId,
+//    ref0, ref1, …, ref{K-1}]
+//
+// `firstEmit` is reserved (GPU-written by the downstream scan); CPU
+// writes 0. `comboId` selects which combo of axis-rules the partition
+// kernel evaluates — a combo is a per-RO choice of (at most one) rule
+// per mode axis. Each `refI` is the per-RO arena byte offset of the
+// I-th uniform appearing across all rules in the bucket
+// (`bucket.uniformOrder`). The kernel reads `r.refI` for whichever
+// uniform a given rule body declares via `ReadInput("Uniform", name)`
+// — the codegen translates name → refI lookup.
+export const PARTITION_RECORD_PREFIX_U32 = 6;
+export function partitionRecordU32(numUniforms) {
+    return PARTITION_RECORD_PREFIX_U32 + numUniforms;
+}
+export function partitionRecordBytes(numUniforms) {
+    return partitionRecordU32(numUniforms) * 4;
+}
+//# sourceMappingURL=partitionKernelLayout.js.map

package/dist/runtime/derivedModes/partitionKernelLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionKernelLayout.js","sourceRoot":"","sources":["../../../src/runtime/derivedModes/partitionKernelLayout.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,kEAAkE;AAClE,8CAA8C;AAC9C,EAAE;AACF,yEAAyE;AACzE,8BAA8B;AAC9B,EAAE;AACF,oEAAoE;AACpE,sEAAsE;AACtE,sEAAsE;AACtE,oEAAoE;AACpE,wDAAwD;AACxD,mEAAmE;AACnE,sEAAsE;AACtE,+CAA+C;AAE/C,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC;AAE7C,MAAM,UAAU,kBAAkB,CAAC,WAAmB;IACpD,OAAO,2BAA2B,GAAG,WAAW,CAAC;AACnD,CAAC;AACD,MAAM,UAAU,oBAAoB,CAAC,WAAmB;IACtD,OAAO,kBAAkB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;AAC7C,CAAC"}

package/dist/runtime/derivedModes/rule.d.ts

@@ -1,98 +1,50 @@
-import type { CullMode, FrontFace, Topology } from "../pipelineCache/index.js";
-/** Discrete pipeline-state axes a `derivedMode` rule can target. v1
- *  supports cull / frontFace / topology / depthCompare / depthWrite /
- *  blendEnabled. Stencil + per-attachment blend factor/operation are
- *  deferred — same carve-outs as `derived-modes.md`. */
-export type ModeAxis = "cull" | "frontFace" | "topology" | "depthCompare" | "depthWrite" | "alphaToCoverage";
-/** Output value type per axis. */
-export type ModeValue<A extends ModeAxis> = A extends "cull" ? CullMode : A extends "frontFace" ? FrontFace : A extends "topology" ? Topology : A extends "depthCompare" ? GPUCompareFunction : A extends "depthWrite" ? boolean : A extends "alphaToCoverage" ? boolean : never;
-/**
- * The closure signature a `derivedMode` rule body takes:
- *   - `u`: a proxy whose properties resolve to the RO's uniform values
- *     at evaluation time. The proxy is type-erased in v1 — declare the
- *     uniforms you'll read via `UniformScope` augmentation on the
- *     wombat.shader side for compile-time safety, or annotate locally.
- *   - `declared`: the SG-declared value for this axis at this leaf.
- *     Identity rules `(u, d) => d` are valid and useful for axes that
- *     want to pass declared through unchanged.
- */
-export type DerivedModeBuilder<A extends ModeAxis> = (u: Record<string, unknown>, declared: ModeValue<A>) => ModeValue<A>;
-/**
- * Opt-in GPU evaluation marker. When present on a rule, the heap
- * scene runs a hard-coded WGSL kernel (see `./gpuKernel.ts`) instead
- * of the CPU closure. The closure is retained for fallback (e.g.
- * MockGPU tests, devices without compute, or before frame 0).
- *
- * v1 supports one kernel: `"flipCullByDeterminant"`. v2 generalizes
- * via a traced IR builder.
- */
-export interface GpuRuleSpec<A extends ModeAxis = ModeAxis> {
-    readonly kernel: "flipCullByDeterminant";
-    /** Name of the input uniform the kernel reads (e.g. "ModelTrafo"). */
-    readonly inputUniform: string;
-    /**
-     * Declared (SG-scope) value the kernel mutates by. Either a plain
-     * mode value (baked at scene-build) or an `aval` for reactive
-     * declared — the dispatcher re-uploads the kernel uniform on each
-     * dispatch from the aval's current value, so flipping it via a UI
-     * cval re-runs the rule with the new declared.
-     */
-    readonly declared: ModeValue<A> | import("@aardworx/wombat.adaptive").aval<ModeValue<A>>;
-}
+import type { RuleExpr } from "@aardworx/wombat.shader";
+import type { aval } from "@aardworx/wombat.adaptive";
+import type { CullMode, FrontFace, Topology, AttachmentBlend } from "../pipelineCache/index.js";
+export type ModeAxis = "cull" | "frontFace" | "topology" | "depthCompare" | "depthWrite" | "alphaToCoverage"
+/** Per-attachment blend state. The rule's u32 output indexes into
+ *  the `values` array on `DerivedModeOptions` (or the `resolve`
+ *  callback); each entry is a full {@link AttachmentBlend} struct
+ *  with srcFactor / dstFactor / operation / writeMask / enabled
+ *  fields — letting blend rules specify the entire mode object,
+ *  not just an enum index. */
+ | "blend";
+export type ModeValue<A extends ModeAxis> = A extends "cull" ? CullMode : A extends "frontFace" ? FrontFace : A extends "topology" ? Topology : A extends "depthCompare" ? GPUCompareFunction : A extends "depthWrite" ? boolean : A extends "alphaToCoverage" ? boolean : A extends "blend" ? AttachmentBlend : never;
 export interface DerivedModeRule<A extends ModeAxis = ModeAxis> {
     readonly __derivedModeRule: true;
     readonly axis: A;
-    readonly evaluate: DerivedModeBuilder<A>;
-    /** Opt-in GPU evaluation. Absent → CPU closure path. */
-    readonly gpu?: GpuRuleSpec<A>;
+    /** Shader-IR rule body — the entry's return Expr is the rule. For
+     *  axes whose `ModeValue<A>` is a struct (e.g. blend's
+     *  `AttachmentBlend`) the body returns object literals directly;
+     *  the renderer fingerprints distinct returns and auto-assigns
+     *  slot indices. For enum axes (cull etc.) the body returns u32
+     *  enum indices that the renderer maps via the canonical table. */
+    readonly expr: RuleExpr<ModeValue<A> | number>;
     /**
-     * Conservative over-approximation of the rule's output set. Used by
-     * the build-time pre-warm in v2 to enumerate the pipelines a scene
-     * could realize. v1 doesn't use it at runtime, but recording it
-     * here keeps the API forward-compatible.
+     * SG-context value for this axis. Filled in by `<Sg CullMode>` /
+     * `<Sg DepthTest>` / etc. at traversal time — users never write
+     * it. The rule body's `declared` ambient leaf resolves to this;
+     * when the underlying aval marks, heapScene re-specialises +
+     * swaps the cached kernel + pipeline set.
+     *
+     * `undefined` is the initial state right after `derivedMode(...)`;
+     * the SG fills it in before the rule reaches the renderer.
      */
-    readonly domain?: ReadonlyArray<ModeValue<A>>;
+    readonly declared: aval<ModeValue<A>> | ModeValue<A> | undefined;
 }
-/**
- * Author a derived mode rule.
- *
- *     derivedMode("cull", (u, declared) =>
- *       u.WindingFlipped ? flipCull(declared) : declared);
- *
- *     derivedMode("blend", (u) => u.Premultiplied ? "premul" : "straight");
- *
- *     // Determinant-flip-cull (the motivating case):
- *     derivedMode("cull", (u, declared) => {
- *       const m = u.ModelTrafo as M44d;
- *       const det =
- *         m.M00 * (m.M11 * m.M22 - m.M12 * m.M21) -
- *         m.M01 * (m.M10 * m.M22 - m.M12 * m.M20) +
- *         m.M02 * (m.M10 * m.M21 - m.M11 * m.M20);
- *       return det < 0 ? flipCull(declared) : declared;
- *     });
- */
-export declare function derivedMode<A extends ModeAxis>(axis: A, evaluate: DerivedModeBuilder<A>, options?: {
-    readonly domain?: ReadonlyArray<ModeValue<A>>;
-}): DerivedModeRule<A>;
-/** Brand check — distinguishes a DerivedModeRule from an aval/raw value
- *  at runtime so PipelineState consumers can route accordingly. */
 export declare function isDerivedModeRule(x: unknown): x is DerivedModeRule;
-/** Convenience: flip 'back' ↔ 'front' (and pass through 'none').
- *  Useful in `(u, declared) => mirrored ? flipCull(declared) : declared`. */
-export declare function flipCull(c: CullMode): CullMode;
 /**
- * Construct a derived-mode rule that flips cullMode based on the sign
- * of `det(upperLeft3x3(u.<inputUniform>))`. Runs on the GPU when
- * heapScene's compute path is available; the same logic is mirrored
- * in the CPU closure for tests and fallback.
+ * Brand a `RuleExpr` (the shader-IR artefact emitted by the
+ * `rule(...)` build-time marker) as a derived-mode rule for `axis`.
  *
- *   const rule = gpuFlipCullByDeterminant("ModelTrafo", "back");
- *   spec.modeRules = { cull: rule };
+ * The `declared` option carries the SG-context value the rule reads
+ * via `declare const declared: number` in its body. heapScene
+ * substitutes it (as a Const) before codegen — when `declared` is a
+ * cval, every mark triggers a re-specialise + cached-kernel swap.
  *
- * Useful for mirrored geometry: scenes that animate a per-RO trafo
- * with potentially-negative scale don't pay CPU per-RO determinant
- * cost — the kernel walks the arena once per frame for ALL ROs that
- * carry this rule.
+ * `domain` is NOT a parameter: the renderer infers the per-declared
+ * set of possible outputs from the rule's IR via
+ * `analyseOutputSet` + `evaluateSet`.
  */
-export declare function gpuFlipCullByDeterminant(inputUniform: string, declared?: CullMode | import("@aardworx/wombat.adaptive").aval<CullMode>): DerivedModeRule<"cull">;
+export declare function derivedMode<A extends ModeAxis>(axis: A, expr: RuleExpr<ModeValue<A> | number>): DerivedModeRule<A>;
 //# sourceMappingURL=rule.d.ts.map

package/dist/runtime/derivedModes/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/rule.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE/E;;;wDAGwD;AACxD,MAAM,MAAM,QAAQ,GAChB,MAAM,GAAG,WAAW,GAAG,UAAU,GACjC,cAAc,GAAG,YAAY,GAC7B,iBAAiB,CAAC;AAEtB,kCAAkC;AAClC,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,QAAQ,IACtC,CAAC,SAAS,MAAM,GAAa,QAAQ,GACrC,CAAC,SAAS,WAAW,GAAQ,SAAS,GACtC,CAAC,SAAS,UAAU,GAAS,QAAQ,GACrC,CAAC,SAAS,cAAc,GAAK,kBAAkB,GAC/C,CAAC,SAAS,YAAY,GAAO,OAAO,GACpC,CAAC,SAAS,iBAAiB,GAAG,OAAO,GACrC,KAAK,CAAC;AAER;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,QAAQ,IAAI,CACnD,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,KACnB,SAAS,CAAC,CAAC,CAAC,CAAC;AAElB;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACxD,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,sEAAsE;IACtE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EACb,SAAS,CAAC,CAAC,CAAC,GACZ,OAAO,2BAA2B,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAK,CAAC,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IACzC,wDAAwD;IACxD,QAAQ,CAAC,GAAG,CAAC,EAAK,WAAW,CAAC,CAAC,CAAC,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAC5C,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,OAAO,GAAE;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;CAAO,GAC9D,eAAe,CAAC,CAAC,CAAC,CAKpB;AAED;mEACmE;AACnE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,eAAe,CAGlE;AAED;6EAC6E;AAC7E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAE9C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,EACpB,QAAQ,GACJ,QAAQ,GACR,OAAO,2BAA2B,EAAE,IAAI,CAAC,QAAQ,CAC3C,GACT,eAAe,CAAC,MAAM,CAAC,CAwBzB"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/rule.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEhG,MAAM,MAAM,QAAQ,GAChB,MAAM,GAAG,WAAW,GAAG,UAAU,GACjC,cAAc,GAAG,YAAY,GAC7B,iBAAiB;AACnB;;;;;8BAK8B;GAC5B,OAAO,CAAC;AAEZ,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,QAAQ,IACtC,CAAC,SAAS,MAAM,GAAa,QAAQ,GACrC,CAAC,SAAS,WAAW,GAAQ,SAAS,GACtC,CAAC,SAAS,UAAU,GAAS,QAAQ,GACrC,CAAC,SAAS,cAAc,GAAK,kBAAkB,GAC/C,CAAC,SAAS,YAAY,GAAO,OAAO,GACpC,CAAC,SAAS,iBAAiB,GAAG,OAAO,GACrC,CAAC,SAAS,OAAO,GAAY,eAAe,GAC5C,KAAK,CAAC;AAER,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB;;;;;uEAKmE;IACnE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;IAC/C;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAClE;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,eAAe,CAGlE;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAC5C,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GACpC,eAAe,CAAC,CAAC,CAAC,CAOpB"}

package/dist/runtime/derivedModes/rule.js

@@ -1,90 +1,50 @@
-// `derivedMode(axis, (u, declared) => modeValue)` — author-facing
-// marker for per-RO pipeline-state values that are functions of the
-// RO's uniforms.
+// Derived-mode rule — branded combination of a shader-IR rule
+// expression (from `rule(...)` in wombat.shader) + an axis + the
+// SG-declared aval. The IR is what gets compiled into the partition
+// kernel; the declared aval drives per-frame re-specialisation.
 //
-// v1 is CPU-evaluated: the user's closure runs in JS each time the
-// rule's inputs mark. That's a good fit for the typical authoring
-// shapes (a uniform-driven enum flip, a determinant-sign cull flip,
-// etc.) and pairs naturally with the bucket-level rebuild fast path
-// shipped in 0.9.16 — only ROs whose inputs actually changed get
-// re-evaluated, and same-key buckets re-bind their pipeline once
-// rather than per-RO.
+// Authoring flow (with `@boperators/plugin-vite` + the shader-vite
+// plugin both installed):
 //
-// v2 (deferred) lowers rules to a GPU compute kernel via §7's IR
-// machinery — needed only when bulk-animated per-RO inputs become a
-// CPU-side bottleneck. See docs/derived-mode-rules-plan.md.
+//     declare const u: { ModelTrafo: M44f };
+//     declare const declared: number;
 //
-// What can be derived (the small-enum axes — cull/blend/depth-compare/
-// topology/etc.) and what stays static (depth bias, blend constant,
-// stencil ref) is covered in docs/derived-modes.md.
-/**
- * Author a derived mode rule.
- *
- *     derivedMode("cull", (u, declared) =>
- *       u.WindingFlipped ? flipCull(declared) : declared);
- *
- *     derivedMode("blend", (u) => u.Premultiplied ? "premul" : "straight");
- *
- *     // Determinant-flip-cull (the motivating case):
- *     derivedMode("cull", (u, declared) => {
- *       const m = u.ModelTrafo as M44d;
- *       const det =
- *         m.M00 * (m.M11 * m.M22 - m.M12 * m.M21) -
- *         m.M01 * (m.M10 * m.M22 - m.M12 * m.M20) +
- *         m.M02 * (m.M10 * m.M21 - m.M11 * m.M20);
- *       return det < 0 ? flipCull(declared) : declared;
- *     });
- */
-export function derivedMode(axis, evaluate, options = {}) {
-    const out = options.domain !== undefined
-        ? { __derivedModeRule: true, axis, evaluate, domain: options.domain }
-        : { __derivedModeRule: true, axis, evaluate };
-    return out;
-}
-/** Brand check — distinguishes a DerivedModeRule from an aval/raw value
- *  at runtime so PipelineState consumers can route accordingly. */
+//     const cullExpr = rule(() => {
+//       const m: M33f = mat3(u.ModelTrafo);
+//       const det = determinant(m);
+//       return det < 0 ? flipCull(declared) : declared;
+//     });
+//
+//     const cullRule = derivedMode("cull", cullExpr, { declared: cullModeC });
+//
+// At runtime, heapScene reads `cullRule.expr.template`, extracts the
+// entry's body Stmt, calls `analyseOutputSet(body)` to obtain the
+// symbolic set, and for each declared-aval value resolves the set
+// via `evaluateSet({"declared": current}, intrinsics)` to size the
+// bucket's slots + codegen the partition kernel.
 export function isDerivedModeRule(x) {
     return typeof x === "object" && x !== null
         && x.__derivedModeRule === true;
 }
-/** Convenience: flip 'back' ↔ 'front' (and pass through 'none').
- *  Useful in `(u, declared) => mirrored ? flipCull(declared) : declared`. */
-export function flipCull(c) {
-    return c === "back" ? "front" : c === "front" ? "back" : "none";
-}
 /**
- * Construct a derived-mode rule that flips cullMode based on the sign
- * of `det(upperLeft3x3(u.<inputUniform>))`. Runs on the GPU when
- * heapScene's compute path is available; the same logic is mirrored
- * in the CPU closure for tests and fallback.
+ * Brand a `RuleExpr` (the shader-IR artefact emitted by the
+ * `rule(...)` build-time marker) as a derived-mode rule for `axis`.
  *
- *   const rule = gpuFlipCullByDeterminant("ModelTrafo", "back");
- *   spec.modeRules = { cull: rule };
+ * The `declared` option carries the SG-context value the rule reads
+ * via `declare const declared: number` in its body. heapScene
+ * substitutes it (as a Const) before codegen — when `declared` is a
+ * cval, every mark triggers a re-specialise + cached-kernel swap.
  *
- * Useful for mirrored geometry: scenes that animate a per-RO trafo
- * with potentially-negative scale don't pay CPU per-RO determinant
- * cost — the kernel walks the arena once per frame for ALL ROs that
- * carry this rule.
+ * `domain` is NOT a parameter: the renderer infers the per-declared
+ * set of possible outputs from the rule's IR via
+ * `analyseOutputSet` + `evaluateSet`.
  */
-export function gpuFlipCullByDeterminant(inputUniform, declared = "back") {
+export function derivedMode(axis, expr) {
     return {
         __derivedModeRule: true,
-        axis: "cull",
-        domain: ["back", "front", "none"],
-        gpu: { kernel: "flipCullByDeterminant", inputUniform, declared },
-        evaluate: (u, declaredFromCtx) => {
-            // Accept Trafo3d ({forward: M44d}) — the wombat.base shape used
-            // by SG ModelTrafo — or any object with M00..M22 accessors.
-            const raw = u[inputUniform];
-            const m = raw.forward
-                ?? raw;
-            if (m === undefined || typeof m.M00 !== "number")
-                return declaredFromCtx;
-            const det = m.M00 * (m.M11 * m.M22 - m.M12 * m.M21)
-                - m.M01 * (m.M10 * m.M22 - m.M12 * m.M20)
-                + m.M02 * (m.M10 * m.M21 - m.M11 * m.M20);
-            return det < 0 ? flipCull(declaredFromCtx) : declaredFromCtx;
-        },
+        axis,
+        expr,
+        declared: undefined, // SG fills this in at traversal time
     };
 }
 //# sourceMappingURL=rule.js.map

package/dist/runtime/derivedModes/rule.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/runtime/derivedModes/rule.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,oEAAoE;AACpE,iBAAiB;AACjB,EAAE;AACF,mEAAmE;AACnE,kEAAkE;AAClE,oEAAoE;AACpE,oEAAoE;AACpE,iEAAiE;AACjE,iEAAiE;AACjE,sBAAsB;AACtB,EAAE;AACF,iEAAiE;AACjE,oEAAoE;AACpE,4DAA4D;AAC5D,EAAE;AACF,uEAAuE;AACvE,oEAAoE;AACpE,oDAAoD;AA8EpD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,QAA+B,EAC/B,UAA6D,EAAE;IAE/D,MAAM,GAAG,GAAuB,OAAO,CAAC,MAAM,KAAK,SAAS;QAC1D,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;QACrE,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAChD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;mEACmE;AACnE,MAAM,UAAU,iBAAiB,CAAC,CAAU;IAC1C,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;WAClC,CAAqC,CAAC,iBAAiB,KAAK,IAAI,CAAC;AAC3E,CAAC;AAED;6EAC6E;AAC7E,MAAM,UAAU,QAAQ,CAAC,CAAW;IAClC,OAAO,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,wBAAwB,CACtC,YAAoB,EACpB,WAGI,MAAM;IAEV,OAAO;QACL,iBAAiB,EAAE,IAAI;QACvB,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;QACjC,GAAG,EAAE,EAAE,MAAM,EAAE,uBAAuB,EAAE,YAAY,EAAE,QAAQ,EAAE;QAChE,QAAQ,EAAE,CAAC,CAAC,EAAE,eAAe,EAAE,EAAE;YAC/B,gEAAgE;YAChE,4DAA4D;YAC5D,MAAM,GAAG,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC;YAI5B,MAAM,CAAC,GACJ,GAAuB,CAAC,OAAO;mBAC5B,GAAS,CAAC;YAChB,IAAI,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,GAAG,KAAK,QAAQ;gBAAE,OAAO,eAAe,CAAC;YACzE,MAAM,GAAG,GACP,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC;kBACvC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC;kBACvC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YAC1C,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;QAC/D,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/runtime/derivedModes/rule.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,iEAAiE;AACjE,oEAAoE;AACpE,gEAAgE;AAChE,EAAE;AACF,mEAAmE;AACnE,0BAA0B;AAC1B,EAAE;AACF,6CAA6C;AAC7C,sCAAsC;AACtC,EAAE;AACF,oCAAoC;AACpC,4CAA4C;AAC5C,oCAAoC;AACpC,wDAAwD;AACxD,UAAU;AACV,EAAE;AACF,+EAA+E;AAC/E,EAAE;AACF,qEAAqE;AACrE,kEAAkE;AAClE,kEAAkE;AAClE,mEAAmE;AACnE,iDAAiD;AAmDjD,MAAM,UAAU,iBAAiB,CAAC,CAAU;IAC1C,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI;WAClC,CAAqC,CAAC,iBAAiB,KAAK,IAAI,CAAC;AAC3E,CAAC;AAGD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,IAAqC;IAErC,OAAO;QACL,iBAAiB,EAAE,IAAI;QACvB,IAAI;QACJ,IAAI;QACJ,QAAQ,EAAE,SAAS,EAAG,qCAAqC;KAC5D,CAAC;AACJ,CAAC"}

package/dist/runtime/derivedUniforms/dispatch.d.ts

@@ -3,24 +3,26 @@ import type { RecordsBuffer } from "./records.js";
 import { type SlotIndex } from "./slots.js";
 /** Upload the changed-constituent value range to the constituents GPU buffer. */
 export declare function uploadConstituentsRange(device: GPUDevice, buf: GPUBuffer, mirror: Float32Array, dirty: ReadonlySet<SlotIndex>): void;
-/** Live getters for the GPU buffers the kernel binds (scene may grow/replace them). */
+/** Live getters for the scene-wide GPU buffers the kernel binds. The
+ *  main-heap binding is per-dispatch and supplied to `encodeChunk`,
+ *  since one DerivedUniformsScene now serves multiple arena chunks
+ *  (§3) and each chunk has its own main-heap GPUBuffer. */
 export interface DerivedUniformsResources {
     /** `array<vec2<f32>>` — df32 trafo halves (the constituents heap). */
     readonly constituentsBuf: () => GPUBuffer;
-    /** `array<f32>` — the main heap (drawHeaders); written by the kernel. */
-    readonly mainHeapBuf: () => GPUBuffer;
 }
 export declare class DerivedUniformsDispatcher {
     private readonly device;
     private readonly resources;
-    private readonly gpu;
     private readonly pipe;
-    private cachedBg;
-    private bgKey;
+    private readonly byChunk;
     constructor(device: GPUDevice, resources: DerivedUniformsResources);
-    /** Open a compute pass and run the uber-kernel. No-ops if there are no records / no rules. */
-    encode(enc: GPUCommandEncoder, registry: DerivedUniformRegistry, records: RecordsBuffer): boolean;
+    /** Run the uber-kernel for ONE chunk's records, binding
+     *  `mainHeapGetter()` as the heap target. No-op if the chunk's
+     *  records buffer is empty or the registry has no rules. */
+    encodeChunk(enc: GPUCommandEncoder, registry: DerivedUniformRegistry, records: RecordsBuffer, mainHeapGetter: () => GPUBuffer): boolean;
     dispose(): void;
+    private stateFor;
     private bindGroup;
 }
 //# sourceMappingURL=dispatch.d.ts.map

package/dist/runtime/derivedUniforms/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedUniforms/dispatch.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE7D,iFAAiF;AACjF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,GAC5B,IAAI,CAWN;AAED,uFAAuF;AACvF,MAAM,WAAW,wBAAwB;IACvC,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,MAAM,SAAS,CAAC;IAC1C,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,MAAM,SAAS,CAAC;CACvC;AA2GD,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,KAAK,CAA4G;gBAE7G,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,wBAAwB;IAOlE,8FAA8F;IAC9F,MAAM,CAAC,GAAG,EAAE,iBAAiB,EAAE,QAAQ,EAAE,sBAAsB,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO;IAajG,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,SAAS;CAoBlB"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedUniforms/dispatch.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE7D,iFAAiF;AACjF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,GAC5B,IAAI,CAWN;AAED;;;2DAG2D;AAC3D,MAAM,WAAW,wBAAwB;IACvC,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,MAAM,SAAS,CAAC;CAC3C;AAmHD,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;gBAEpD,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,wBAAwB;IAMlE;;gEAE4D;IAC5D,WAAW,CACT,GAAG,EAAE,iBAAiB,EACtB,QAAQ,EAAE,sBAAsB,EAChC,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,MAAM,SAAS,GAC9B,OAAO;IAcV,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,SAAS;CAmBlB"}

package/dist/runtime/derivedUniforms/dispatch.js

@@ -127,53 +127,66 @@ class UberPipeline {
 export class DerivedUniformsDispatcher {
     device;
     resources;
-    gpu;
     pipe;
-    cachedBg;
-    bgKey = [undefined, undefined, undefined];
+    byChunk = new Map();
     constructor(device, resources) {
         this.device = device;
         this.resources = resources;
-        this.gpu = new RecordsGpu(device);
         this.pipe = new UberPipeline(device);
     }
-    /** Open a compute pass and run the uber-kernel. No-ops if there are no records / no rules. */
-    encode(enc, registry, records) {
+    /** Run the uber-kernel for ONE chunk's records, binding
+     *  `mainHeapGetter()` as the heap target. No-op if the chunk's
+     *  records buffer is empty or the registry has no rules. */
+    encodeChunk(enc, registry, records, mainHeapGetter) {
         if (records.recordCount === 0)
             return false;
         const pipeline = this.pipe.pipeline(registry, records.strideWords);
         if (pipeline === undefined)
             return false;
-        this.gpu.sync(records);
+        const state = this.stateFor(records);
+        state.gpu.sync(records);
         const pass = enc.beginComputePass({ label: "derivedUniforms.uber" });
         pass.setPipeline(pipeline);
-        pass.setBindGroup(0, this.bindGroup());
+        pass.setBindGroup(0, this.bindGroup(state, mainHeapGetter()));
         pass.dispatchWorkgroups(Math.ceil(records.recordCount / 64));
         pass.end();
         return true;
     }
     dispose() {
-        this.gpu.dispose();
+        for (const s of this.byChunk.values())
+            s.gpu.dispose();
+        this.byChunk.clear();
     }
-    bindGroup() {
+    stateFor(records) {
+        let s = this.byChunk.get(records);
+        if (s === undefined) {
+            s = {
+                gpu: new RecordsGpu(this.device),
+                cachedBg: undefined,
+                bgKey: [undefined, undefined, undefined],
+            };
+            this.byChunk.set(records, s);
+        }
+        return s;
+    }
+    bindGroup(state, heap) {
         const consts = this.resources.constituentsBuf();
-        const heap = this.resources.mainHeapBuf();
-        const recs = this.gpu.buffer();
-        if (this.cachedBg !== undefined && this.bgKey[0] === consts && this.bgKey[1] === heap && this.bgKey[2] === recs) {
-            return this.cachedBg;
+        const recs = state.gpu.buffer();
+        if (state.cachedBg !== undefined && state.bgKey[0] === consts && state.bgKey[1] === heap && state.bgKey[2] === recs) {
+            return state.cachedBg;
         }
-        this.cachedBg = this.device.createBindGroup({
+        state.cachedBg = this.device.createBindGroup({
             label: "derivedUniforms.uber",
             layout: this.pipe.bgl,
             entries: [
                 { binding: 0, resource: { buffer: consts } },
                 { binding: 1, resource: { buffer: heap } },
                 { binding: 2, resource: { buffer: recs } },
-                { binding: 3, resource: { buffer: this.gpu.countBuf } },
+                { binding: 3, resource: { buffer: state.gpu.countBuf } },
             ],
         });
-        this.bgKey = [consts, heap, recs];
-        return this.cachedBg;
+        state.bgKey = [consts, heap, recs];
+        return state.cachedBg;
     }
 }
 //# sourceMappingURL=dispatch.js.map