@aardworx/wombat.rendering 0.9.14 → 0.9.15

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

@@ -0,0 +1,45 @@
+import type { PipelineState } from "../../core/pipelineState.js";
+import type { FramebufferSignature } from "../../core/framebufferSignature.js";
+import type { IDisposable } from "@aardworx/wombat.adaptive";
+import { type PipelineStateDescriptor } from "../pipelineCache/index.js";
+/**
+ * One-shot snapshot of the current values of every leaf aval in a
+ * `PipelineState`, mapped onto a `PipelineStateDescriptor` whose
+ * `attachments` array follows the framebuffer's `colorNames` order
+ * (missing entries default to non-blended / 0xF writeMask, matching
+ * `BLEND_DEFAULT` semantics in heapScene).
+ */
+export declare function snapshotDescriptor(ps: PipelineState | undefined, signature: FramebufferSignature): PipelineStateDescriptor;
+/**
+ * Subscribes to every leaf aval in a `PipelineState` and invokes
+ * `onDirty` when any of them marks. Use one tracker per RO; call
+ * `recompute()` after a dirty signal to refresh the descriptor +
+ * modeKey, and `dispose()` when the RO is removed.
+ *
+ * Reactive cvals are the typical case; constant avals also "subscribe"
+ * — `addMarkingCallback` is a no-op for an aval that never marks, so
+ * no special-casing required.
+ */
+export declare class ModeKeyTracker implements IDisposable {
+    readonly ps: PipelineState | undefined;
+    readonly signature: FramebufferSignature;
+    private readonly onDirty;
+    private readonly subs;
+    private cachedDescriptor;
+    private cachedModeKey;
+    constructor(ps: PipelineState | undefined, signature: FramebufferSignature, onDirty: () => void);
+    get descriptor(): PipelineStateDescriptor;
+    get modeKey(): bigint;
+    /**
+     * Snapshot current aval values and rebuild descriptor + modeKey.
+     * Returns true iff the modeKey changed (so the bucket only needs to
+     * upload + repartition when something actually moved).
+     */
+    recompute(): boolean;
+    dispose(): void;
+    private subscribeAll;
+    private sub;
+    private subBlendState;
+    private subStencilFaces;
+}
+//# sourceMappingURL=modeKeyCpu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modeKeyCpu.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/modeKeyCpu.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAEV,aAAa,EAKd,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGnE,OAAO,EAIL,KAAK,uBAAuB,EAI7B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,aAAa,GAAG,SAAS,EAC7B,SAAS,EAAE,oBAAoB,GAC9B,uBAAuB,CAsBzB;AAkDD;;;;;;;;;GASG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,EAAE,EAAE,aAAa,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,aAAa,CAAS;gBAG5B,EAAE,EAAE,aAAa,GAAG,SAAS,EAC7B,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,MAAM,IAAI;IAUrB,IAAI,UAAU,IAAI,uBAAuB,CAAkC;IAC3E,IAAI,OAAO,IAAI,MAAM,CAA+B;IAEpD;;;;OAIG;IACH,SAAS,IAAI,OAAO;IASpB,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,YAAY;IA6BpB,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,eAAe;CAIxB"}

package/dist/runtime/derivedModes/modeKeyCpu.js

