@vessel-dsp/runtime 0.2.0

package/README.md

@@ -0,0 +1,178 @@
+# @vessel-dsp/runtime
+
+Headless real time MNA simulation runtime and solver console for compiled VesselDSP `Program` ROMs. It executes a `@vessel-dsp/compiler` program on audio streams with trapezoidal integration and damped Newton Raphson iteration. It depends on `@vessel-dsp/compiler` only.
+
+## Install
+
+`@vessel-dsp/runtime` 0.1.0 is not yet on npm. Until the release is published, use the package from this repository's workspace rather than an install command that will 404.
+
+```bash
+# once published:
+bun add @vessel-dsp/runtime
+```
+
+## Minimal example
+
+The constructor takes the program and optional block elimination only. The sample rate goes to `prepare()`, which has no default. `process()` takes a `Float64Array` and returns a new `Float64Array`.
+
+```ts
+import { readFileSync } from "node:fs";
+import { compile, pedalPartCatalog } from "@vessel-dsp/compiler";
+import { ReferenceRuntime } from "@vessel-dsp/runtime";
+
+const source = readFileSync("big-muff-pi.vdsp", "utf8");
+const compiled = compile(source, { registry: pedalPartCatalog });
+if (compiled.status !== "ok") throw new Error("compile failed");
+
+const runtime = new ReferenceRuntime(compiled.program);
+runtime.prepare(44100);
+
+const input = new Float64Array(128);
+for (let i = 0; i < input.length; i++) {
+  input[i] = 0.2 * Math.sin((2 * Math.PI * 220 * i) / 44100);
+}
+const output = runtime.process(input);
+console.log("output length:", output.length);
+console.log("output is Float64Array:", output instanceof Float64Array);
+let peak = 0;
+for (const v of output) peak = Math.max(peak, Math.abs(v));
+console.log("output peak:", peak.toFixed(6));
+```
+
+```text
+output length: 128
+output is Float64Array: true
+output peak: 0.265499
+```
+
+The previous version of this example constructed `new ReferenceRuntime(program, 44100)` and called `process(inputBuffer, outputBuffer)` with `Float32Array` buffers. That throws `RuntimeError: prepare(sampleRate) was never called`, because the second constructor argument is an options object and the rate is only accepted by `prepare()`.
+
+## Construct, prepare, process
+
+`new ReferenceRuntime(program, options?)` copies the program blocks it may later retarget (copy on write) and records control defaults. Options: `{ eliminateBlocks }`, a set of block ids solved by symbolic elimination.
+
+`prepare(sampleRate, options?)` is the only place a rate enters. There is no default. It refuses unusable rates (`sample rate 5 is not usable; a program has no default rate`), programs needing operators or DSP models it does not implement (named in the message), and chains that fail the opt in admission gate. Options:
+
+- `maxNewtonIterations` (default `DEFAULT_NEWTON_MAX_ITERATIONS`): CPU versus accuracy knob. Samples that exhaust it are held and counted in telemetry, never silently interpolated.
+- `realtimeBudget`: opt in admission gate; omitted means no gating.
+- `inputSourceOhms` (default 0): series impedance of whatever drives the input jack. A console setting, not a program one. A fuzz face driven from an ideal source renders at constant maximum harshness; a guitar source is several kOhm.
+- `oversample` (default 1): integer sub samples per host sample. Zero order hold output (last sub sample wins); no band limiting decimator is implemented.
+
+`process(input: Float64Array): Float64Array` renders one block and returns a new array. Any block length is accepted. `reset()` clears reactive state. `telemetry()` returns per run solver census: samples, non converged, stalled, solved but flagged, per block Newton census, non finite, peak iterations, operating point failures, `operatingPointSupplyAmps`, `renderedSupplyPeakAmps` (null until a sample renders), total iterations, last failure.
+
+`setControl(id, position)` takes 0..1 and applies the program own taper. Unknown ids throw (`program has no control "NOPE"`); positions outside 0..1 throw (`control position 2 is outside 0..1`). There is no `getControl` on this class; the WASM engine has one, this class does not.
+
+## Supply control
+
+`getSupplies()` lists every addressable `dc-source` stamp as `SupplyInfo` (`address`, `positive`, `negative`, `volts`, `sourceOhms`). `big-muff-pi` reports one supply: block 0, source 0, 9 V, 1 ohm.
+
+`setSupply(addresses, volts, sourceOhms)` retargets supply stamps between `process()` calls with effect from the next sample. It validates every address before touching state, replaces the touched stamps on the runtime own copies (never the caller `Program`), rebuilds each affected block base matrix the way `prepare()` builds it, and bumps the control generation so eliminated path factorisation rebuilds. Re applying identical values rebuilds nothing. The DC operating point is deliberately not re solved and reactive state carries over.
+
+What it does not do: no mutation of the caller `Program` (two runtimes from one program never interact; a frozen program never throws), no envelope follower or waveshaper, no audio domain processing of any kind. This is the TypeScript reference runtime only.
+
+`supplyRebuilds` counts block base matrix rebuilds so far. Bad addresses throw: unknown block index, non MNA block, or missing source index, each naming the block and index. Non finite volts and negative or non finite `sourceOhms` throw.
+
+## Admission
+
+`admissionVerdict(chain, sampleRate, budget)` answers whether an ordered list of programs can be shown to fit inside a host CPU budget. Costs add across slots; a one program caller passes a one element list. The budget carries `nsPerSolve`, `nsPerMacroSample` (required; an unpriced model is refused by name, never costed at zero), `budgetedIterationsPerSample` (default 64, a sustained policy allowance, not the solver cap), and `cpuBudgetFraction` (default 1). The verdict is `{ fits: true }` or `{ fits: false, reason }` with the worst offender named by slot, block, unknowns, and nanoseconds. `predictedWorstCaseNs` returns the same sum as a number, or null when a model has no price.
+
+## Settling and measurement
+
+These render a program until its level stops moving, so startup transients are not measured as the circuit.
+
+| Name | What it is |
+| --- | --- |
+| `findSettled` | First window at which the level holds still, or null. |
+| `measureSettled` | Render until the output level stops moving and report it. |
+| `measureSettledSignal` | Driven level with the silent part removed. |
+| `measureSharedWindow` | Several drive levels over one shared settled window. |
+| `measureInputAttributable` | Per node AC attributable to the input (driven minus silent). |
+| `settledRender` | Render until still, in a value, refusal, or diverged shape. |
+| `settledLevel` | `settledRender` level as a bare number, throwing when it cannot settle. |
+| `settledSweep` | Settle once, then measure each control setting on the same runtime. |
+| `settledSweepVerified` | Sweep with one point verified against an independent render. |
+| `sweepMatchesIndependent` | Whether a sweep point matches an independent render. |
+| `sweepIsOrderIndependent` | Whether sweep order changes the result. |
+| `settleSelfCheck` | Known answer controls for the measurement primitives. |
+| `SettleOptions` | Window, consecutive, stable dB, and ladder seconds. |
+| `SETTLE_DEFAULTS` | Corpus measured defaults (0.5 s window, 2 consecutive, 0.25 dB). |
+| `SettleCriterion` | Which criterion produced a measurement. |
+| `Settled` | `{ rms, seconds }` of the settled window. |
+| `SettledMeasurement` | `{ rms, peak, settleSeconds, renderedSeconds, flatAtZero }`. |
+| `SettledRender` | Value, refusal, or diverged outcome of `settledRender`. |
+| `SettledRenderOptions` | What to render. |
+| `SettleRefusal` | Thrown by `settledLevel` instead of an unstandable level. |
+| `SharedWindowMeasurement` | One drive behaviour over the shared window. |
+| `AttributedMeasurement` | Driven level plus attributable fraction from one window. |
+| `InputAttributableNode` | One node response with and without stimulus. |
+| `FLAT_AT_ZERO_RMS` | Level below this (1e-6) is noise, not measurement. |
+| `isFlatAtZero` | Whether a level is indistinguishable from noise. |
+
+`findSettled([1, 1.001, 1.0005, 1.0001])` returns `{ rms: 1.0005, seconds: 1.5 }`; `findSettled([1, 2, 4, 8])` returns null. `measureSettled` on `big-muff-pi` at 48000 Hz with a 0.3 V 440 Hz sine reports rms about 0.2010, peak about 0.2491, settled in 1.5 s.
+
+## Chain runtime and advisories
+
+| Name | What it is |
+| --- | --- |
+| `ChainRuntime` | Ordered slots where each slot output feeds the next. |
+| `ChainSlot` | A program slot or an injected processor slot. |
+| `ChainSlotTelemetry` | One slot telemetry labelled by position. |
+| `programSlot` | A compiled circuit as a slot. |
+| `processorSlot` | An injected processor (NAM, IR, cab) as a slot. |
+| `ExternalProcessor` | A host supplied processor: NAM profile, impulse response, cab simulation. |
+| `slotContract` | The contract a slot presents to seam arithmetic. |
+| `SlotContract` | What the chain needs to know about a slot. |
+| `slotLabel` | Human readable label for a slot. |
+| `supplyGroundConflicts` | Slot pairs whose shared supply would short through grounds. |
+| `SupplyGroundConflict` | One conflicting slot pair with message. |
+| `chainAdvisories` | Seams where one side states no full scale, plus kind errors. |
+| `ChainAdvisory` | One chain problem with code, slots, and message. |
+| `chainScaleFactor` | Multiplier from two adjacent port full scales (null is unity). |
+| `chainScaleAdvisories` | Boundaries where the chain fell back to unity scaling. |
+| `ChainScaleAdvisory` | One unity fallback boundary with message. |
+| `seamScale` | Multiplier applied to the signal crossing into a slot. |
+| `seamDivider` | Resistive divider at a seam, or 1 when not computable. |
+| `dacScaleFactor` | Worklet DAC multiplier so a rail swing does not peg output. |
+| `outputDbfs` | Output level in dBFS at the DAC. |
+| `outputConversionFullScale` | Declared 0 dBFS reference where stated, else derived ceiling. |
+| `taperFraction` | Fraction of track at a 0..1 position for a taper kind. |
+| `StageCoverage` | `instrument`, `preamp`, `speaker-electrical`, or `miked`. |
+
+`ChainRuntime` gates the whole chain once against the admission budget, then prepares every slot ungated at the same rate. `process()` feeds slot outputs forward with `seamScale` between them. `setControl(slot, id, position)` addresses one slot; processor slots refuse with the slot named. `telemetry()` returns per slot telemetry, never blended.
+
+`supplyGroundConflicts([muff, rangemaster])` reports that the positive ground treble booster and the negative ground muff cannot share one supply. `chainAdvisories` reports `unscalable-seam` where a full scale is null, `speaker-signal-into-input` where a speaker terminal feeds an instrument input, `cab-after-miked`, `undividable-seam`, and `instrument-into-speaker-stage`.
+
+## WASM engine
+
+| Name | What it is |
+| --- | --- |
+| `V2WasmEngine` | Exported TypeScript wrapper around the C++ V2 console. Requires a build artifact the package does not ship; not usable from the npm package today. |
+| `getV2WasmModule` | Loads the V2 Emscripten module from the missing build artifact. |
+
+`V2WasmEngine` dynamically imports `../../build/v2_dsp.cjs`, a built artifact that is not in this repository and not in the package `files` (`dist`, `README.md`, `LICENSE.md`). From an installed tarball it fails with:
+
+```text
+Error: Cannot find module
+'/tmp/v2proof-proj/node_modules/@vessel-dsp/build/v2_dsp.cjs'
+imported from
+'/tmp/v2proof-proj/node_modules/@vessel-dsp/runtime/dist/v2-wasm-engine.js'
+```
+
+Evidence: packed the runtime and compiler tarballs, installed both with npm into an empty project under `/tmp`, and called `getV2WasmModule()` and `V2WasmEngine.create()`. Both reject with the error above; the tarball contains `dist` only, no `build` directory. The export is kept as is (removing it is an API decision for the maintainer). Two options for the maintainer: ship the built artifact in the package `files`, or drop the export.
+
+## Reference runtime surface
+
+| Name | What it is |
+| --- | --- |
+| `ReferenceRuntime` | The executable semantics of the program format. |
+| `RuntimeTelemetry` | What the solver did, so failing to solve is never silent. |
+| `RuntimeBranchCurrent` | One solved branch current per auxiliary unknown. |
+| `RuntimeNodeVoltageSnapshot` | Per block node voltages. |
+| `SupplyAddress` | `{ blockIndex, sourceIndex }` naming one `dc-source` stamp. |
+| `SupplyInfo` | Address plus the stamp own positive, negative, volts, sourceOhms. |
+| `DEFAULT_NEWTON_MAX_ITERATIONS` | How long a Newton loop may try before its iterate is the answer. |
+| `RealtimeBudget` | Host measured solve costs plus iteration and fraction policy. |
+| `AdmissionVerdict` | `{ fits: true }` or `{ fits: false, reason }`. |
+| `admissionVerdict` | Whether a chain of programs fits inside a budget. |
+| `predictedWorstCaseNs` | The admission worst case sum as a number, or null. |
+| `RuntimeError` | Thrown for misuse: no prepare, bad rate, bad control, bad supply, unimplemented operator or model. |

