@vessel-dsp/runtime 0.2.0

package/dist/chain-slot.js

@@ -0,0 +1,105 @@
+// A chain slot that is not a compiled circuit.
+//
+// The chain used to be `Program[]`, which made every slot an MNA circuit and left the signal's final
+// destination outside the runtime entirely. `chain-advisories.ts` said so in as many words: the rule
+// that a miked signal must not be sent through a cabinet again "is **not expressible here**, because
+// the coloration stage is not a chain slot". Making it one is what this file is for.
+//
+// **The runtime does not implement NAM or IR, and must not.** Two rules forbid it, and they agree:
+// the v2 runtime may import the program contract and nothing else, so `src/dsp`'s convolvers and the
+// cab simulator are out of reach; and the console/ROM rule says adding a device must never require a
+// runtime change. A NAM profile is another kind of ROM. So the runtime owns the **seams** -- scaling,
+// ordering, advisories, telemetry -- and the host supplies the engine.
+//
+// What a slot must state is therefore small, and it is the same in both directions:
+//
+//   - **what it produces**, as a `stageCoverage`, so the chain knows how far down the amplification
+//     path its output already sits;
+//   - **what it expects**, so a speaker terminal feeding an instrument input is separable from a
+//     speaker terminal feeding a cabinet, which is a legitimate and very common connection;
+//   - **its full scale at each port**, or `null`, so seams scale where both sides know and are
+//     reported where they do not.
+//
+// A compiled `Program` already carries the first and third. It does not carry the second because it
+// does not need to: a compiled circuit's input is a jack, and a jack expects an instrument-level
+// signal. That is why `slotContract` supplies `instrument` for a program rather than the compiler
+// growing a field.
+/**
+ * Row 8 tail step 1 — host mapping: bypass state → chain mode, per `program.bypass.kind`.
+ *
+ * The Studio's slot toggle already reads ENGAGED/BYPASSED, but the worklet chain omitted
+ * bypassed slots, so a bypassed buffered pedal ran no buffer and the mode plumbing
+ * (`setBypassMode`, `effectiveBypassMode`) never engaged in product. The host now keeps
+ * the slot and states the mode instead of dropping it.
+ *
+ * Returns `null` when no honest mode exists yet: `buffered` bypass needs the compiler's
+ * `bufferProgram` derivation (row 8 step 2), and requesting `buffer` without one falls back
+ * to the full program — which would play the effect under bypass. The caller omits those
+ * slots exactly as before, until step 2 lands. Everything else maps:
+ * engaged → `effect`; bypassed `true-bypass` → `wire`; `hardwire` → `wire`, with the input
+ * loading a hardwired output switch leaves behind still unmodelled (23 pedals by census —
+ * named here, not silent); `none` / `not-in-audio-path` → `wire`, agreeing with the
+ * runtime's own demotion guard.
+ */
+export function resolveBypassMode(bypass, engaged) {
+    if (engaged) {
+        return "effect";
+    }
+    if (bypass.declared === "none") {
+        return "wire";
+    }
+    switch (bypass.kind) {
+        case "true-bypass":
+            return "wire";
+        case "hardwire":
+            return "wire";
+        case "buffered":
+        case "buffered-mechanical":
+            // Both carry the pedal's own buffers in the bypass path; neither has a chain mode
+            // until the buffer program exists (row 8 step 3), so the host must decide.
+            return null;
+        case "not-in-audio-path":
+            return "wire";
+        default:
+            return "wire";
+    }
+}
+/** A compiled circuit as a slot. `bufferProgram` is the buffer-only stages for buffered bypass. */
+export function programSlot(program, bufferProgram) {
+    return bufferProgram !== undefined ? { kind: "program", program, bufferProgram } : { kind: "program", program };
+}
+/** A compiled circuit as a slot with explicit buffer processor (WASM). */
+export function programSlotWithBufferProcessor(program, bufferProcessor, bufferProgram) {
+    return { kind: "program", program, bufferProgram, bufferProcessor, bypassMode: "effect" };
+}
+/** An injected processor as a slot. */
+export function processorSlot(processor) {
+    return { kind: "processor", processor };
+}
+/**
+ * The contract a slot presents to the seam arithmetic.
+ *
+ * A program's `expects` is `instrument` by construction -- its input is a jack. Nothing infers it,
+ * and no compiler field is needed for it.
+ */
+export function slotContract(slot) {
+    if (slot.kind === "processor") {
+        return slot.processor;
+    }
+    return {
+        produces: slot.program.stageCoverage,
+        expects: "instrument",
+        portFullScaleVolts: slot.program.portFullScaleVolts,
+        portReferenceVolts: slot.program.portReferenceVolts,
+        // A compiled circuit always has electrical ports, so this is the object form even when both
+        // impedances are unstated. A processor supplies `null` instead -- see `SlotContract`.
+        portImpedanceOhms: slot.program.portImpedanceOhms,
+    };
+}
+/** How a slot names itself in a message. */
+export function slotLabel(slot, index) {
+    return slot.kind === "processor"
+        ? `slot ${index} (${slot.processor.id})`
+        : `slot ${index}`;
+}
+//# sourceMappingURL=chain-slot.js.map