@@ -0,0 +1,179 @@
+// Per-RO modeKey production (CPU side).
+//
+// Task 1 of the derived-modes work: turn a `PipelineState` (the
+// aval-shaped struct from core/pipelineState.ts) plus the surrounding
+// `FramebufferSignature` into a canonical `PipelineStateDescriptor`
+// and its bitfield-encoded modeKey. Subscribes to every input aval
+// so that mutating a `cval` for cullMode / blendFactor / etc. fires
+// a dirty callback, the bucket flushes the changed RO's modeKey to
+// GPU on the next frame, and the partition kernel re-buckets the
+// record into its new slot. No rule-IR machinery yet — Task 2 layers
+// `derivedMode(...)` on top of this.
+import { addMarkingCallback } from "@aardworx/wombat.adaptive";
+import { encodeModeKey, DEFAULT_DESCRIPTOR, DEFAULT_ATTACHMENT_BLEND, } from "../pipelineCache/index.js";
+/**
+ * One-shot snapshot of the current values of every leaf aval in a
+ * `PipelineState`, mapped onto a `PipelineStateDescriptor` whose
+ * `attachments` array follows the framebuffer's `colorNames` order
+ * (missing entries default to non-blended / 0xF writeMask, matching
+ * `BLEND_DEFAULT` semantics in heapScene).
+ */
+export function snapshotDescriptor(ps, signature) {
+    if (ps === undefined) {
+        return buildAttachmentsFor(DEFAULT_DESCRIPTOR, signature);
+    }
+    const r = ps.rasterizer;
+    const depth = ps.depth !== undefined ? snapshotDepth(ps.depth, signature) : undefined;
+    const atc = ps.alphaToCoverage !== undefined ? ps.alphaToCoverage.force( /* allow-force */) : false;
+    const blends = ps.blends !== undefined ? ps.blends.force( /* allow-force */) : undefined;
+    const attachments = signature.colorNames.map((name) => {
+        const b = blends?.tryFind(name);
+        return b !== undefined ? snapshotAttachment(b) : DEFAULT_ATTACHMENT_BLEND;
+    });
+    const out = {
+        topology: r.topology.force( /* allow-force */),
+        stripIndexFormat: stripFormatFor(r.topology.force( /* allow-force */)),
+        frontFace: r.frontFace.force( /* allow-force */),
+        cullMode: r.cullMode.force( /* allow-force */),
+        ...(depth !== undefined ? { depth } : {}),
+        attachments,
+        alphaToCoverage: atc,
+    };
+    return out;
+}
+function buildAttachmentsFor(base, signature) {
+    // When `ps` is undefined, every named attachment uses defaults.
+    return {
+        ...base,
+        attachments: signature.colorNames.map(() => DEFAULT_ATTACHMENT_BLEND),
+    };
+}
+function snapshotDepth(d, signature) {
+    if (signature.depthStencil === undefined)
+        return undefined;
+    return {
+        write: d.write.force( /* allow-force */),
+        compare: d.compare.force( /* allow-force */),
+        clamp: d.clamp !== undefined ? d.clamp.force( /* allow-force */) : false,
+    };
+}
+function snapshotAttachment(b) {
+    const color = snapshotBlendComponent(b.color);
+    const alpha = snapshotBlendComponent(b.alpha);
+    const writeMask = b.writeMask.force( /* allow-force */) & 0xF;
+    // "Blend enabled" derives from whether the components differ from
+    // the no-op (src=one, dst=zero, op=add) shape. This mirrors WebGPU's
+    // contract: a blend descriptor MUST be present for blending to occur,
+    // and the no-op shape is the canonical disabled state.
+    const enabled = !(color.srcFactor === "one" && color.dstFactor === "zero" && color.operation === "add" &&
+        alpha.srcFactor === "one" && alpha.dstFactor === "zero" && alpha.operation === "add");
+    return { enabled, color, alpha, writeMask };
+}
+function snapshotBlendComponent(c) {
+    return {
+        srcFactor: c.srcFactor.force( /* allow-force */),
+        dstFactor: c.dstFactor.force( /* allow-force */),
+        operation: c.operation.force( /* allow-force */),
+    };
+}
+function stripFormatFor(topology) {
+    return topology === "line-strip" || topology === "triangle-strip" ? "uint32" : undefined;
+}
+// ─── Reactive tracker ──────────────────────────────────────────────────
+/**
+ * Subscribes to every leaf aval in a `PipelineState` and invokes
+ * `onDirty` when any of them marks. Use one tracker per RO; call
+ * `recompute()` after a dirty signal to refresh the descriptor +
+ * modeKey, and `dispose()` when the RO is removed.
+ *
+ * Reactive cvals are the typical case; constant avals also "subscribe"
+ * — `addMarkingCallback` is a no-op for an aval that never marks, so
+ * no special-casing required.
+ */
+export class ModeKeyTracker {
+    ps;
+    signature;
+    onDirty;
+    subs = [];
+    cachedDescriptor;
+    cachedModeKey;
+    constructor(ps, signature, onDirty) {
+        this.ps = ps;
+        this.signature = signature;
+        this.onDirty = onDirty;
+        this.cachedDescriptor = snapshotDescriptor(ps, signature);
+        this.cachedModeKey = encodeModeKey(this.cachedDescriptor);
+        this.subscribeAll();
+    }
+    get descriptor() { return this.cachedDescriptor; }
+    get modeKey() { return this.cachedModeKey; }
+    /**
+     * Snapshot current aval values and rebuild descriptor + modeKey.
+     * Returns true iff the modeKey changed (so the bucket only needs to
+     * upload + repartition when something actually moved).
+     */
+    recompute() {
+        const next = snapshotDescriptor(this.ps, this.signature);
+        const nextKey = encodeModeKey(next);
+        if (nextKey === this.cachedModeKey)
+            return false;
+        this.cachedDescriptor = next;
+        this.cachedModeKey = nextKey;
+        return true;
+    }
+    dispose() {
+        for (const s of this.subs)
+            s.dispose();
+        this.subs.length = 0;
+    }
+    subscribeAll() {
+        if (this.ps === undefined)
+            return;
+        const ps = this.ps;
+        this.sub(ps.rasterizer.topology);
+        this.sub(ps.rasterizer.cullMode);
+        this.sub(ps.rasterizer.frontFace);
+        if (ps.rasterizer.depthBias !== undefined)
+            this.sub(ps.rasterizer.depthBias);
+        if (ps.depth !== undefined) {
+            this.sub(ps.depth.write);
+            this.sub(ps.depth.compare);
+            if (ps.depth.clamp !== undefined)
+                this.sub(ps.depth.clamp);
+        }
+        if (ps.stencil !== undefined) {
+            // Stencil enabled/reference/masks contribute to neither modeKey
+            // nor cache key (v1 carves stencil out — only the "enabled"
+            // flag matters and we surface it via snapshotDescriptor). We
+            // still subscribe so callers can repackage if a future change
+            // flips the enable bit.
+            this.subStencilFaces(ps.stencil);
+        }
+        if (ps.blends !== undefined) {
+            this.sub(ps.blends);
+            const map = ps.blends.force( /* allow-force */);
+            for (const [, bs] of map)
+                this.subBlendState(bs);
+        }
+        if (ps.alphaToCoverage !== undefined)
+            this.sub(ps.alphaToCoverage);
+        // blendConstant is dynamic state; not in the modeKey, no subscription needed.
+    }
+    sub(a) {
+        this.subs.push(addMarkingCallback(a, this.onDirty));
+    }
+    subBlendState(b) {
+        this.sub(b.color.srcFactor);
+        this.sub(b.color.dstFactor);
+        this.sub(b.color.operation);
+        this.sub(b.alpha.srcFactor);
+        this.sub(b.alpha.dstFactor);
+        this.sub(b.alpha.operation);
+        this.sub(b.writeMask);
+    }
+    subStencilFaces(_s) {
+        // v1: stencil isn't in the modeKey; deliberately not subscribing
+        // to face avals here. Wire up in v2 when stencil enters the key.
+    }
+}
+//# sourceMappingURL=modeKeyCpu.js.map

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

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

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