package/dist/admission.d.ts

@@ -0,0 +1,94 @@
+import type { Program } from "@vessel-dsp/compiler";
+/**
+ * What only a host can know, and what this repository has no honest default for.
+ *
+ * A laptop and an ESP32 differ here by orders of magnitude, and the *runtime
+ * implementation* is part of "machine" too -- this dense reference interpreter is
+ * measured at up to ~12x slower than the sparse plan it exists to be the reference for
+ * (`thoughts/shared/plans/2026-08-12-runtime-modules.md`, S3), so a constant baked in here
+ * would describe neither a real machine nor the shipped engine.
+ */
+export type RealtimeBudget = {
+    /**
+     * This host's own measured cost, in nanoseconds, of one dense solve of a system with
+     * `unknownCount` unknowns, on the hardware and engine that will actually run the
+     * program. Called once per solved block per iteration it is charged for: a linear
+     * block is charged one call (it solves once per sample), a nonlinear block is charged
+     * `budgetedIterationsPerSample` calls -- the sustained allowance, not the solver's cap.
+     */
+    readonly nsPerSolve: (unknownCount: number) => number;
+    /**
+     * This host's own measured cost, in nanoseconds, of one per-sample step of the named DSP
+     * model -- a bucket brigade's ring-buffer read and write, say. Called once per executed
+     * `macro` block per sample (a macro does not iterate; it has no Newton loop to cap).
+     *
+     * **Required, not optional, because optional is how the hole got there.** A macro block
+     * contributes nothing to `CostPredictors.solvedBlocks`, so before this existed a macro's
+     * per-sample work was costed at exactly zero and a program of nothing but macro blocks was
+     * admitted unconditionally. An optional field would restore that: every existing caller
+     * would keep omitting it and keep getting the old silent zero. A host that plays no macro
+     * program never sees this called and can write `() => 0` honestly; a host that does play
+     * one has to have measured something.
+     *
+     * Return a non-finite or negative figure and the program is **refused by model name**,
+     * rather than costed at zero -- the same fail-closed shape `requiredModels` already has at
+     * `prepare()`. "The host has no price for this algorithm" is a refusal, not a free block.
+     */
+    readonly nsPerMacroSample: (modelId: string) => number;
+    /**
+     * Newton iterations per sample this host budgets for a nonlinear block: the **sustained
+     * allowance**, not the solver's cap.
+     *
+     * Host policy, which is why it lives here beside `cpuBudgetFraction` rather than being a
+     * constant this module invents — and separate from `maxNewtonIterations`, which is a
+     * correctness bound. See the header for why they were one number and could not stay so.
+     *
+     * Defaults to 64, the value the cap supplied when the two were the same, so a host that
+     * does not set it sees no change in verdict. The corpus median is ~2.5 iterations per
+     * sample and the worst sustained figure ~9.7, so 64 is very conservative; lowering it is
+     * a host's choice about how much spike headroom to keep.
+     */
+    readonly budgetedIterationsPerSample?: number;
+    /**
+     * Fraction of one sample period (`1e9 / sampleRate` ns) this host is willing to spend
+     * on this chain, leaving headroom for whatever else its audio thread does. Defaults
+     * to 1.0 -- the whole sample period, which is optimistic for any host running more
+     * than one program at once.
+     */
+    readonly cpuBudgetFraction?: number;
+};
+/** A verdict rather than a thrown error, so the caller decides how to fail. */
+export type AdmissionVerdict = {
+    readonly fits: true;
+} | {
+    readonly fits: false;
+    readonly reason: string;
+};
+/**
+ * Whether `chain` -- an ordered list of Programs, each solved every sample -- can be shown to
+ * fit inside `budget` at `sampleRate`, given a sustained allowance of
+ * `budgetedIterationsPerSample` Newton iterations for each nonlinear block.
+ *
+ * **The allowance is a policy, not the solver's cap** -- see the header. A sample that needs
+ * more is a spike the overrun policy covers (a bounded solver and a held sample), which is
+ * why raising the cap so a legitimate 183-iteration transient can converge no longer makes
+ * every chain 16x more expensive to admit.
+ *
+ * Still fail-closed on everything it can price: a macro block is charged the host's own
+ * per-step figure, an unpriced model is refused by name, and costs add across slots.
+ *
+ * **Costs add across slots and nothing here discounts them.** There is no shared work between
+ * two slots -- each holds its own program, its own state and its own solver scratch -- so the
+ * sum is the honest model, not a conservative one.
+ */
+export declare function admissionVerdict(chain: readonly Program[], sampleRate: number, budget: RealtimeBudget): AdmissionVerdict;
+/**
+ * The same worst-case sum the gate compares, returned as a number.
+ *
+ * Exists so a measurement harness can ask what admission *predicted* and hold it against a
+ * stopwatch, rather than parsing it back out of a refusal sentence -- and so the two can only
+ * ever disagree because the model is wrong, never because they were computed differently.
+ * `null` when a declared model has no price, which is the same condition the gate refuses on.
+ */
+export declare function predictedWorstCaseNs(chain: readonly Program[], budget: RealtimeBudget): number | null;
+//# sourceMappingURL=admission.d.ts.map