package/dist/chain-slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-slot.js","sourceRoot":"","sources":["../src/chain-slot.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,qGAAqG;AACrG,qGAAqG;AACrG,qGAAqG;AACrG,qFAAqF;AACrF,EAAE;AACF,mGAAmG;AACnG,qGAAqG;AACrG,qGAAqG;AACrG,sGAAsG;AACtG,uEAAuE;AACvE,EAAE;AACF,oFAAoF;AACpF,EAAE;AACF,oGAAoG;AACpG,oCAAoC;AACpC,iGAAiG;AACjG,4FAA4F;AAC5F,+FAA+F;AAC/F,kCAAkC;AAClC,EAAE;AACF,oGAAoG;AACpG,iGAAiG;AACjG,kGAAkG;AAClG,mBAAmB;AA2FnB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,iBAAiB,CAChC,MAAyB,EACzB,OAAgB;IAEhB,IAAI,OAAO,EAAE,CAAC;QACb,OAAO,QAAQ,CAAC;IACjB,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;QAChC,OAAO,MAAM,CAAC;IACf,CAAC;IACD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,aAAa;YACjB,OAAO,MAAM,CAAC;QACf,KAAK,UAAU;YACd,OAAO,MAAM,CAAC;QACf,KAAK,UAAU,CAAC;QAChB,KAAK,qBAAqB;YACzB,kFAAkF;YAClF,2EAA2E;YAC3E,OAAO,IAAI,CAAC;QACb,KAAK,mBAAmB;YACvB,OAAO,MAAM,CAAC;QACf;YACC,OAAO,MAAM,CAAC;IAChB,CAAC;AACF,CAAC;AAiBD,mGAAmG;AACnG,MAAM,UAAU,WAAW,CAAC,OAAgB,EAAE,aAAuB;IACpE,OAAO,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AACjH,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,8BAA8B,CAC7C,OAAgB,EAChB,eAAkC,EAClC,aAAuB;IAEvB,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;AAC3F,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,aAAa,CAAC,SAA4B;IACzD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AACzC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,IAAe;IAC3C,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IACD,OAAO;QACN,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa;QACpC,OAAO,EAAE,YAAY;QACrB,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB;QACnD,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB;QACnD,4FAA4F;QAC5F,sFAAsF;QACtF,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;KACjD,CAAC;AACH,CAAC;AAED,4CAA4C;AAC5C,MAAM,UAAU,SAAS,CAAC,IAAe,EAAE,KAAa;IACvD,OAAO,IAAI,CAAC,IAAI,KAAK,WAAW;QAC/B,CAAC,CAAC,QAAQ,KAAK,KAAK,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG;QACxC,CAAC,CAAC,QAAQ,KAAK,EAAE,CAAC;AACpB,CAAC"}

package/dist/chain.d.ts