@@ -0,0 +1,36 @@
+/** v1 cap on distinct pipeline slots per bucket. */
+export declare const MAX_SLOTS_PER_BUCKET = 256;
+export interface PartitionInput {
+    /** Per-record slot index (length = numRecords). */
+    readonly slot: ReadonlyArray<number>;
+    /** Per-record (indexCount * instanceCount) — emit count contributed
+     * to its slot's drawIndirect vertex total. */
+    readonly emitCount: ReadonlyArray<number>;
+    /** Number of distinct slots used. Slots outside this range produce
+     * an error. */
+    readonly slotCount: number;
+}
+export interface PartitionResult {
+    /** Per-slot record count. Length = slotCount. */
+    readonly slotCounts: Uint32Array;
+    /** Per-slot cumulative record-count prefix sum (length = slotCount + 1). */
+    readonly slotOffsets: Uint32Array;
+    /** Per-slot total emit count (vertex count for the drawIndirect). */
+    readonly slotTotalEmit: Uint32Array;
+    /** Permuted record indices, grouped by slot. Length = numRecords. */
+    readonly slotRecords: Uint32Array;
+    /** Slot-local prefix sum of emitCounts, length = numRecords + slotCount.
+     * For slot s, the prefix array is
+     *   slotEmitPrefix[slotOffsets[s] + s ..= slotOffsets[s+1] + s]
+     * (one extra entry per slot for the upper bound). */
+    readonly slotEmitPrefix: Uint32Array;
+}
+/**
+ * Pure-CPU partition. Reference implementation for the WGSL kernel
+ * below. Order within a slot is stable wrt. input record order so
+ * tests can predict the permuted layout deterministically.
+ */
+export declare function partitionCPU(input: PartitionInput): PartitionResult;
+export declare const PARTITION_HISTOGRAM_WGSL = "\nstruct PartitionInputs {\n  numRecords:   u32,\n  slotCount:    u32,\n  _pad0:        u32,\n  _pad1:        u32,\n};\n@group(0) @binding(0) var<uniform>            uIn:           PartitionInputs;\n@group(0) @binding(1) var<storage, read>      slot:          array<u32>;\n@group(0) @binding(2) var<storage, read>      emitCount:     array<u32>;\n@group(0) @binding(3) var<storage, read_write> slotCounts:    array<atomic<u32>>;\n@group(0) @binding(4) var<storage, read_write> slotTotalEmit: array<atomic<u32>>;\n\n@compute @workgroup_size(64)\nfn histogram(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let i = gid.x;\n  if (i >= uIn.numRecords) { return; }\n  let s = slot[i];\n  atomicAdd(&slotCounts[s], 1u);\n  atomicAdd(&slotTotalEmit[s], emitCount[i]);\n}\n";
+export declare const PARTITION_SCATTER_WGSL = "\nstruct PartitionInputs {\n  numRecords:   u32,\n  slotCount:    u32,\n  _pad0:        u32,\n  _pad1:        u32,\n};\n@group(0) @binding(0) var<uniform>            uIn:         PartitionInputs;\n@group(0) @binding(1) var<storage, read>      slot:        array<u32>;\n@group(0) @binding(2) var<storage, read>      slotOffsets: array<u32>;\n@group(0) @binding(3) var<storage, read_write> cursors:     array<atomic<u32>>;\n@group(0) @binding(4) var<storage, read_write> slotRecords: array<u32>;\n\n@compute @workgroup_size(64)\nfn scatter(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let i = gid.x;\n  if (i >= uIn.numRecords) { return; }\n  let s    = slot[i];\n  let base = slotOffsets[s];\n  let k    = atomicAdd(&cursors[s], 1u);\n  slotRecords[base + k] = i;\n}\n";
+//# sourceMappingURL=partition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/partition.ts"],"names":[],"mappings":"AAgCA,oDAAoD;AACpD,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAW,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C;kDAC8C;IAC9C,QAAQ,CAAC,SAAS,EAAM,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C;mBACe;IACf,QAAQ,CAAC,SAAS,EAAM,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAM,WAAW,CAAC;IACrC,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAK,WAAW,CAAC;IACrC,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAG,WAAW,CAAC;IACrC,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAK,WAAW,CAAC;IACrC;;;yDAGqD;IACrD,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAqDnE;AAwCD,eAAO,MAAM,wBAAwB,uwBAqBpC,CAAC;AAEF,eAAO,MAAM,sBAAsB,2wBAsBlC,CAAC"}