package/dist/admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission.d.ts","sourceRoot":"","sources":["../src/admission.ts"],"names":[],"mappings":"AAuEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAQpD;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IACtD;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IAC9C;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,gBAAgB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AA8DrD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,GACpB,gBAAgB,CA8DlB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,MAAM,EAAE,cAAc,GACpB,MAAM,GAAG,IAAI,CAmBf"}

package/dist/admission.js

@@ -0,0 +1,209 @@
+// Real-time admission: can a compiled program -- or a whole chain of them -- be shown to fit
+// inside a host's CPU budget before it is allowed to run?
+//
+// **It takes a chain, not a program, and that is the load-bearing change.** The console runs
+// an ordered list of Programs (see `./chain.ts`), every slot solving every sample, so the
+// costs add. Gating each slot separately against the whole budget is the permissive failure:
+// three pedals each measured at 0.9x of the sample period each pass alone and together need
+// 2.7x, and the host finds out as clicks. One verdict over the whole list is the only shape
+// that can refuse that, which is why there is no single-program entry point left -- a caller
+// with one program passes a one-element list and gets an identical answer.
+//
+// The gap this closes: `Program.requiredOperators` (S1b) refuses a program a runtime
+// cannot *execute at all*, by name, at `prepare()`. Nothing stopped a program a runtime
+// *can* execute but cannot execute in time -- a packet at 350x real time loaded exactly
+// as willingly as one at 0.15x, and the difference only showed up later as held samples
+// and audible clicks, after a host had already committed to playing it. This is the same
+// refusal shape -- fail closed, name what is missing -- applied to cost instead of
+// capability.
+//
+// **The central tension this design has to hold, not paper over.** Real-time cost is not
+// a property of the program alone: it is program x machine x sample rate x block size. A
+// `.vdsp` that is playable on a laptop is not playable on an ESP32, so a portable artifact
+// cannot honestly carry "playable: true" -- there is no fact of that shape a compiler
+// could know. What it *can* carry is the rate-independent, machine-independent half:
+// `Program.costPredictors` (`../compiler/types.ts`), computed once from circuit structure
+// alone -- unknown counts, state size, block count, which blocks may iterate. The
+// machine-dependent half -- how many nanoseconds one dense solve of a given size costs on
+// THIS host's hardware and engine, and how much of the sample period this host is willing
+// to spend -- can only come from the host, which is why it is a `prepare()` argument and
+// never a default this module invents.
+//
+// **What this deliberately does not attempt.** It does not predict how many Newton
+// iterations a sample will actually need -- that is a signal- and control-position-
+// dependent number with no static derivation (`scripts/report-newton-deadline.ts` measures
+// it empirically for exactly this reason: "iteration counts are rate-independent and are
+// the right input to a CPU-budget decision, where wall-clock from the stamp interpreter is
+// not" -- true, but the counts themselves still come from running a signal through, not
+// from reading the circuit), and fabricating a bound here would be worse than omitting one.
+//
+// **It charges a BUDGETED iteration allowance, which is a policy number, and NOT the
+// solver's cap.** Those were the same number until 2026-09-09 and it was a conflation:
+// the cap is a *correctness* bound -- how long the solver may keep trying before the
+// answer it has is the answer it returns -- and the admission charge is a *cost* policy.
+// Tying them means any change to one silently rewrites the other, and it did: raising the
+// cap from 64 to 1024 so that `moogerfooger-mf-102` (183 iterations once, then 2.1 per
+// sample) and `mxr-blue-box` (356) could converge made every nonlinear block look 16x more
+// expensive here, and chains that admit today would have been refused. Neither side was
+// wrong; no single value satisfied both, which is the signature of a conflation rather than
+// a mis-tuned constant.
+//
+// **The overrun policy, which is what makes a typical-cost charge honest.** A sample that
+// needs more than the budgeted allowance is a *spike*, and a spike is not an inadmissible
+// chain -- `report-newton-deadline.ts`'s own triage says so: `peak == mean` is a fixed cost
+// to budget and ship; `peak >> mean` is "a bounded solver plus a held sample covers it, and
+// the cost is a rare tiny error rather than a dropout"; only `mean at the cap` is not a
+// real-time circuit. A rare held sample beats refusing to load, which is what a real-time
+// audio system actually does. So the charge bounds the sustained case and the cap bounds
+// the excursion, and the two no longer move together.
+//
+// Convergence and cost remain different questions: a held, unconverged sample still burns
+// CPU, so `telemetry().nonConvergedSamples` (and now `stalledSamples`) remain the *quality*
+// numbers while this stays the *cost* one.
+//
+// Fail-closed, in the sense that matters here: admission runs only when a host opts in by
+// supplying a budget (there is no honest default for a per-machine nanosecond figure), but
+// once supplied, a program that cannot be shown to fit is refused, naming the block and
+// the numbers that did not fit -- never accepted and left to glitch. A caller that
+// supplies no budget has explicitly chosen not to gate, the same way a caller that never
+// reads `telemetry()` has chosen not to look at convergence: a skipped input is a skip,
+// not a pass.
+/**
+ * The sustained allowance a host gets when it does not state one: the value the solver's cap
+ * supplied while the two were the same number, so separating them changes no verdict.
+ */
+const DEFAULT_BUDGETED_ITERATIONS = 64;
+/** Worst-case per-sample cost of every unit in one slot's program. */
+function costUnits(program, slot, budgetedIterationsPerSample, budget) {
+    const units = [];
+    for (const block of program.costPredictors.solvedBlocks) {
+        // A linear block solves once per sample; a nonlinear one is charged the sustained
+        // allowance rather than the solver's cap. See the header: the cap is a correctness
+        // bound and an excursion past the allowance is a spike the overrun policy covers,
+        // not a chain to refuse.
+        const iterations = block.linear ? 1 : budgetedIterationsPerSample;
+        units.push({
+            slot,
+            blockId: block.blockId,
+            description: `${block.unknownCount} unknowns, ${block.linear
+                ? "linear"
+                : `nonlinear, budgeted=${budgetedIterationsPerSample} it/sample`}`,
+            worstCaseNs: iterations * budget.nsPerSolve(block.unknownCount),
+        });
+    }
+    const unpriced = [];
+    for (const block of program.costPredictors.macroBlocks) {
+        const ns = budget.nsPerMacroSample(block.modelId);
+        // A host with no measured figure for this algorithm is refused by name, never costed
+        // at zero -- see `RealtimeBudget.nsPerMacroSample`. Zero itself is accepted: a host is
+        // allowed to say an algorithm is free on its hardware, and that is a claim it made.
+        if (!Number.isFinite(ns) || ns < 0) {
+            unpriced.push(block.modelId);
+            continue;
+        }
+        units.push({
+            slot,
+            blockId: block.blockId,
+            description: `DSP model "${block.modelId}", 1 step/sample`,
+            worstCaseNs: ns,
+        });
+    }
+    return { units, unpriced };
+}
+/**
+ * Whether `chain` -- an ordered list of Programs, each solved every sample -- can be shown to
+ * fit inside `budget` at `sampleRate`, given a sustained allowance of
+ * `budgetedIterationsPerSample` Newton iterations for each nonlinear block.
+ *
+ * **The allowance is a policy, not the solver's cap** -- see the header. A sample that needs
+ * more is a spike the overrun policy covers (a bounded solver and a held sample), which is
+ * why raising the cap so a legitimate 183-iteration transient can converge no longer makes
+ * every chain 16x more expensive to admit.
+ *
+ * Still fail-closed on everything it can price: a macro block is charged the host's own
+ * per-step figure, an unpriced model is refused by name, and costs add across slots.
+ *
+ * **Costs add across slots and nothing here discounts them.** There is no shared work between
+ * two slots -- each holds its own program, its own state and its own solver scratch -- so the
+ * sum is the honest model, not a conservative one.
+ */
+export function admissionVerdict(chain, sampleRate, budget) {
+    const budgetedIterationsPerSample = budget.budgetedIterationsPerSample ?? DEFAULT_BUDGETED_ITERATIONS;
+    if (!Number.isFinite(budgetedIterationsPerSample) ||
+        budgetedIterationsPerSample < 1) {
+        return {
+            fits: false,
+            reason: `budgetedIterationsPerSample must be a finite number of at least 1, got ${budgetedIterationsPerSample}`,
+        };
+    }
+    const fraction = budget.cpuBudgetFraction ?? 1;
+    if (!(fraction > 0) || fraction > 1) {
+        return {
+            fits: false,
+            reason: `cpuBudgetFraction must be in (0, 1], got ${fraction}`,
+        };
+    }
+    const nsAvailable = (1e9 / sampleRate) * fraction;
+    const costed = [];
+    const unpriced = [];
+    for (const [slot, program] of chain.entries()) {
+        const result = costUnits(program, slot, budgetedIterationsPerSample, budget);
+        costed.push(...result.units);
+        for (const modelId of result.unpriced) {
+            unpriced.push({ slot, modelId });
+        }
+    }
+    // Before the arithmetic: a chain carrying an algorithm the budget cannot price has no
+    // worst case to compare, and summing the rest would produce a number that reads like a
+    // measurement of the whole chain while omitting a slot.
+    if (unpriced.length > 0) {
+        const named = unpriced
+            .map(({ slot, modelId }) => `slot ${slot} "${modelId}"`)
+            .join(", ");
+        return {
+            fits: false,
+            reason: `chain cannot be shown to fit: the budget declares no usable per-sample cost ` +
+                `for ${unpriced.length === 1 ? "DSP model" : "DSP models"} ${named}`,
+        };
+    }
+    const worstCaseNs = costed.reduce((sum, unit) => sum + unit.worstCaseNs, 0);
+    if (worstCaseNs <= nsAvailable) {
+        return { fits: true };
+    }
+    const worst = [...costed].sort((a, b) => b.worstCaseNs - a.worstCaseNs)[0];
+    const worstDescription = worst === undefined
+        ? "no costed block"
+        : `slot ${worst.slot} block "${worst.blockId}" (${worst.description}) alone ` +
+            `costing ${worst.worstCaseNs.toFixed(0)} ns/sample`;
+    return {
+        fits: false,
+        reason: `chain of ${chain.length} program(s) cannot be shown to fit inside ` +
+            `${nsAvailable.toFixed(0)} ns/sample at ${sampleRate} Hz ` +
+            `(cpuBudgetFraction=${fraction}): worst case is ${worstCaseNs.toFixed(0)} ` +
+            `ns/sample across ${costed.length} costed block(s), worst offender ` +
+            `${worstDescription}`,
+    };
+}
+/**
+ * The same worst-case sum the gate compares, returned as a number.
+ *
+ * Exists so a measurement harness can ask what admission *predicted* and hold it against a
+ * stopwatch, rather than parsing it back out of a refusal sentence -- and so the two can only
+ * ever disagree because the model is wrong, never because they were computed differently.
+ * `null` when a declared model has no price, which is the same condition the gate refuses on.
+ */
+export function predictedWorstCaseNs(chain, budget) {
+    const budgetedIterationsPerSample = budget.budgetedIterationsPerSample ?? DEFAULT_BUDGETED_ITERATIONS;
+    let total = 0;
+    for (const [slot, program] of chain.entries()) {
+        const { units, unpriced } = costUnits(program, slot, budgetedIterationsPerSample, budget);
+        if (unpriced.length > 0) {
+            return null;
+        }
+        for (const unit of units) {
+            total += unit.worstCaseNs;
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=admission.js.map

package/dist/admission.js.map

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

package/dist/calibrate.d.ts

@@ -0,0 +1,104 @@
+import type { RealtimeBudget } from "./admission";
+/** Sizes measured when the caller states none. */
+export declare const DEFAULT_CALIBRATION_SIZES: readonly number[];
+export type CalibrateOptions = {
+    /** Factory: prepare a workload for `unknownCount` unknowns, return one solve. */
+    readonly solve: (unknownCount: number) => () => void;
+    /** System sizes to measure. Defaults to DEFAULT_CALIBRATION_SIZES. */
+    readonly sizes?: readonly number[];
+    /** Untimed solves per size before sampling. Default 50. Zero skips warmup. */
+    readonly warmupSolves?: number;
+    /** Starting solves per timed batch; grows until the clock resolves it. Default 100. */
+    readonly solvesPerSample?: number;
+    /** Timed batches per size. Default 7. */
+    readonly samples?: number;
+    /** Injected clock in nanoseconds. Default wraps `performance.now`. */
+    readonly now?: () => number;
+    /** Smallest honest clock difference in ns. Default 1000. */
+    readonly minTimerResolutionNs?: number;
+};
+export type CalibrationRow = {
+    readonly unknownCount: number;
+    /** Median ns per solve across samples, after the monotone envelope. */
+    readonly medianNsPerSolve: number;
+    /** Interquartile range over the median, before the envelope. */
+    readonly spreadFraction: number;
+    /** How many timed batches the median and spread were computed from. */
+    readonly samples: number;
+};
+export type CalibrationCorrection = {
+    readonly unknownCount: number;
+    readonly measuredNsPerSolve: number;
+    readonly correctedNsPerSolve: number;
+};
+export type ToRealtimeBudgetArgs = {
+    /**
+     * The host's own measured per-sample cost of the named DSP model.
+     * Calibration cannot measure this (it times dense solves, not models),
+     * so the host supplies it here; it is required, never defaulted, because
+     * admission refuses unpriced models and a silent zero would waive that.
+     */
+    readonly nsPerMacroSample: (modelId: string) => number;
+    /** Host policy, passed through when given; omitted otherwise. */
+    readonly budgetedIterationsPerSample?: number;
+    /** Host policy, passed through when given; omitted otherwise. */
+    readonly cpuBudgetFraction?: number;
+};
+export type CalibrationResult = {
+    readonly ok: true;
+    readonly table: readonly CalibrationRow[];
+    readonly corrections: readonly CalibrationCorrection[];
+    readonly nsPerSolve: (unknownCount: number) => number;
+    readonly toRealtimeBudget: (args: ToRealtimeBudgetArgs) => RealtimeBudget;
+};
+/** Closed reason codes; compare whole values, never message text. */
+export type CalibrationReason = "no-sizes" | "bad-size" | "zero-solves" | "timer-too-coarse" | "solve-threw" | "non-finite-time";
+export type CalibrationRefusal = {
+    readonly ok: false;
+    readonly reason: "no-sizes";
+} | {
+    readonly ok: false;
+    readonly reason: "bad-size";
+    readonly size: number;
+    readonly index: number;
+} | {
+    readonly ok: false;
+    readonly reason: "zero-solves";
+    readonly field: "warmupSolves" | "solvesPerSample" | "samples";
+    readonly value: number;
+} | {
+    readonly ok: false;
+    readonly reason: "timer-too-coarse";
+    readonly unknownCount: number;
+    readonly resolutionNs: number;
+    readonly largestBatchSolves: number;
+    readonly elapsedNs: number;
+} | {
+    readonly ok: false;
+    readonly reason: "solve-threw";
+    readonly unknownCount: number;
+    readonly thrown: unknown;
+} | {
+    readonly ok: false;
+    readonly reason: "non-finite-time";
+    readonly unknownCount: number;
+    readonly t0Ns: number;
+    readonly t1Ns: number;
+};
+/**
+ * Measure this host's dense-solve cost per unknown count. Refuses with a
+ * typed reason instead of reporting a number the inputs cannot support.
+ */
+export declare function calibrateNsPerSolve(options: CalibrateOptions): CalibrationResult | CalibrationRefusal;
+/**
+ * A TEST WORKLOAD for calibration, not a claim about the real engine. It
+ * performs one dense Gaussian elimination with partial pivoting on a fixed
+ * well-conditioned diagonally dominant n by n system in plain TypeScript,
+ * deterministically (same entries every call), with no allocation inside the
+ * timed function (all working buffers are preallocated by the factory).
+ * Later the same harness times the WebAssembly console instead; figures from
+ * this workload describe the TypeScript loop under the calibrating host and
+ * nothing else.
+ */
+export declare function denseLinearSolveWorkload(unknownCount: number): () => void;
+//# sourceMappingURL=calibrate.d.ts.map

package/dist/calibrate.d.ts.map

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