@@ -0,0 +1,113 @@
+import type { ControlId } from "@vessel-dsp/compiler";
+import { type RealtimeBudget } from "./admission";
+import { type ChainSlot } from "./chain-slot";
+import type { SupplyAddress } from "./supply";
+import { type RuntimeTelemetry } from "./reference-runtime";
+/** One slot's own telemetry, labelled by position. See `ChainRuntime.telemetry()`. */
+export type ChainSlotTelemetry = RuntimeTelemetry & {
+    readonly slot: number;
+};
+export type BypassMode = "wire" | "buffer" | "effect";
+export declare class ChainRuntime {
+    private readonly slots;
+    private readonly contracts;
+    /** One per slot: a runtime for a program, the injected processor otherwise. */
+    private readonly engines;
+    /** Parallel buffer engines; ExternalProcessor for WASM buffer, ReferenceRuntime for TS buffer. */
+    private readonly bufferEngines;
+    /**
+     * Output DC blocker state, carried across `process` calls.
+     *
+     * **A chain ends in something, and that something is AC-coupled.** A runtime reads the
+     * output jack unloaded and DC-coupled, which no real signal chain is: the next device
+     * always presents a coupling cap and an input resistance. Without this the jack's
+     * operating point reaches the converter, and a packet whose output sits a few volts off
+     * ground clamps every sample to full scale -- audible offline, digitally silent here.
+     * Measured 2026-09-22: four corpus packets were in that state, `boss-dd-5` at 3.561 V
+     * against a 1.0 V full scale.
+     *
+     * Stateful across calls because a worklet hands over 128 samples at a time; a per-buffer
+     * mean-subtract would put a step at every quantum boundary.
+     */
+    private dcPole;
+    private dcPreviousIn;
+    private dcPreviousOut;
+    constructor(slots: readonly ChainSlot[]);
+    private effectiveBypassMode;
+    private effectiveContract;
+    /** How many slots this chain has. */
+    get length(): number;
+    /**
+     * Gates the whole chain once (see this module's header), then prepares every slot,
+     * ungated, at the same rate and iteration cap. A slot's own refusal -- an operator or
+     * DSP model this runtime cannot execute -- is rethrown naming its slot, since
+     * `ReferenceRuntime`'s `RuntimeError` cannot know which slot it ran in.
+     */
+    prepare(sampleRate: number, options?: {
+        readonly maxNewtonIterations?: number;
+        readonly realtimeBudget?: RealtimeBudget;
+    }): void;
+    /**
+     * Slot 0 runs on `input`; its output buffer becomes slot 1's input, and so on -- the
+     * last slot's output is the chain's output.
+     *
+     * Whole buffers pass between slots rather than sample-by-sample calls between them.
+     * That is safe, not merely convenient: this is a feedforward chain (no slot reads a
+     * later slot's output), `ReferenceRuntime.process` has no lookahead -- each sample is a
+     * causal function of that slot's own past reactive state and the sample handed to it --
+     * so slot 1 sees the identical sample sequence in the identical order whether the chain
+     * hands it one sample at a time or the whole buffer at once. Each slot still advances
+     * its own sample-by-sample loop internally exactly as it always has.
+     *
+     * Allocates one `Float64Array` per slot per call (each `ReferenceRuntime.process` call
+     * allocates its own output buffer) -- for a worklet driven at a small quantum this is an
+     * allocation on the audio thread every callback, once per slot in the chain. Left as is:
+     * reusing scratch buffers across slots is a separate change, noted rather than made here.
+     *
+     * **Bypass modes:**
+     * - `wire` (true-bypass): no seam scaling, no solver — a wire.
+     * - `buffer` (buffered bypass): runs the bufferProgram (a handful of nodes), with seam
+     *   scaling against the buffer's output (a real stage). If no bufferProgram is present,
+     *   falls back to full program (slower, never wrong).
+     * - `effect` (default): full program.
+     * The seam into a bypassed slot is not scaled (a wire has no port), and the seam into
+     * the next non-wire slot is computed against the last non-wire upstream.
+     */
+    process(input: Float64Array): Float64Array;
+    /**
+     * The coupling every real downstream device presents, as a first-order high pass.
+     *
+     * Identical pole to the offline renderer's, deliberately. A plain mean-subtract would
+     * leave the operating-point settling ramp in the signal and would step at every buffer
+     * boundary; this removes both and carries its state across calls.
+     */
+    private blockDc;
+    setBypassMode(slot: number, mode: BypassMode): void;
+    /** Slots where bypass was requested but the packet declares `audio.bypass: "none"` — wired through, flagged. */
+    bypassNotModelledSlots(): readonly number[];
+    /**
+     * Addresses a control by (slot, id). Slot index is the only disambiguator: two identical
+     * pedals in the chain declare the same control ids, but each slot owns an independent
+     * `ReferenceRuntime` with its own control-position map, so the shared id never collides
+     * with the other slot's.
+     */
+    setControl(slot: number, id: ControlId, position: number): void;
+    /**
+     * Addresses a supply by (slot, addresses), mirroring `setControl`'s routing.
+     * Each slot owns an independent `ReferenceRuntime` with its own supply
+     * stamps, so the shared `sourceIndex` never collides with another slot's.
+     * A processor slot (NAM or IR) is refused by name: it has no compiled
+     * `dc-source` stamps, and a silently ignored rail would be the failure this
+     * file's telemetry exists to avoid.
+     */
+    setSupply(slot: number, addresses: readonly SupplyAddress[], volts: number, sourceOhms: number): void;
+    /**
+     * Every slot's own telemetry, labelled by position -- never blended into one set of
+     * totals. A chain's `samples`/`heldSamples`/etc. are per-slot facts (a nonlinear block
+     * failing to converge in slot 2 says nothing about slot 0), so summing or averaging them
+     * would silently under-report whichever slot is actually struggling; see this module's
+     * header and `RuntimeTelemetry` in `reference-runtime.ts`.
+     */
+    telemetry(): readonly ChainSlotTelemetry[];
+}
+//# sourceMappingURL=chain.d.ts.map