package/dist/runtime/derivedModes/partition.js

@@ -0,0 +1,170 @@
+// Per-frame partition kernel — turns per-RO slot assignments into
+// per-slot draw metadata (record lists + cumulative emit prefix sums
+// + total indexCount × instanceCount per slot).
+//
+// Each bucket runs this kernel once per frame (dirty-gated). Output
+// feeds one `drawIndirect` per slot in the encode loop. Records routed
+// to the same slot share an indirect call; records in different slots
+// land in separate `setPipeline + drawIndirect` calls.
+//
+// The CPU function `partitionCPU` is the algorithmic reference and
+// the basis for unit tests. The WGSL kernel below mirrors the same
+// algorithm using two compute passes (histogram + scatter), with an
+// exclusive prefix scan on the histogram in between.
+//
+// Layout choices:
+//
+//   - Records are NOT physically re-sorted. Instead, the kernel writes
+//     a permuted index list `slotRecords[]` (one u32 per record), plus
+//     per-slot offsets `slotOffsets[]` and counts `slotCounts[]`. The
+//     existing drawTable stays put — the VS prelude does one extra
+//     read of `slotRecords[…]` to map from "drawIndex within slot"
+//     back to "drawIndex in the full drawTable."
+//   - `slotEmitPrefix[]` is the slot-local prefix-sum of
+//     `record.indexCount * record.instanceCount`. The VS prelude
+//     binary-searches THIS (per-slot) instead of the global table.
+//   - `slotTotalEmit[]` is the dispatched vertex count for that
+//     slot's drawIndirect.
+//
+// Buffers grow lazily; the partition wrapper resizes as slot counts
+// or record counts change. v1 caps slots per bucket at MAX_SLOTS
+// (256), exceeded slots throw with a friendly diagnostic.
+/** v1 cap on distinct pipeline slots per bucket. */
+export const MAX_SLOTS_PER_BUCKET = 256;
+/**
+ * Pure-CPU partition. Reference implementation for the WGSL kernel
+ * below. Order within a slot is stable wrt. input record order so
+ * tests can predict the permuted layout deterministically.
+ */
+export function partitionCPU(input) {
+    const { slot, emitCount, slotCount } = input;
+    const numRecords = slot.length;
+    if (emitCount.length !== numRecords) {
+        throw new Error("partition: slot.length != emitCount.length");
+    }
+    if (slotCount > MAX_SLOTS_PER_BUCKET) {
+        throw new Error(`partition: slotCount ${slotCount} exceeds cap ${MAX_SLOTS_PER_BUCKET}`);
+    }
+    const slotCounts = new Uint32Array(slotCount);
+    const slotOffsets = new Uint32Array(slotCount + 1);
+    const slotTotalEmit = new Uint32Array(slotCount);
+    const slotRecords = new Uint32Array(numRecords);
+    const slotEmitPrefix = new Uint32Array(numRecords + slotCount);
+    // Pass 1: histogram + per-slot emit sum.
+    for (let i = 0; i < numRecords; i++) {
+        const s = slot[i];
+        if (s < 0 || s >= slotCount) {
+            throw new Error(`partition: record ${i} has out-of-range slot ${s} (slotCount=${slotCount})`);
+        }
+        slotCounts[s] = slotCounts[s] + 1;
+        slotTotalEmit[s] = slotTotalEmit[s] + emitCount[i];
+    }
+    // Pass 2: exclusive prefix sum -> per-slot start offsets.
+    let acc = 0;
+    for (let s = 0; s < slotCount; s++) {
+        slotOffsets[s] = acc;
+        acc += slotCounts[s];
+    }
+    slotOffsets[slotCount] = acc;
+    // Pass 3: scatter — second pass over records to place each at its
+    // slot's current cursor, emitting the within-slot prefix sums.
+    const cursors = new Uint32Array(slotCount);
+    for (let i = 0; i < numRecords; i++) {
+        const s = slot[i];
+        const base = slotOffsets[s]; // first slotRecords[] index for this slot
+        const prefBase = base + s; // first slotEmitPrefix[] index for this slot
+        const k = cursors[s]; // within-slot position
+        slotRecords[base + k] = i;
+        // Slot prefix sums are length (slotCounts[s] + 1): first entry
+        // is 0, then cumulative; the last entry equals slotTotalEmit[s].
+        if (k === 0) {
+            slotEmitPrefix[prefBase] = 0;
+        }
+        slotEmitPrefix[prefBase + k + 1] = slotEmitPrefix[prefBase + k] + emitCount[i];
+        cursors[s] = k + 1;
+    }
+    return { slotCounts, slotOffsets, slotTotalEmit, slotRecords, slotEmitPrefix };
+}
+// ─── WGSL kernel ───────────────────────────────────────────────────────
+//
+// Mirrors `partitionCPU` in two compute passes:
+//
+//   Pass A (histogram):
+//     - one thread per record
+//     - read slot[i], emitCount[i]
+//     - atomicAdd(slotCounts[s], 1)
+//     - atomicAdd(slotTotalEmit[s], emitCount[i])
+//
+//   Pass B (scatter):
+//     - one thread per record
+//     - look up slot[i]
+//     - atomicAdd(cursors[s], 1) -> within-slot position k
+//     - slotRecords[slotOffsets[s] + k] = i
+//     - slotEmitPrefix[slotOffsets[s] + s + k + 1] is computed by a
+//       second scan pass (the within-slot prefix sum). v1 emits a
+//       serial CPU-side scan for simplicity; v2 should fold this into
+//       a per-slot warp-scan once buckets get large.
+//
+// Between the two passes, the CPU runs an exclusive scan on
+// `slotCounts` to produce `slotOffsets` (small array, ≤ MAX_SLOTS).
+//
+// The within-slot prefix scan in pass B uses a non-atomic read of
+// `slotEmitPrefix[prefBase + k]` — this is safe because the only
+// thread that writes index `prefBase + k` is the one whose `cursors`
+// fetchAdd returned `k`, and that thread completed before any thread
+// whose fetchAdd returned `k+1` could read `prefBase + k`.
+//
+// (Wait — that's only true if we have a memory barrier across
+// invocations, which WGSL doesn't guarantee inside one dispatch. In
+// practice v1 punts: the kernel emits the histogram + slotRecords,
+// and the host or a follow-up pass computes slotEmitPrefix. The
+// kernel below reflects this: it produces slotCounts, slotOffsets
+// (after host scan), slotTotalEmit, and slotRecords. The
+// slotEmitPrefix scan is performed in a third compute pass on the
+// already-scattered records.)
+export const PARTITION_HISTOGRAM_WGSL = /* wgsl */ `
+struct PartitionInputs {
+  numRecords:   u32,
+  slotCount:    u32,
+  _pad0:        u32,
+  _pad1:        u32,
+};
+@group(0) @binding(0) var<uniform>            uIn:           PartitionInputs;
+@group(0) @binding(1) var<storage, read>      slot:          array<u32>;
+@group(0) @binding(2) var<storage, read>      emitCount:     array<u32>;
+@group(0) @binding(3) var<storage, read_write> slotCounts:    array<atomic<u32>>;
+@group(0) @binding(4) var<storage, read_write> slotTotalEmit: array<atomic<u32>>;
+
+@compute @workgroup_size(64)
+fn histogram(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x;
+  if (i >= uIn.numRecords) { return; }
+  let s = slot[i];
+  atomicAdd(&slotCounts[s], 1u);
+  atomicAdd(&slotTotalEmit[s], emitCount[i]);
+}
+`;
+export const PARTITION_SCATTER_WGSL = /* wgsl */ `
+struct PartitionInputs {
+  numRecords:   u32,
+  slotCount:    u32,
+  _pad0:        u32,
+  _pad1:        u32,
+};
+@group(0) @binding(0) var<uniform>            uIn:         PartitionInputs;
+@group(0) @binding(1) var<storage, read>      slot:        array<u32>;
+@group(0) @binding(2) var<storage, read>      slotOffsets: array<u32>;
+@group(0) @binding(3) var<storage, read_write> cursors:     array<atomic<u32>>;
+@group(0) @binding(4) var<storage, read_write> slotRecords: array<u32>;
+
+@compute @workgroup_size(64)
+fn scatter(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x;
+  if (i >= uIn.numRecords) { return; }
+  let s    = slot[i];
+  let base = slotOffsets[s];
+  let k    = atomicAdd(&cursors[s], 1u);
+  slotRecords[base + k] = i;
+}
+`;
+//# sourceMappingURL=partition.js.map

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

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

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

