@vessel-dsp/runtime 0.2.0

package/dist/settle.d.ts

@@ -0,0 +1,359 @@
+import type { Program } from "@vessel-dsp/compiler";
+export type SettleOptions = {
+    /** Length of each measurement window, seconds. */
+    readonly windowSeconds: number;
+    /** Consecutive window pairs that must agree before the level is called settled. */
+    readonly consecutive: number;
+    /** How close two consecutive windows must be, in dB. */
+    readonly stableDb: number;
+    /** Render lengths to try in turn; the last is the giving-up point. */
+    readonly ladderSeconds: readonly number[];
+};
+/**
+ * Defaults measured against the corpus rather than chosen: 0.5 s resolves a 1.5 s settle without
+ * splitting hairs, and 0.25 dB is below the run-to-run spread.
+ *
+ * **The top rung is deliberately above anything the corpus reaches, and that is the point.** It was
+ * 16 s, justified as "covers `marshall-jcm800`, the slowest row found (settles at 16.0 s)" — which
+ * is not a bound, it is a coincidence. A ladder whose maximum equals the population maximum cannot
+ * tell *settled at the last rung* from *never settled*: both produce the same row, and jcm800's
+ * gain of 0.00 — the packet called the one real remaining amp defect all afternoon — was read at
+ * exactly that edge every time.
+ *
+ * Re-measured on a 64 s ladder, jcm800 settles at **10 s** and holds flat to five digits out to
+ * 64 s, so the diagnosis survives and the 16.0 s figure was an artifact of the two settling
+ * criteria this module used to have (see `windowLevel`). The rung is raised anyway: the reason to
+ * have headroom is not that anything needed it, it is that without it a maximum reading is
+ * ambiguous. Same argument as a screen needing a *no valid measurement* state distinct from a
+ * negative result. It costs nothing for a packet that settles earlier.
+ */
+export declare const SETTLE_DEFAULTS: SettleOptions;
+/** A level below this is numerical noise, not a measurement. */
+export declare const FLAT_AT_ZERO_RMS = 0.000001;
+/** `true` when a settled verdict cannot distinguish a dead circuit from one still coming up. */
+export declare function isFlatAtZero(rms: number): boolean;
+export type Settled = {
+    /** rms of the window the level settled in. */
+    readonly rms: number;
+    /** Seconds into the render at which it settled. */
+    readonly seconds: number;
+};
+/**
+ * The first window at which the level holds still, or `null` if it never does.
+ *
+ * Pure, so an instrument that renders its own audio — in a browser page, through the WASM console,
+ * or anywhere else this module cannot reach — can still share the policy by handing over its
+ * window levels.
+ */
+export declare function findSettled(windowRms: readonly number[], options?: SettleOptions): Settled | null;
+/**
+ * A driven level and the part of it attributable to the input, **from one shared window**.
+ *
+ * Returned as a pair on purpose. `measureSettledSignal` used to return the attributable rms
+ * alone, which left a caller wanting an attributable *fraction* to fetch the total from
+ * `measureSettled` — a separate call that settles on its **own** window. Every such pairing is
+ * one careless line from the differencing defect this module already documents, and it happened:
+ * `marshall-jcm800` was measured at **106.2% attributable**, a signal larger than its own total,
+ * hours after the same two-window error had been found and fixed at a different call site.
+ *
+ * The fix lived in a call site rather than in the shape of the measurement, so it did not
+ * transfer to the next instrument someone reached for. Handing back both numbers from the same
+ * window makes the wrong version unreachable rather than merely discouraged.
+ */
+export type AttributedMeasurement = SettledMeasurement & {
+    /** Total driven rms about its mean, over the **same** window the signal came from. */
+    readonly total: number;
+    /** `signal / total`, clamped to [0, 1]; `null` when the total is zero. */
+    readonly attributable: number | null;
+};
+export type SettledMeasurement = {
+    /** `null` when the render never settled: no level rather than a wrong one. */
+    readonly rms: number | null;
+    readonly peak: number;
+    readonly settleSeconds: number | null;
+    readonly renderedSeconds: number;
+    /** `true` when the settled level is indistinguishable from numerical noise. */
+    readonly flatAtZero: boolean;
+};
+/**
+ * Render a program until its output level stops moving, and report that level.
+ *
+ * The runtime is stateful across `process()` calls, so this walks forward through one continuous
+ * render rather than restarting per rung — which both costs less and is the only honest way to
+ * measure a circuit that is still charging.
+ *
+ * `sampleAt` is the stimulus, in volts, as a function of absolute sample index; passing the same
+ * function every instrument uses is what makes two measurements comparable.
+ */
+export declare function measureSettled(program: Program, sampleRate: number, sampleAt: (index: number) => number, options?: SettleOptions): SettledMeasurement;
+/** One node's response to the input, separated from whatever it does without one. */
+export type InputAttributableNode = {
+    readonly blockId: string;
+    readonly node: number;
+    /** Amplitude present with the stimulus but not without it. */
+    readonly signalVolts: number;
+    readonly loudVolts: number;
+    readonly silentVolts: number;
+};
+/**
+ * Per-node AC attributable to the input: render twice, once driven and once silent, and
+ * difference the two.
+ *
+ * **A plain per-node amplitude list is unreadable on anything with a mains supply.**
+ * `mesa-boogie-dual-rectifier` carries 495 V of rail ripple, which occupies the top of any such
+ * list and buries a preamp running at 132 V — the signal was invisible until the two renders were
+ * differenced, and then the fault (power-tube grids sitting on the fixed bias rail with no drive
+ * node at all) fell out in one reading. Pedals have supply ripple too, so this is not an
+ * amp-only tool.
+ *
+ * Both renders settle first, via the same policy as everything else here, because differencing
+ * two unsettled renders subtracts one transient from another.
+ */
+export declare function measureInputAttributable(program: Program, sampleRate: number, sampleAt: (index: number) => number, options?: SettleOptions): readonly InputAttributableNode[];
+/**
+ * The settled output level **attributable to the input**: render driven, render silent, subtract,
+ * and measure the remainder.
+ *
+ * **Plain output rms is a ceiling, not a level, on anything with a mains supply.** Ripple adds to
+ * the measurement, so `rms >= signal`, and by an amount that differs per packet. Every amp gain
+ * figure taken before this existed is an upper bound: a corpus "healthy band" of 19-190 was a band
+ * of ceilings, and the bimodal gap that appeared to validate the threshold was a gap between
+ * ceilings rather than between signals.
+ *
+ * The direction of the bias is the point, and it is the opposite of the one that broke the phase
+ * screen. Ripple is common-mode, so it drove *correlation* toward +1 and manufactured defects that
+ * were not there; it is additive, so it drives *magnitude* upward and hides defects that are. Same
+ * contaminant, opposite direction, because one statistic summed a phase relationship and the other
+ * a magnitude — which is what determines which way a statistic lies, not merely how much.
+ */
+/** One drive's behaviour over a window shared with every other drive in the same call. */
+export type SharedWindowMeasurement = {
+    /** rms about the mean, in volts: the audio, with any DC pedestal removed. */
+    readonly rms: number;
+    /** The pedestal itself, which is a different finding from the audio. */
+    readonly dc: number;
+    readonly peak: number;
+};
+/**
+ * Render each drive of one program to the **shared window**, keeping what it renders.
+ *
+ * **This exists because the two functions below rendered every drive twice.** Each made one pass
+ * per drive to find its settle point and a second pass per drive to capture the window -- and both
+ * passes feed the runtime an identical input, so the second recomputes exactly what the first
+ * already produced. `boss-ch-1` never settles and cost **2441 s** of one corpus run, more than any
+ * other packet, and half of that was the recomputation.
+ *
+ * **The first attempt at this was wrong, and the timing control is what said so.** It advanced
+ * every drive in lockstep and stopped only when *all* of them had settled -- which means one drive
+ * that never settles drags every other drive through the whole ladder. On `boss-sp-1-spectrum`
+ * that was **2.9x slower** than the version it replaced, reproducibly, on an idle machine. A drive
+ * that has settled must **stop**, not keep pace with the slowest one.
+ *
+ * So each drive advances on its own and stops at its own settle point, every window it renders is
+ * kept, and once the shared window is known each drive is advanced from where it stopped to that
+ * window. Per drive the render is `skip + 1` windows, which is the minimum possible: every drive
+ * has to reach the shared window, and none of it is rendered twice.
+ *
+ * **Exactness is the argument.** The runtime is deterministic and the input is identical, so the
+ * window handed back is the window the second pass would have produced, sample for sample.
+ *
+ * `settleAt[d]` is the window index **after** drive `d` settled, or -1 if it never did -- the
+ * convention the two-pass version used, so each caller keeps its own rule for a drive that never
+ * settles.
+ */
+/**
+ * Which settle criterion produced a measurement.
+ *
+ * **Recorded per row, not just per run.** With a fallback, two packets in the same run can be
+ * measured by different criteria — and a future diff that compares a `fine` row against a `coarse`
+ * row would read the criterion change as *movement*. That is the instrument-digest problem at a
+ * finer grain, and **the digest gate cannot see it**, because both criteria live in the same
+ * unchanged file. One field closes the hole before it exists.
+ */
+export type SettleCriterion = "fine" | "coarse" | "unsettled";
+/**
+ * Measure several drive levels over ONE window, after every one of them has settled.
+ *
+ * **Two drives measured at their own settle points are not two views of one state.** Mains ripple
+ * has a phase tied to absolute time, so comparing or subtracting windows captured at different
+ * offsets does not cancel it and can double it — measured directly on 2026-09-09, where letting a
+ * driven and a silent render each stop at its own settle time reported `fender-twin-reverb` with
+ * more signal than total output and `hiwatt-dr103`, then believed to be a working amp, with a
+ * signal of exactly zero.
+ *
+ * `measureSettledSignal` is the two-drive difference case of this. This exists because callers
+ * needing three or more levels — quiet, loud and silent, which is what a liveness screen compares —
+ * were otherwise reimplementing the settle-then-capture policy themselves, and **a shared policy
+ * module only helps if the callers can get what they need from it.** Every instrument that
+ * hardcoded its own render window instead was wrong by up to 42 dB on the amp corpus.
+ *
+ * The window is the latest settle point across the drives, so every render is steady across it. A
+ * drive that never settles does not veto the others: it contributes nothing to the choice of
+ * window and is reported over the same one, which is a level taken late rather than no level.
+ */
+export declare function measureSharedWindow(program: Program, sampleRate: number, sampleAt: (index: number) => number, drives: readonly number[], options?: SettleOptions): {
+    /** `null` when no drive settled at all; the measurements are then taken at the ladder's end. */
+    readonly settleSeconds: number | null;
+    readonly measurements: readonly SharedWindowMeasurement[];
+    /** Which criterion produced this row. Record it beside the verdict. */
+    readonly criterion: SettleCriterion;
+};
+export declare function measureSettledSignal(program: Program, sampleRate: number, sampleAt: (index: number) => number, options?: SettleOptions): AttributedMeasurement;
+/**
+ * Known-answer controls for the measurement primitives here.
+ *
+ * **Every measurement function should have an input whose answer is known independently of the
+ * measurement.** Today both broken instruments were in the position of never having been pointed
+ * at one: broadband plate correlation was never checked against a circuit whose phase relationship
+ * was known, and `measureSettledSignal` shipped with an alignment defect that a single identity
+ * assertion would have caught before it produced a table with more signal than total output.
+ *
+ * The identity here is the cheapest control that exists: **difference a render against itself and
+ * the answer must be exactly zero.** Any misalignment, window mismatch, or off-by-one in the sample
+ * range breaks it immediately and loudly.
+ */
+export declare function settleSelfCheck(program: Program, sampleRate: number, sampleAt: (index: number) => number, options?: SettleOptions): {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly detail: string;
+}[];
+/**
+ * The result of rendering something until it holds still, in the three-outcome shape every screen
+ * in this repo needs: a value, a refusal, or a diverged solve. Never a number it could not stand
+ * behind.
+ *
+ * It is a discriminated union rather than a nullable number **so the refusal cannot be read as a
+ * measurement by accident**: `.rms` does not exist until `status` has been narrowed, which is the
+ * compiler enforcing what a convention could only ask for.
+ */
+export type SettledRender = {
+    readonly status: "settled";
+    /** Seconds into the render at which the level stopped moving. */
+    readonly seconds: number;
+    /** rms about the mean of the settled window -- the same policy `findSettled` used. */
+    readonly rms: number;
+    readonly peak: number;
+    readonly dc: number;
+    /** The settled window's samples, so spectral work happens on settled audio. */
+    readonly tail: Float64Array;
+} | {
+    readonly status: "unsettled";
+    /** How long it rendered before giving up: the ladder's last rung. */
+    readonly triedSeconds: number;
+    /** Window levels, so a caller can see whether it was drifting or oscillating. */
+    readonly windows: readonly number[];
+} | {
+    readonly status: "nonfinite";
+    readonly atSample: number;
+};
+/** What to render. Everything is optional; the bare call renders silence. */
+export type SettledRenderOptions = {
+    readonly sampleRate?: number;
+    /** Test tone frequency. Omit or set 0 for an idle render. */
+    readonly hz?: number;
+    /** Test tone amplitude. */
+    readonly drive?: number;
+    /**
+     * A stimulus in volts as a function of absolute sample index, for anything `hz`/`drive`
+     * cannot express -- a multi-tone probe, a sweep, a recorded input. Takes precedence over
+     * `hz`/`drive`. Same shape `measureSettled` already takes, so the two stay comparable.
+     */
+    readonly sampleAt?: (index: number) => number;
+    /**
+     * Control positions to set before rendering, as `[id, position]` pairs.
+     *
+     * Here because the commonest reason to render twice is to move one knob, and a helper that
+     * cannot do that sends the caller back to `new ReferenceRuntime` -- which is the path this
+     * exists to displace. A control question is a settling question like any other:
+     * `boss-bd-2-blues-driver`'s LEVEL was called dead off a 50 ms render.
+     */
+    readonly controls?: readonly (readonly [string, number])[];
+    readonly settle?: SettleOptions;
+};
+export declare function settledRender(program: Program, options?: SettledRenderOptions): SettledRender;
+/** Thrown by `settledLevel` rather than returning a level it could not settle. */
+export declare class SettleRefusal extends Error {
+}
+/**
+ * `settledRender`'s level as a bare number, throwing rather than returning one it cannot stand
+ * behind. The one-line form for a scratch probe: `const rms = settledLevel(program)`.
+ *
+ * Throwing is the point. A scratch script that ignores a return code still reports a number; one
+ * that throws stops, which is the loud failure the three-outcome rule asks for.
+ */
+export declare function settledLevel(program: Program, options?: SettledRenderOptions): number;
+/**
+ * Settle a program once, then measure it at each control setting in turn **on the same runtime**.
+ *
+ * **Why this and not a settle-point cache.** The obvious saving is to remember each packet's
+ * settle time and skip the search, but measurement says the search is not the cost: a windowed
+ * `settledRender` runs within **3%** of a single `process()` call of the same duration, because
+ * `findSettled` already stops the moment the level holds. What costs is *rendering to settle at
+ * all*, and a fresh runtime pays the full start-up transient every time — charging supplies over
+ * ten seconds to move one knob.
+ *
+ * Continuing on a runtime that has already settled pays it once:
+ *
+ * | packet | initial settle | re-settle after a knob move |
+ * | --- | --- | --- |
+ * | `marshall-jcm800` | 10 s, 15.9 s wall | 1.5 s, 2.36 s — **6.7x cheaper** |
+ * | `hiwatt-dr103` | 9 s, 23.0 s wall | 1.5 s, 3.84 s — **6.0x cheaper** |
+ * | `orange-rockerverb` | 1.5 s | 1.5 s — 1.0x, already at the floor |
+ *
+ * The floor is `consecutive` stable windows, currently 1.5 s, so a packet that settles that fast
+ * gains nothing and loses nothing. The gain is concentrated where the expense is.
+ *
+ * **The cost of the trick, stated rather than hidden: this is order-dependent by construction.**
+ * A circuit with memory — a latch, a sag-dependent bias, an envelope with a long tail — can land
+ * somewhere different depending on which setting preceded it, where independent renders cannot.
+ * That is also *more* physical than restarting, since a real pedal is never power-cycled between
+ * knob positions. `sweepIsOrderIndependent` checks it directly by sweeping forwards and backwards,
+ * and a caller measuring a latching circuit should use `settledRender` per point instead.
+ */
+export declare function settledSweep(program: Program, points: readonly (readonly (readonly [string, number])[])[], options?: SettledRenderOptions): readonly SettledRender[];
+/**
+ * Does sharing a runtime change the answer? Compare a sweep against independent renders.
+ *
+ * **This replaces an order check, which was the wrong question.** `sweepIsOrderIndependent` asked
+ * whether sweeping forwards and backwards agreed, and on `boss-lm-2` — a limiter — it answered
+ * **true** while the sweep was wrong by **84 dB**:
+ *
+ * ```
+ * swept:       1.067e-6  1.057e-6  1.067e-6  1.058e-6
+ * independent: 1.821e-2  1.056e-6  1.821e-2  1.056e-6
+ * ```
+ *
+ * The hazard is not the *sequence* of points, it is sharing state at all. `settledSweep` settles
+ * once before the first point, and for an envelope circuit that initial settle drives the
+ * compressor into gain reduction that no later point recovers from — so every point is poisoned
+ * *equally*, forwards and backwards alike, and an order check sees perfect agreement.
+ *
+ * The only sound validation is against the thing the sweep is an optimisation of. Circuits at risk
+ * are the ones carrying state across a control change: compressors, limiters, noise gates,
+ * envelope filters, slow LFOs, anything with a long-tailed bias.
+ */
+export declare function sweepMatchesIndependent(program: Program, points: readonly (readonly (readonly [string, number])[])[], options?: SettledRenderOptions, toleranceDb?: number): boolean;
+/**
+ * **Sweep where it is safe, and fall back where it is not.**
+ *
+ * Verifies one point against an independent render — the cheapest check that can catch a shared
+ * state hazard — and re-measures the whole packet independently when they disagree. A packet that
+ * carries no state across a control change pays one extra render; one that does gets the right
+ * answer instead of a fast wrong one.
+ *
+ * The verified point is the **first**, because that is the one immediately after the shared
+ * initial settle and therefore the most exposed to it.
+ */
+export declare function settledSweepVerified(program: Program, points: readonly (readonly (readonly [string, number])[])[], options?: SettledRenderOptions, toleranceDb?: number): {
+    readonly results: readonly SettledRender[];
+    readonly shared: boolean;
+};
+/**
+ * Does this program give the same swept answers backwards as forwards?
+ *
+ * `settledSweep`'s saving comes from not restarting, which makes it order-dependent for any
+ * circuit carrying state across a control change. This is the check: sweep the points, sweep them
+ * reversed, and compare the levels. `false` means the packet needs independent renders.
+ */
+export declare function sweepIsOrderIndependent(program: Program, points: readonly (readonly (readonly [string, number])[])[], options?: SettledRenderOptions, tolerance?: number): boolean;
+//# sourceMappingURL=settle.d.ts.map

package/dist/settle.d.ts.map

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