package/dist/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../src/chain.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,SAAS,EAAW,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAEpE,OAAO,EACN,KAAK,SAAS,EAKd,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAIN,KAAK,gBAAgB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,sFAAsF;AACtF,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAWtD,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoD;IAC5E,kGAAkG;IAClG,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2D;IACzF;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,aAAa,CAAK;gBAEd,KAAK,EAAE,SAAS,SAAS,EAAE;IAkBvC,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,iBAAiB;IAmBzB,qCAAqC;IACrC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACH,OAAO,CACN,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;QACR,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;QACtC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;KACpC,GACJ,IAAI;IAmDP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY;IAkD1C;;;;;;OAMG;IACH,OAAO,CAAC,OAAO;IAcf,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI;IAkBnD,gHAAgH;IAChH,sBAAsB,IAAI,SAAS,MAAM,EAAE;IAY3C;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAmB/D;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,aAAa,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAgBrG;;;;;;OAMG;IACH,SAAS,IAAI,SAAS,kBAAkB,EAAE;CAW1C"}

package/dist/chain.js

@@ -0,0 +1,355 @@
+// A chain: an ordered list of compiled Programs the v2 console runs in series -- slot 0's
+// output sample feeds slot 1's input sample, and so on, and the last slot's output is the
+// chain's output. This is what makes "pedal A into pedal B" a runtime concern rather than a
+// compiler one.
+//
+// **A chain is a property of the runtime, never of a Program.** No field here describes a
+// program's position in a chain, no program is fused with another at any point, and no
+// pedal's compiled bytes change depending on which slot it occupies. `ChainRuntime` is
+// nothing more than N independent `ReferenceRuntime` instances, each with its own state and
+// its own `prepare(rate)`, wired output-to-input. A single pedal is the one-element case of
+// this, not a separate code path -- see `admission.ts`'s own header, which already says so:
+// "there is no single-program entry point left ... a caller with one program passes a
+// one-element list and gets an identical answer." `admission.ts` and
+// `reference-runtime.ts`'s `prepare()` both already name this file in comments written
+// before it existed; this is that file.
+//
+// **Gate once, prepare ungated.** `admissionVerdict` takes the whole ordered list and sums
+// worst-case cost across every slot -- gating each slot separately against the whole budget
+// is exactly the permissive failure admission.ts's header warns about (three pedals at 0.9x
+// each, admitted individually, need 2.7x together). So `prepare()` here calls
+// `admissionVerdict` once over `this.programs`, then prepares every slot's own
+// `ReferenceRuntime` with no `realtimeBudget` at all -- passing the budget down a second
+// time would charge each slot against the *whole* chain's budget again.
+//
+// The operator/model lockout is untouched and still runs per slot: it is a question about
+// whether a runtime can execute a program at all, independent of any budget, and it lives
+// inside `ReferenceRuntime.prepare()` before that method ever looks at `realtimeBudget` --
+// see its own comment. A slot that fails it here is refused with the slot named, because
+// `ReferenceRuntime`'s own `RuntimeError` has no way to know which slot it was running in.
+import { admissionVerdict } from "./admission.js";
+import { seamScale } from "./chain-advisories.js";
+import { slotContract, slotLabel, } from "./chain-slot.js";
+import { DEFAULT_NEWTON_MAX_ITERATIONS, ReferenceRuntime, RuntimeError, } from "./reference-runtime.js";
+/**
+ * Corner of the chain's output DC blocker, in hertz.
+ *
+ * The same 10 Hz first-order pole `scripts/render-v2-audio.ts` has used since the
+ * `marshall-blues-breaker` finding. The two paths must agree: a packet that is listenable
+ * offline and silent in the browser is precisely the defect this constant exists to close.
+ */
+const DC_BLOCK_HZ = 10;
+export class ChainRuntime {
+    slots;
+    contracts;
+    /** One per slot: a runtime for a program, the injected processor otherwise. */
+    engines;
+    /** Parallel buffer engines; ExternalProcessor for WASM buffer, ReferenceRuntime for TS buffer. */
+    bufferEngines;
+    /**
+     * Output DC blocker state, carried across `process` calls.
+     *
+     * **A chain ends in something, and that something is AC-coupled.** A runtime reads the
+     * output jack unloaded and DC-coupled, which no real signal chain is: the next device
+     * always presents a coupling cap and an input resistance. Without this the jack's
+     * operating point reaches the converter, and a packet whose output sits a few volts off
+     * ground clamps every sample to full scale -- audible offline, digitally silent here.
+     * Measured 2026-09-22: four corpus packets were in that state, `boss-dd-5` at 3.561 V
+     * against a 1.0 V full scale.
+     *
+     * Stateful across calls because a worklet hands over 128 samples at a time; a per-buffer
+     * mean-subtract would put a step at every quantum boundary.
+     */
+    dcPole = 0;
+    dcPreviousIn = 0;
+    dcPreviousOut = 0;
+    constructor(slots) {
+        if (slots.length === 0) {
+            throw new RuntimeError("a chain needs at least one slot, got 0");
+        }
+        this.slots = slots.map((s) => ({ ...s }));
+        this.contracts = this.slots.map((slot) => slotContract(slot));
+        this.engines = this.slots.map((slot) => slot.kind === "program"
+            ? new ReferenceRuntime(slot.program)
+            : slot.processor);
+        this.bufferEngines = this.slots.map((slot) => {
+            if (slot.bufferProcessor !== undefined)
+                return slot.bufferProcessor;
+            if (slot.kind === "program" && slot.bufferProgram !== undefined)
+                return new ReferenceRuntime(slot.bufferProgram);
+            return null;
+        });
+    }
+    effectiveBypassMode(slot) {
+        const s = this.slots[slot];
+        const raw = s?.bypassMode ?? "effect";
+        // Declared absence or switch not in audio path: wire is the only honest choice.
+        // Surface via advisory, not log.
+        if (raw !== "effect" && s?.kind === "program") {
+            if (s.program.bypass.declared === "none" ||
+                s.program.bypass.kind === "not-in-audio-path") {
+                return "wire";
+            }
+        }
+        return raw;
+    }
+    effectiveContract(slot) {
+        const s = this.slots[slot];
+        if (s === undefined)
+            return null;
+        const mode = this.effectiveBypassMode(slot);
+        if (mode === "wire")
+            return null;
+        if (mode === "buffer") {
+            if (s.bufferProcessor !== undefined)
+                return s.bufferProcessor;
+            if (s.kind === "program" && s.bufferProgram !== undefined) {
+                return {
+                    produces: s.bufferProgram.stageCoverage,
+                    expects: "instrument",
+                    portFullScaleVolts: s.bufferProgram.portFullScaleVolts,
+                    portImpedanceOhms: s.bufferProgram.portImpedanceOhms,
+                };
+            }
+        }
+        return slotContract(s);
+    }
+    /** How many slots this chain has. */
+    get length() {
+        return this.engines.length;
+    }
+    /**
+     * Gates the whole chain once (see this module's header), then prepares every slot,
+     * ungated, at the same rate and iteration cap. A slot's own refusal -- an operator or
+     * DSP model this runtime cannot execute -- is rethrown naming its slot, since
+     * `ReferenceRuntime`'s `RuntimeError` cannot know which slot it ran in.
+     */
+    prepare(sampleRate, options = {}) {
+        // Resolved here, once, so the iteration count the admission gate charges is exactly
+        // the iteration count every slot will actually be prepared with -- `ReferenceRuntime`
+        // resolves the identical default the identical way, from the identical constant.
+        const maxNewtonIterations = Math.max(1, Math.floor(options.maxNewtonIterations ?? DEFAULT_NEWTON_MAX_ITERATIONS));
+        this.dcPole = sampleRate > 0 ? 1 - (2 * Math.PI * DC_BLOCK_HZ) / sampleRate : 0;
+        this.dcPreviousIn = 0;
+        this.dcPreviousOut = 0;
+        if (options.realtimeBudget !== undefined) {
+            // **Only the compiled slots are charged.** The admission model costs Newton iterations
+            // against a matrix it can size from the program; an injected NAM or IR has neither, and
+            // guessing a cost for it would make the verdict a fiction. A chain whose processors are
+            // expensive can still overrun, and that is the host's to know -- so a `fits` verdict here
+            // means the circuit slots fit, not that the whole chain does.
+            const verdict = admissionVerdict(this.slots.flatMap((slot) => slot.kind === "program" ? [slot.program] : []), sampleRate, options.realtimeBudget);
+            if (!verdict.fits) {
+                throw new RuntimeError(verdict.reason);
+            }
+        }
+        for (const [slot, engine] of this.engines.entries()) {
+            try {
+                // Ungated: `realtimeBudget` is deliberately not forwarded here. The whole
+                // chain was already charged against it above; forwarding it per slot would
+                // charge every slot against the whole chain's budget a second time.
+                if (engine instanceof ReferenceRuntime) {
+                    engine.prepare(sampleRate, { maxNewtonIterations });
+                }
+                else {
+                    engine.prepare(sampleRate);
+                }
+                const bufEngine = this.bufferEngines[slot];
+                if (bufEngine !== null) {
+                    bufEngine.prepare(sampleRate, { maxNewtonIterations });
+                }
+            }
+            catch (error) {
+                if (error instanceof RuntimeError) {
+                    throw new RuntimeError(`slot ${slot}: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+    }
+    /**
+     * Slot 0 runs on `input`; its output buffer becomes slot 1's input, and so on -- the
+     * last slot's output is the chain's output.
+     *
+     * Whole buffers pass between slots rather than sample-by-sample calls between them.
+     * That is safe, not merely convenient: this is a feedforward chain (no slot reads a
+     * later slot's output), `ReferenceRuntime.process` has no lookahead -- each sample is a
+     * causal function of that slot's own past reactive state and the sample handed to it --
+     * so slot 1 sees the identical sample sequence in the identical order whether the chain
+     * hands it one sample at a time or the whole buffer at once. Each slot still advances
+     * its own sample-by-sample loop internally exactly as it always has.
+     *
+     * Allocates one `Float64Array` per slot per call (each `ReferenceRuntime.process` call
+     * allocates its own output buffer) -- for a worklet driven at a small quantum this is an
+     * allocation on the audio thread every callback, once per slot in the chain. Left as is:
+     * reusing scratch buffers across slots is a separate change, noted rather than made here.
+     *
+     * **Bypass modes:**
+     * - `wire` (true-bypass): no seam scaling, no solver — a wire.
+     * - `buffer` (buffered bypass): runs the bufferProgram (a handful of nodes), with seam
+     *   scaling against the buffer's output (a real stage). If no bufferProgram is present,
+     *   falls back to full program (slower, never wrong).
+     * - `effect` (default): full program.
+     * The seam into a bypassed slot is not scaled (a wire has no port), and the seam into
+     * the next non-wire slot is computed against the last non-wire upstream.
+     */
+    process(input) {
+        let buffer = input;
+        let lastNonWire = -1;
+        for (const [slot, engine] of this.engines.entries()) {
+            const mode = this.effectiveBypassMode(slot);
+            if (mode === "wire") {
+                continue;
+            }
+            const isBuffer = mode === "buffer";
+            const effectiveContract = this.effectiveContract(slot);
+            const upstreamContract = lastNonWire >= 0 ? this.effectiveContract(lastNonWire) : null;
+            if (lastNonWire >= 0 && effectiveContract !== null && upstreamContract !== null) {
+                const upstream = upstreamContract.portFullScaleVolts.output;
+                const downstream = effectiveContract.portFullScaleVolts.input;
+                const scale = upstream === null || downstream === null || downstream === 0 ? 1 : upstream / downstream;
+                const source = upstreamContract.portImpedanceOhms;
+                const load = effectiveContract.portImpedanceOhms;
+                const out = source?.output ?? null;
+                const inn = load?.input ?? null;
+                let divider = 1;
+                if (out !== null && inn !== null) {
+                    const total = out + inn;
+                    divider = total <= 0 ? 1 : inn / total;
+                }
+                const effectiveScale = scale * divider;
+                if (effectiveScale !== 1) {
+                    const scaled = new Float64Array(buffer.length);
+                    for (let index = 0; index < buffer.length; index += 1) {
+                        scaled[index] = (buffer[index] ?? 0) * effectiveScale;
+                    }
+                    buffer = scaled;
+                }
+            }
+            else if (slot > 0 && lastNonWire === -1) {
+                // Leading wire slots: no upstream to scale against.
+            }
+            if (isBuffer) {
+                const bufEngine = this.bufferEngines[slot];
+                if (bufEngine !== null) {
+                    buffer = bufEngine.process(buffer);
+                }
+                else {
+                    buffer = engine.process(buffer);
+                }
+            }
+            else {
+                buffer = engine.process(buffer);
+            }
+            lastNonWire = slot;
+        }
+        return this.blockDc(buffer);
+    }
+    /**
+     * The coupling every real downstream device presents, as a first-order high pass.
+     *
+     * Identical pole to the offline renderer's, deliberately. A plain mean-subtract would
+     * leave the operating-point settling ramp in the signal and would step at every buffer
+     * boundary; this removes both and carries its state across calls.
+     */
+    blockDc(buffer) {
+        if (!(this.dcPole > 0) || buffer.length === 0) {
+            return buffer;
+        }
+        const out = new Float64Array(buffer.length);
+        for (let index = 0; index < buffer.length; index += 1) {
+            const sample = buffer[index] ?? 0;
+            this.dcPreviousOut = sample - this.dcPreviousIn + this.dcPole * this.dcPreviousOut;
+            this.dcPreviousIn = sample;
+            out[index] = this.dcPreviousOut;
+        }
+        return out;
+    }
+    setBypassMode(slot, mode) {
+        const current = this.slots[slot];
+        if (current === undefined) {
+            throw new RuntimeError(`chain has no slot ${slot} (chain length is ${this.engines.length})`);
+        }
+        const next = current.kind === "program"
+            ? {
+                kind: "program",
+                program: current.program,
+                bufferProgram: current.bufferProgram,
+                bufferProcessor: current.bufferProcessor,
+                bypassMode: mode,
+            }
+            : { kind: "processor", processor: current.processor, bypassMode: mode };
+        this.slots[slot] = next;
+    }
+    /** Slots where bypass was requested but the packet declares `audio.bypass: "none"` — wired through, flagged. */
+    bypassNotModelledSlots() {
+        const out = [];
+        for (let i = 0; i < this.slots.length; i++) {
+            const s = this.slots[i];
+            if (s === undefined || s.kind !== "program")
+                continue;
+            const mode = s.bypassMode ?? "effect";
+            if (mode !== "wire" && mode !== "buffer")
+                continue;
+            if (s.program.bypass.declared === "none")
+                out.push(i);
+        }
+        return out;
+    }
+    /**
+     * Addresses a control by (slot, id). Slot index is the only disambiguator: two identical
+     * pedals in the chain declare the same control ids, but each slot owns an independent
+     * `ReferenceRuntime` with its own control-position map, so the shared id never collides
+     * with the other slot's.
+     */
+    setControl(slot, id, position) {
+        const engine = this.engines[slot];
+        if (engine === undefined) {
+            throw new RuntimeError(`chain has no slot ${slot} (chain length is ${this.engines.length})`);
+        }
+        // A processor has no compiled controls. Its parameters are the host's to set on the object
+        // it supplied, which is why refusing here names the slot rather than inventing a no-op: a
+        // silently ignored knob is the failure this whole file's telemetry exists to avoid.
+        if (!(engine instanceof ReferenceRuntime)) {
+            throw new RuntimeError(`slot ${slot} is an injected processor (${slotLabel(this.slots[slot], slot)}) ` +
+                `and carries no compiled control "${id}": set it on the processor the host supplied`);
+        }
+        engine.setControl(id, position);
+    }
+    /**
+     * Addresses a supply by (slot, addresses), mirroring `setControl`'s routing.
+     * Each slot owns an independent `ReferenceRuntime` with its own supply
+     * stamps, so the shared `sourceIndex` never collides with another slot's.
+     * A processor slot (NAM or IR) is refused by name: it has no compiled
+     * `dc-source` stamps, and a silently ignored rail would be the failure this
+     * file's telemetry exists to avoid.
+     */
+    setSupply(slot, addresses, volts, sourceOhms) {
+        const engine = this.engines[slot];
+        if (engine === undefined) {
+            throw new RuntimeError(`chain has no slot ${slot} (chain length is ${this.engines.length})`);
+        }
+        if (!(engine instanceof ReferenceRuntime)) {
+            throw new RuntimeError(`slot ${slot} is an injected processor (${slotLabel(this.slots[slot], slot)}) ` +
+                `and carries no compiled supply: set it on the processor the host supplied`);
+        }
+        engine.setSupply(addresses, volts, sourceOhms);
+    }
+    /**
+     * Every slot's own telemetry, labelled by position -- never blended into one set of
+     * totals. A chain's `samples`/`heldSamples`/etc. are per-slot facts (a nonlinear block
+     * failing to converge in slot 2 says nothing about slot 0), so summing or averaging them
+     * would silently under-report whichever slot is actually struggling; see this module's
+     * header and `RuntimeTelemetry` in `reference-runtime.ts`.
+     */
+    telemetry() {
+        // Only the compiled slots have telemetry to give -- `samples`, `heldSamples`, Newton counts
+        // are all properties of an MNA solve. A processor slot is absent rather than reported as
+        // zeroes, because a zero held-sample count would read as "converged fine" for something that
+        // never ran a solve at all.
+        return this.engines.flatMap((engine, slot) => engine instanceof ReferenceRuntime
+            ? [{ ...engine.telemetry(), slot }]
+            : []);
+    }
+}
+//# sourceMappingURL=chain.js.map

package/dist/chain.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { ChainRuntime } from "./chain";
+export { bypassNotModelledAdvisories, chainAdvisories, seamScale, type ChainAdvisory, } from "./chain-advisories";
+export { dacScaleFactor, outputConversionFullScale, outputDbfs } from "./chain-scale";
+export { processorSlot, programSlot, resolveBypassMode, slotContract, type ChainSlot, type ExternalProcessor, type SlotContract, type StageCoverage, } from "./chain-slot";
+export { DEFAULT_NEWTON_MAX_ITERATIONS, ReferenceRuntime, RuntimeError, type RuntimeNodeVoltageSnapshot, } from "./reference-runtime";
+export type { SupplyAddress, SupplyInfo } from "./supply";
+export { SETTLE_DEFAULTS, measureInputAttributable, measureSharedWindow, settledRender, settledSweepVerified, type SettleOptions, } from "./settle";
+export { supplyGroundConflicts, type SupplyGroundConflict } from "./supply-ground";
+export { taperFraction } from "./taper";
+export { V2WasmEngine } from "./v2-wasm-engine";
+export * from "./calibrate";
+export { admissionVerdict, predictedWorstCaseNs } from "./admission";
+export type { AdmissionVerdict, RealtimeBudget } from "./admission";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EACN,2BAA2B,EAC3B,eAAe,EACf,SAAS,EACT,KAAK,aAAa,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EACN,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EACN,6BAA6B,EAC7B,gBAAgB,EAChB,YAAY,EACZ,KAAK,0BAA0B,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EACN,eAAe,EACf,wBAAwB,EACxB,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,KAAK,aAAa,GAClB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACrE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+// Public surface of the v2 runtime: a compiled Program to audio.
+//
+// The runtime is a generic console and a compiled pedal is a ROM; the only thing it
+// shares with the compiler is the Program contract, imported as types. Everything the
+// browser surface and the report scripts use is exported here, and nothing outside
+// `src/runtime/` reaches a console file directly.
+export { ChainRuntime } from "./chain.js";
+export { bypassNotModelledAdvisories, chainAdvisories, seamScale, } from "./chain-advisories.js";
+export { dacScaleFactor, outputConversionFullScale, outputDbfs } from "./chain-scale.js";
+export { processorSlot, programSlot, resolveBypassMode, slotContract, } from "./chain-slot.js";
+export { DEFAULT_NEWTON_MAX_ITERATIONS, ReferenceRuntime, RuntimeError, } from "./reference-runtime.js";
+export { SETTLE_DEFAULTS, measureInputAttributable, measureSharedWindow, settledRender, settledSweepVerified, } from "./settle.js";
+export { supplyGroundConflicts } from "./supply-ground.js";
+export { taperFraction } from "./taper.js";
+export { V2WasmEngine } from "./v2-wasm-engine.js";
+export * from "./calibrate.js";
+export { admissionVerdict, predictedWorstCaseNs } from "./admission.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,EAAE;AACF,oFAAoF;AACpF,sFAAsF;AACtF,mFAAmF;AACnF,kDAAkD;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EACN,2BAA2B,EAC3B,eAAe,EACf,SAAS,GAET,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EACN,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,YAAY,GAKZ,MAAM,cAAc,CAAC;AACtB,OAAO,EACN,6BAA6B,EAC7B,gBAAgB,EAChB,YAAY,GAEZ,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,eAAe,EACf,wBAAwB,EACxB,mBAAmB,EACnB,aAAa,EACb,oBAAoB,GAEpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,qBAAqB,EAA6B,MAAM,iBAAiB,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}