@@ -0,0 +1,70 @@
+import { PipelineCache, type PipelineBuilder, type PipelineStateDescriptor } from "../pipelineCache/index.js";
+export interface SlotTableEntry {
+    readonly slotIndex: number;
+    readonly modeKey: bigint;
+    readonly descriptor: PipelineStateDescriptor;
+    /** Refcount of ROs currently bound to this slot. v1 doesn't GC at 0. */
+    refCount: number;
+    /** Populated lazily by precompile; null until linked. */
+    pipeline: GPURenderPipeline | null;
+}
+/**
+ * One SlotTable per `(effect, textureSet)` bucket. The cache may be
+ * shared across buckets — pipelines that happen to share a descriptor
+ * (rare across distinct effects, since pipeline objects bake the
+ * shader / layout) still dedupe at the cache level if a builder
+ * legitimately produces the same GPURenderPipeline for the same
+ * descriptor key.
+ */
+export declare class SlotTable {
+    readonly cache: PipelineCache;
+    readonly builder: PipelineBuilder;
+    private readonly entries;
+    private readonly byKey;
+    /** Tracks pending precompile promises so ready() waits for the union. */
+    private pending;
+    private version;
+    constructor(cache: PipelineCache, builder: PipelineBuilder);
+    /** Total slot count (linked or pending). */
+    get slotCount(): number;
+    /**
+     * Bumps whenever a new slot is appended. Consumers (partition setup,
+     * indirect-args resize, GPU lookup-table upload) compare against
+     * their last-seen value to know when to re-upload.
+     */
+    get layoutVersion(): number;
+    /** Iterate all slots in slot-index order. */
+    all(): IterableIterator<SlotTableEntry>;
+    /**
+     * Add (or reference-bump) the slot for `descriptor`. Returns the
+     * existing slot if it already exists, otherwise creates one and
+     * kicks off compilation via `builder` (async by default).
+     *
+     * Pass `sync: true` on the runtime-mutation path to use
+     * `builder.createSync` instead — the returned slot's `pipeline` will
+     * be populated immediately.
+     */
+    addRO(descriptor: PipelineStateDescriptor, options?: {
+        sync?: boolean;
+    }): SlotTableEntry;
+    /** Drop one reference from the slot. Pipelines stay resident. */
+    removeRO(modeKey: bigint): void;
+    /**
+     * Move an RO from one slot to another (reactive aval mutation
+     * caused its modeKey to change). Returns the new (possibly newly
+     * allocated) slot.
+     */
+    rebindRO(fromModeKey: bigint, toDescriptor: PipelineStateDescriptor, options?: {
+        sync?: boolean;
+    }): SlotTableEntry;
+    /** Sync slot lookup by modeKey. Returns the entry or null. */
+    lookup(modeKey: bigint): SlotTableEntry | null;
+    /**
+     * Resolves when every currently-registered slot has a linked
+     * pipeline. Subsequent `addRO` calls after this resolves with
+     * `sync: false` will produce fresh pending work; call `ready()`
+     * again to wait.
+     */
+    ready(): Promise<void>;
+}
+//# sourceMappingURL=slotTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotTable.d.ts","sourceRoot":"","sources":["../../../src/runtime/derivedModes/slotTable.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,aAAa,EAEb,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC7B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAI,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC7C,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,qBAAa,SAAS;IAQlB,QAAQ,CAAC,KAAK,EAAE,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,eAAe;IARnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,yEAAyE;IACzE,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,OAAO,CAAK;gBAGT,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,eAAe;IAGnC,4CAA4C;IAC5C,IAAI,SAAS,IAAI,MAAM,CAAgC;IACvD;;;;OAIG;IACH,IAAI,aAAa,IAAI,MAAM,CAAyB;IACpD,6CAA6C;IAC5C,GAAG,IAAI,gBAAgB,CAAC,cAAc,CAAC;IAExC;;;;;;;;OAQG;IACH,KAAK,CACH,UAAU,EAAE,uBAAuB,EACnC,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/B,cAAc;IA8BjB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAM/B;;;;OAIG;IACH,QAAQ,CACN,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,uBAAuB,EACrC,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAO,GAC/B,cAAc;IAKjB,8DAA8D;IAC9D,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAI9C;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}