@vessel-dsp/runtime 0.4.0 → 0.5.0

package/README.md

@@ -4,7 +4,7 @@ Headless real time MNA simulation runtime and solver console for compiled Vessel
 
 ## Install
 
-`@vessel-dsp/runtime` 0.4.0 is on npm. Use runtime 0.2.1 or later (0.3.0 adds the packaged worklet): 0.2.0 cannot load a program inside an AudioWorklet (`structuredClone` is not defined there).
+`@vessel-dsp/runtime` 0.5.0 is on npm. Use runtime 0.2.1 or later (0.3.0 adds the packaged worklet): 0.2.0 cannot load a program inside an AudioWorklet (`structuredClone` is not defined there).
 
 
 ```bash
@@ -59,7 +59,7 @@ The previous version of this example constructed `new ReferenceRuntime(program,
 - `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. A power of two of 2 or more solves the circuit at `sampleRate * oversample` behind a band-limited half-band FIR cascade: one 2x stage per factor of two, interpolating on the way up and decimating on the way down, with a fixed per-stage prototype (41 taps at Kaiser beta 6.0, then 29 at 7.0, then 21 at 6.0; stages past the table reuse the last entry). Coefficients depend on the stage only, never on the circuit. The cascade is linear phase and delays the output by 19.5 / 26.25 / 28.625 host samples at 2x / 4x / 8x (0.41 / 0.55 / 0.60 ms at 48 kHz), read back by `oversampleLatency()` (`null` before `prepare()`); `hostSampleRate()` reports the host rate. Any other factor (3, 5, ...) keeps the held path: the input sample is held flat across the sub samples and the last sub sample is the output, latency 0. Factor 1 executes the same operations in the same order as before.
 
-A standard audio-pass Newton solve of a nonlinear block starts from a self-selecting extrapolation (order 0, 1 or 2) of the block's last three converged solutions, chosen after every converged solve by scoring the three candidates against the solution in tolerance units and used only after a solve that took at most two iterations; a non-converged solve breaks the chain, and `prepare()` clears it. There is no knob: it changes which iterate inside the convergence tolerance is accepted, not the tolerance.
+At `oversample` 2 or more, a standard audio-pass Newton solve of a nonlinear block starts from a self-selecting extrapolation (order 0, 1 or 2) of the block's last three converged solutions, chosen after every converged solve by scoring the three candidates against the solution in tolerance units and used only after a solve that took at most two iterations; a non-converged solve breaks the chain, and `prepare()` clears it. **At the default factor 1 the predictor does not run:** nothing seeds and nothing records, and every solve starts from the previous solution, as in runtime 0.3.1 (it ran at every factor in 0.4.0; 0.4.1 gated it because at factor 1 it bought 2.9 % / 10.1 % fewer iterations across the pedal / amp corpus while moving `boss-dm-2` by 6.2 % of its cold-start peak). The factor is fixed by `prepare()`, so there is no switch mid run. There is no knob: it changes which iterate inside the convergence tolerance is accepted, not the tolerance.
 
 `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.
 
@@ -100,7 +100,7 @@ What it does not do: no mutation of the caller `Program` (two runtimes from one
 
 `V2WasmEngine` is the compiled C++/WASM console for the same programs. It ships in this package: `bun run --cwd packages/runtime build:wasm` (needs `em++`) writes `v2_dsp.cjs` plus `v2_dsp.wasm` to the gitignored `src/wasm/`, `build` copies them to `dist/wasm/`, and `prepack` does both, so the published tarball always carries a freshly built console. The 0.2.0 tarball is about 1.0 MB packed (3.1 MB unpacked): 2.1 MB of wasm plus about 15 KB of glue.
 
-`V2WasmEngine.create(program?)` loads the glue from the package's own `dist/wasm/` — no path to configure — and optionally loads a program. `prepare({ sampleRate, maxNewtonIterations, inputSourceOhms, oversample })` (rate defaults to 48000, `oversample` to 1, validated as on the reference console and running the same half-band cascade, latency and held-path rules), `hostSampleRate()` / `oversampleLatency()` with the reference console's names and `null`-before-`prepare()` semantics, `processSample` / `processBlock` on `Float32Array`s, `getControl` beside `setControl`, `getSupplies`/`setSupply` with the same validation and `RuntimeError` behaviour as the reference console, schedule telemetry (`getScheduleTelemetry`: solves, fallbacks, kernel solves, repivoted, abandoned, dropped blocks — a healthy packet reads zero fallbacks and zero abandoned blocks), and Newton start predictor telemetry (`getPredictorTelemetry`: `seedsUsed`, `oneIterationSolves`, `totalIterations` since `prepare()`/`reset()`; `getPredictorOrder(blockIdx)`: the order 0/1/2 the block's next solve seeds from, -1 for a bad index). The console runs the same predictor as the reference and makes the same order decision sample for sample.
+`V2WasmEngine.create(program?)` loads the glue from the package's own `dist/wasm/` — no path to configure — and optionally loads a program. `prepare({ sampleRate, maxNewtonIterations, inputSourceOhms, oversample })` (rate defaults to 48000, `oversample` to 1, validated as on the reference console and running the same half-band cascade, latency and held-path rules), `hostSampleRate()` / `oversampleLatency()` with the reference console's names and `null`-before-`prepare()` semantics, `processSample` / `processBlock` on `Float32Array`s, `getControl` beside `setControl`, `getSupplies`/`setSupply` with the same validation and `RuntimeError` behaviour as the reference console, schedule telemetry (`getScheduleTelemetry`: solves, fallbacks, kernel solves, repivoted, abandoned, dropped blocks — a healthy packet reads zero fallbacks and zero abandoned blocks), and Newton start predictor telemetry (`getPredictorTelemetry`: `seedsUsed`, `oneIterationSolves`, `totalIterations` since `prepare()`/`reset()`; `getPredictorOrder(blockIdx)`: the order 0/1/2 the block's next solve seeds from, -1 for a bad index). The console runs the same predictor as the reference, behind the same `oversample > 1` gate, and makes the same order decision sample for sample; at `oversample` 1 `seedsUsed` and `oneIterationSolves` stay 0 and `getPredictorOrder` reads 0.
 
 Native exports (the glue's `_v2_engine_*` functions) changed in runtime 0.4.0: `v2_engine_prepare` is now `(handle, sampleRate, maxNewtonIterations, inputSourceOhms, oversample)` — the `oversample` argument was added to the existing export, not shipped beside it, so a host calling the glue directly must pass it (the wrapper does). New exports: `v2_engine_get_host_sample_rate`, `v2_engine_get_oversample_latency` (doubles, -1 before prepare), `v2_engine_get_predictor_seeds`, `v2_engine_get_one_iteration_solves`, `v2_engine_get_total_iterations` (doubles), `v2_engine_get_predictor_order(handle, blockIdx)` (int32), and the test-only `v2_resample_*` / `v2_testonly_resample_*` getters the package's own tests use.
 

package/dist/reference-runtime.d.ts

@@ -425,6 +425,8 @@ export declare class ReferenceRuntime {
     private readonly limiterTrace;
     private limitedIterationCount;
     private limitedIterationPerSample;
+    /** Fold reseeds taken so far (diagnostic, read past `private` by the stall study's tracer). */
+    private foldReseedCount;
     /** Series ohms of whatever drives the input jack -- see `prepare()`'s option. */
     private inputSourceOhms;
     /**
@@ -517,6 +519,19 @@ export declare class ReferenceRuntime {
      * and the fold reseed (which reads the caller's `start`, the previous solution) are
      * untouched, so what converges is still the circuit's equations at the shipped
      * tolerances -- a different first iterate, the same fixed point.
+     *
+     * **It runs only when `prepare()` was given `oversample > 1`; at factor 1 (the default)
+     * it neither seeds nor records, so the ring stays empty and the solve is the one runtime
+     * 0.3.1 ran.** It shipped in 0.4.0 at every factor and was gated here in 0.4.1 because at
+     * factor 1 it buys little and moves the output more than that saving is worth: iterations
+     * fall 2.9 % across the pedal corpus and 10.1 % across the amps (1 kHz 0.1 V, cap 64),
+     * against `boss-dm-2` moving 6.2 % of its cold-start peak (0.5-0.8 % of the settled peak)
+     * and `boss-mt-2` stalling the WASM console permanently from 2.752 s of two-tone drive
+     * (it does not stall with the predictor off). Above 1 it stays on for every factor, the
+     * held path included (iterations on the profile packets: 2x -6..-15 %, 3x 0..-1 %, 4x
+     * -39..-47 %, 5x/6x -8..-24 %, 8x -44..-50 %; output movement at most 6e-6 relative RMS).
+     * The factor is fixed by `prepare()` (which also clears the ring), so there is no mid-run
+     * switch to reason about.
      */
     private readonly newtonStartHistory;
     private readonly blockNewtonCensus;
@@ -1057,6 +1072,17 @@ export declare class ReferenceRuntime {
      * circuit the sample loop does not solve.
      */
     private iterate;
+    /**
+     * The factor the Newton update is scaled by so that no railed op-amp's differential moves
+     * further than its step cap and no op-amp output node moves further than one full swing:
+     * the smallest `cap / |requested differential step|` and `2 * halfSwing / |requested output
+     * step|` over the block's railed op-amps, or 1. `current` is the iterate the rows were
+     * stamped at and `next` the undamped solve. The history read here is the one the stamps
+     * wrote this iteration, so `differential` is the point each row's tangent was taken at and
+     * `cap` the step the next evaluation will allow; a request inside both bounds scales nothing.
+     * Mirrored in `Engine.cpp` (`opAmpStepDamping`); the two must agree to the operation.
+     */
+    private opAmpStepDamping;
     /**
      * Build-order step 6, vertical slice: the part of a block's matrix that is the same for
      * every Newton iteration of this sample -- every stamp `newtonPortRowsOf` calls linear,

package/dist/reference-runtime.d.ts.map

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

package/dist/reference-runtime.js

@@ -599,11 +599,25 @@ function opAmpHalfSwing(railHigh, railLow) {
     return Math.max((railHigh - railLow) / 2, 1e-9);
 }
 /**
- * The op-amp's gain-bandwidth product, in hertz. A class default rather than a part fact:
- * the source's per-packet GBP is not read (see `netlist.ts`), so every op-amp in the corpus
- * gets the same pole. With a 1e5 gain the open-loop pole sits at `GBP / gain`, 10 Hz here.
+ * The gain-bandwidth product, in hertz, of an op-amp section whose stamp states none
+ * (`gainBandwidthHz: null`). Before the stamp carried the field every op-amp in every program
+ * ran this value, so a `null` section renders exactly as it always did; the compiler names the
+ * sections left on it (`opamp-gain-bandwidth-default`). With a 1e5 gain the open-loop pole sits at
+ * `GBP / gain`, 10 Hz here.
+ *
+ * A stamp that states a product runs on that product instead. Mirrored in `Engine.cpp`'s
+ * `OPAMP_DEFAULT_GAIN_BANDWIDTH_HZ`.
  */
-const OPAMP_GAIN_BANDWIDTH_HZ = 1e6;
+const OPAMP_DEFAULT_GAIN_BANDWIDTH_HZ = 1e6;
+/**
+ * The gain-bandwidth product an op-amp stamp runs on: its own, else the class default. `??` also
+ * catches `undefined`, which is what a program compiled before the field existed carries -- that
+ * program was compiled against this same default, so reading it as `null` is its meaning, not a
+ * fallback invented for it.
+ */
+function opAmpGainBandwidthHz(stamp) {
+    return stamp.gainBandwidthHz ?? OPAMP_DEFAULT_GAIN_BANDWIDTH_HZ;
+}
 /**
  * Anti-windup bound for the op-amp pole's raw state, in units of halfSwing.
  *
@@ -1354,6 +1368,8 @@ export class ReferenceRuntime {
     limiterTrace = typeof process !== "undefined" && process.env?.VESSEL_LIMITER_TRACE === "1";
     limitedIterationCount = 0;
     limitedIterationPerSample = [];
+    /** Fold reseeds taken so far (diagnostic, read past `private` by the stall study's tracer). */
+    foldReseedCount = 0;
     /** Series ohms of whatever drives the input jack -- see `prepare()`'s option. */
     inputSourceOhms = 0;
     /**
@@ -1446,6 +1462,19 @@ export class ReferenceRuntime {
      * and the fold reseed (which reads the caller's `start`, the previous solution) are
      * untouched, so what converges is still the circuit's equations at the shipped
      * tolerances -- a different first iterate, the same fixed point.
+     *
+     * **It runs only when `prepare()` was given `oversample > 1`; at factor 1 (the default)
+     * it neither seeds nor records, so the ring stays empty and the solve is the one runtime
+     * 0.3.1 ran.** It shipped in 0.4.0 at every factor and was gated here in 0.4.1 because at
+     * factor 1 it buys little and moves the output more than that saving is worth: iterations
+     * fall 2.9 % across the pedal corpus and 10.1 % across the amps (1 kHz 0.1 V, cap 64),
+     * against `boss-dm-2` moving 6.2 % of its cold-start peak (0.5-0.8 % of the settled peak)
+     * and `boss-mt-2` stalling the WASM console permanently from 2.752 s of two-tone drive
+     * (it does not stall with the predictor off). Above 1 it stays on for every factor, the
+     * held path included (iterations on the profile packets: 2x -6..-15 %, 3x 0..-1 %, 4x
+     * -39..-47 %, 5x/6x -8..-24 %, 8x -44..-50 %; output movement at most 6e-6 relative RMS).
+     * The factor is fixed by `prepare()` (which also clears the ring), so there is no mid-run
+     * switch to reason about.
      */
     newtonStartHistory = new Map();
     blockNewtonCensus = new Map();
@@ -3806,10 +3835,15 @@ export class ReferenceRuntime {
         // buffer, so a caller that still holds it (`[...guess]` in the continuation methods,
         // `previous.slice()` in `processBlock`) sees it unchanged.
         //
-        // On a standard audio pass of a nonlinear block the seed is the predicted start (see
-        // `newtonStartHistory`), falling back to `start`. `start` itself stays the previous
-        // solution for the fold reseed below.
-        const predictorPass = !dc && sourceScale === 1 && gmin === GMIN_SIEMENS && !block.linear;
+        // On a standard audio pass of a nonlinear block, and only when the runtime was prepared
+        // with `oversample > 1`, the seed is the predicted start (see `newtonStartHistory`),
+        // falling back to `start`. At factor 1 nothing seeds and nothing records. `start`
+        // itself stays the previous solution for the fold reseed below.
+        const predictorPass = this.oversample > 1 &&
+            !dc &&
+            sourceScale === 1 &&
+            gmin === GMIN_SIEMENS &&
+            !block.linear;
         const seed = (predictorPass ? this.predictedNewtonStart(block.id, size) : null) ?? start;
         for (let index = 0; index < size; index += 1) {
             solutionA[index] = seed[index] ?? 0;
@@ -3837,7 +3871,9 @@ export class ReferenceRuntime {
         let bestDelta = Number.POSITIVE_INFINITY;
         let noImprovement = 0;
         let foldStreak = 0;
-        let foldReseeded = false;
+        let foldReseeds = 0;
+        let lastWorstNode = -1;
+        let lastWorstSign = 0;
         for (let iteration = 0; iteration < iterations; iteration += 1) {
             used = iteration + 1;
             this.limitedIterate = false;
@@ -3986,6 +4022,32 @@ export class ReferenceRuntime {
                     }
                 }
             }
+            // **The op-amp step limiter damps the whole update, not only its own row's
+            // evaluation (2026-10-11).** A railed op-amp's row is a tangent of slope up to
+            // `alpha * A0` (910 at 7 MHz and 48 kHz); where a loop closes around it with net
+            // positive feedback inside one sample, the Jacobian is singular at the point of the
+            // sigmoid where `slope * beta = 1`, and a Newton step taken near it leaves the physical
+            // domain: measured on `mxr-blue-box` at 4 MHz the solved output node went to 910,
+            // -1424 and 10335 V during one rail switch, every junction downstream then walked back
+            // for hundreds of iterations, and on `boss-mt-2` at os4 the same step put -30 V on an
+            // output node at iteration 4 and 1e88 on the block by iteration 26. The limiter alone
+            // only re-evaluates the op-amp at a capped differential; the rest of the iterate keeps
+            // the explosion. Scaling the whole step by the most limited op-amp's own ratio
+            // `cap / |requested|` keeps the iterate where its tangent was taken (the limited
+            // differential is then the iterate's actual differential), and bounding the output
+            // node's move to one full swing per iteration keeps it on the sigmoid the row is a
+            // tangent of. Both are the step limiter's own numbers; an op-amp that is not limited
+            // scales nothing, so a sample that never limits takes exactly the path it always did.
+            // Transient only: at the operating point `alpha` is 1, the linear width is a hundred
+            // thousandth of the swing, and damping to that cap quenched the DC continuation
+            // (`boss-aw-2` came up with a latched envelope stage and a dead output). The DC walk
+            // has gmin and source stepping as its own safety net and is left exactly as it was.
+            const damping = dc ? 1 : this.opAmpStepDamping(block, blockIndex, current, next, dt, dc);
+            if (damping < 1) {
+                for (let i = 0; i < size; i++) {
+                    next[i] = current[i] + damping * (next[i] - current[i]);
+                }
+            }
             if (relaxing) {
                 for (let i = 0; i < size; i++) {
                     next[i] = current[i] + alpha * (next[i] - current[i]);
@@ -3994,6 +4056,22 @@ export class ReferenceRuntime {
             const delta = maxAbsDifference(next, current);
             worstNode = worstDifferenceIndex(next, current);
             worstDelta = delta;
+            // **Non-contracting means circling, not marching (2026-10-11).** The brake was fitted
+            // for an iterate that circles or stalls, and `delta` failing to fall cannot tell that
+            // from a junction walking monotonically to its solution a thermal voltage at a time,
+            // which is SPICE's normal path out of a large step. Measured on `mxr-blue-box` at
+            // 4 MHz after each rail switch: the brake latched on the switch's transient and then
+            // held a downstream NPN base at 0.2 Vt per iteration for 230 iterations of a 305-
+            // iteration solve, five times the un-damped walk. A circling iterate reverses the
+            // sign of its worst node's step; a marching one does not. So the brake engages, and
+            // tightens, only when the worst node's step has reversed since the last iteration.
+            const worstSign = Math.sign((next[worstNode] ?? 0) - (current[worstNode] ?? 0));
+            // At the operating point the brake keeps its old rule (every non-contracting iteration
+            // counts), so the DC walk every packet was validated on is untouched.
+            const reversed = dc ||
+                (worstNode === lastWorstNode && worstSign !== 0 && lastWorstSign !== 0 && worstSign !== lastWorstSign);
+            lastWorstNode = worstNode;
+            lastWorstSign = worstSign;
             if (delta < bestDelta * 0.999) {
                 bestDelta = delta;
                 noImprovement = 0;
@@ -4008,7 +4086,7 @@ export class ReferenceRuntime {
                 }
             }
             else {
-                noImprovement += 1;
+                noImprovement += reversed ? 1 : 0;
                 if (!relaxing) {
                     if (noImprovement >= NEWTON_NON_CONTRACTING_LIMIT &&
                         iteration >= NEWTON_RELAXATION_EARLIEST_ITERATION) {
@@ -4082,15 +4160,37 @@ export class ReferenceRuntime {
             // from the reset above, so it is read through its declared type.
             const limitedOpamp = this.limitedOpamp;
             foldStreak = limitedOpamp?.folded === true ? foldStreak + 1 : 0;
-            if (!dc && !foldReseeded && limitedOpamp !== null && foldStreak >= OPAMP_FOLD_STREAK) {
-                foldReseeded = true;
+            // **Re-armed, not one-shot (2026-10-11).** The reseed used to fire once per solve. On
+            // `boss-mt-2` section `+=37 -=36 out=38` -- whose non-inverting input is fed from its own
+            // output through 1 uF, so the per-sample problem has net positive feedback -- the first
+            // streak is a transient at iteration ~20 that the reseed spends, and the solve then hunts
+            // rail to rail before pinning at a turning point of the residual (`slope * beta = 1`)
+            // from iteration ~660 to the cap: step requests of -4 / +2.8 widths against a floor cap of
+            // 1/64, the Jacobian's sign flipping across one floor step, limited on 1023 of 1024
+            // iterations. That is the canary's os1 stall with the datasheet product, and main's own
+            // os4 stall at 0.666 s is the same pair of sections in the same two-cycle (the trace is in
+            // `docs/spikes/2026-10-11-opamp-gbw-stall.md`). A turning point is exactly what the
+            // halving cap cannot leave and exactly what a reseed exists for, so each fresh streak of
+            // `OPAMP_FOLD_STREAK` floor-limited iterations earns another. **The first reseed goes to
+            // the rail the sample started on, the second to the opposite one**, and so on: the
+            // start's rail is the physical continuation (a bistable stage holds its state), and a
+            // console that reaches that root directly and one that needs a reseed to reach it then
+            // agree. With the opposite rail first they did not: at os4 on `mxr-blue-box` the TS
+            // console reseeded at sample 76 and flipped rails while the WASM console converged in
+            // four iterations without one, and the two drifted apart from sample 89 (r 0.016 over
+            // the parity window). Each reseed needs its own streak, so the budget bounds the
+            // hopping. A sample that never folds takes exactly the path it always did.
+            if (!dc && limitedOpamp !== null && foldStreak >= OPAMP_FOLD_STREAK) {
+                foldReseeds += 1;
+                this.foldReseedCount += 1;
                 foldStreak = 0;
                 const wasHigh = (start[limitedOpamp.output] ?? limitedOpamp.centre) >= limitedOpamp.centre;
-                current[limitedOpamp.output] = wasHigh
-                    ? limitedOpamp.railLow
-                    : limitedOpamp.railHigh;
+                const toHigh = foldReseeds % 2 === 1 ? wasHigh : !wasHigh;
+                current[limitedOpamp.output] = toHigh
+                    ? limitedOpamp.railHigh
+                    : limitedOpamp.railLow;
                 this.opampHistory.set(limitedOpamp.key, {
-                    differential: wasHigh ? -limitedOpamp.band : limitedOpamp.band,
+                    differential: toHigh ? limitedOpamp.band : -limitedOpamp.band,
                     step: 0,
                     cap: limitedOpamp.maxStep,
                 });
@@ -4144,6 +4244,50 @@ export class ReferenceRuntime {
         }
         return { solution: current, converged, used, worstNode, worstDelta };
     }
+    /**
+     * The factor the Newton update is scaled by so that no railed op-amp's differential moves
+     * further than its step cap and no op-amp output node moves further than one full swing:
+     * the smallest `cap / |requested differential step|` and `2 * halfSwing / |requested output
+     * step|` over the block's railed op-amps, or 1. `current` is the iterate the rows were
+     * stamped at and `next` the undamped solve. The history read here is the one the stamps
+     * wrote this iteration, so `differential` is the point each row's tangent was taken at and
+     * `cap` the step the next evaluation will allow; a request inside both bounds scales nothing.
+     * Mirrored in `Engine.cpp` (`opAmpStepDamping`); the two must agree to the operation.
+     */
+    opAmpStepDamping(block, blockIndex, current, next, dt, dc) {
+        let damping = 1;
+        for (const stamp of block.stamps) {
+            if (stamp.kind !== "ideal-opamp" || stamp.railHigh === null || stamp.railLow === null) {
+                continue;
+            }
+            const history = this.opampHistory.get(packHistoryKey3(blockIndex, stamp.plus, stamp.minus, stamp.output));
+            if (history === undefined)
+                continue;
+            // The step the next evaluation will see: the band-clamped differential against the
+            // point the row was taken at. The clamp matters: a section whose real differential
+            // sits beyond the band would otherwise "request" the excess on every iteration and
+            // damp a converged solve forever (measured: `boss-od-3` at os4, every sample at the
+            // cap, when the raw differential was used here).
+            const halfSwing = opAmpHalfSwing(stamp.railHigh, stamp.railLow);
+            const alpha = dc
+                ? 1
+                : opAmpPoleAlpha(stamp.openLoopGain, opAmpGainBandwidthHz(stamp), dt, this.sampleRate);
+            const effectiveGain = alpha * stamp.openLoopGain;
+            const linearWidth = halfSwing / effectiveGain;
+            const band = OPAMP_DIFFERENTIAL_BAND * linearWidth;
+            const nextDifferential = clamp((next[stamp.plus] ?? 0) - (next[stamp.minus] ?? 0), -band, band);
+            const magnitude = Math.abs(nextDifferential - history.differential);
+            if (magnitude > history.cap) {
+                damping = Math.min(damping, history.cap / magnitude);
+            }
+            const swing = 2 * halfSwing;
+            const outputStep = Math.abs((next[stamp.output] ?? 0) - (current[stamp.output] ?? 0));
+            if (outputStep > swing) {
+                damping = Math.min(damping, swing / outputStep);
+            }
+        }
+        return damping;
+    }
     /**
      * Build-order step 6, vertical slice: the part of a block's matrix that is the same for
      * every Newton iteration of this sample -- every stamp `newtonPortRowsOf` calls linear,
@@ -4335,8 +4479,13 @@ export class ReferenceRuntime {
             }
         };
         // The predicted start (see `newtonStartHistory`), falling back to `start`: the same
-        // rule as `iterate`, applied through the port unknowns the reduced solve iterates on.
-        const predictorPass = !dc && sourceScale === 1 && gmin === GMIN_SIEMENS && !block.linear;
+        // rule and the same `oversample > 1` gate as `iterate`, applied through the port
+        // unknowns the reduced solve iterates on.
+        const predictorPass = this.oversample > 1 &&
+            !dc &&
+            sourceScale === 1 &&
+            gmin === GMIN_SIEMENS &&
+            !block.linear;
         const seed = (predictorPass ? this.predictedNewtonStart(block.id, size) : null) ?? start;
         for (let p = 0; p < portCount; p += 1) {
             scratch.yCurrent[p] = seed[portRows[p]] ?? 0;
@@ -5043,7 +5192,7 @@ export class ReferenceRuntime {
                 continue;
             }
             const key = packHistoryKey3(blockIndex, stamp.plus, stamp.minus, stamp.output);
-            const alpha = opAmpPoleAlpha(stamp.openLoopGain, OPAMP_GAIN_BANDWIDTH_HZ, dt, this.sampleRate);
+            const alpha = opAmpPoleAlpha(stamp.openLoopGain, opAmpGainBandwidthHz(stamp), dt, this.sampleRate);
             // **Bounded at ±8 halfSwings (shipped 2026-09-14, reverted once 2026-08-21).**
             // The bound is anti-windup: a real op-amp's compensation node cannot exceed its
             // supply, and at ±8 halfSwings `tanh` is `0.99999977` -- indistinguishable from
@@ -6139,14 +6288,25 @@ export class ReferenceRuntime {
                 // saturation band and step limiter are stated in.
                 const alpha = dc
                     ? 1
-                    : opAmpPoleAlpha(stamp.openLoopGain, OPAMP_GAIN_BANDWIDTH_HZ, dt, this.sampleRate);
+                    : opAmpPoleAlpha(stamp.openLoopGain, opAmpGainBandwidthHz(stamp), dt, this.sampleRate);
                 const effectiveGain = alpha * stamp.openLoopGain;
                 const linearWidth = halfSwing / effectiveGain;
                 const previous = this.opampHistory.get(opampKey);
-                const previousDifferential = previous?.differential ?? 0;
                 const rawDifferential = (solution[stamp.plus] ?? 0) - (solution[stamp.minus] ?? 0);
                 const band = OPAMP_DIFFERENTIAL_BAND * linearWidth;
                 const bounded = clamp(rawDifferential, -band, band);
+                // **The first iteration measures its step against the seed, not against zero
+                // (2026-10-11).** The history is cleared every sample, so the first iterate used to
+                // compare its differential with 0 and be "limited" whenever a section sits more than
+                // four widths from zero -- which every saturated section does, by the width of its
+                // band. The solve then re-walked that differential from zero at four widths per
+                // iteration on every sample: `electro-harmonix-slapback-echo` at 4 MHz needed exactly
+                // four iterations per sub-sample (its sections sit at the 12-width band), `boss-od-3`
+                // and `boss-pq-4` exactly three, where the predictor had been landing one. SPICE's
+                // rule is that the first iterate of a time point is limited against the previous time
+                // point's solution; that is what the seed is, so its own differential is the point
+                // the first step is measured from, and the first step is zero.
+                const previousDifferential = previous?.differential ?? bounded;
                 const step = bounded - previousDifferential;
                 const maxStep = OPAMP_MAX_DIFFERENTIAL_STEP * linearWidth;
                 const reversing = previous !== undefined &&
@@ -6184,9 +6344,25 @@ export class ReferenceRuntime {
                     ? Math.max(previousCap / 2, linearWidth / 64)
                     : Math.min(maxStep, previousCap * 1.2);
                 const limited = Math.abs(step) > cap;
+                // A fold is the cap pinned at its floor **with the iterate moving at the floor's
+                // scale**, whether or not this particular step overran the cap: once the update is
+                // damped to the cap (see `opAmpStepDamping`) a trapped iterate's steps equal the cap
+                // rather than exceed it, so a streak counted on `limited` alone never forms (measured
+                // 2026-10-11: `boss-mt-2` sample 4990, 1024 iterations with the cap at the floor on
+                // 1015 of them and the limiter flagged on 372). The step-size test is what keeps an
+                // idle section out of it: a section whose differential merely jitters by 1e-6 widths
+                // reverses sign every iteration too, its cap collapses to the floor the same way, and
+                // without the test it was reseeded onto a rail it had no business on (`boss-aw-2`,
+                // sample 1489: 527 iterations and a latched output where the product tree took 4).
+                // A quarter of the floor cap (`linearWidth / 64`) is the scale: a trapped iterate
+                // moves by the cap, or by less when another section's ratio damped the update (the
+                // mt-2 pair s87/s88 fold together), and jitter is four orders below it.
+                const folded = cap <= linearWidth / 8 && Math.abs(step) >= linearWidth / 256;
                 if (limited) {
                     this.limitedIterate = true;
                     this.limitedBy = `opamp +=${stamp.plus} -=${stamp.minus} out=${stamp.output}`;
+                }
+                if (limited || folded) {
                     this.limitedOpamp = {
                         key: opampKey,
                         output: stamp.output,
@@ -6195,7 +6371,7 @@ export class ReferenceRuntime {
                         railLow: stamp.railLow,
                         band,
                         maxStep,
-                        folded: cap <= linearWidth / 8,
+                        folded,
                     };
                 }
                 const differential = limited
@@ -6231,11 +6407,26 @@ export class ReferenceRuntime {
                 // advance's comment and `docs/troubleshootings/...saturated-opamp-row...md`).
                 const derivativeShape = Math.tanh(clamp(scaled, -OPAMP_SATURATION_BAND, OPAMP_SATURATION_BAND));
                 const slope = effectiveGain * (1 - derivativeShape * derivativeShape);
-                // Linearised: Vout - slope * Vdiff = Vout0 - slope * Vdiff0.
+                // Linearised: Vout - slope * Vdiff = Vout0 - slope * Vdiff0, with Vdiff0 the point the
+                // tangent is taken at. While the step limiter is active that point is the limited
+                // differential (SPICE's rule: evaluate at the damped step, let the unknown be free).
+                // When it is not, the point is the **actual previous differential**, even when that
+                // lies beyond the band `differential` was clamped to -- the value `output` is still
+                // the band's, which is the model, but the tangent must pass through the iterate or the
+                // fixed point is not the model: with `Vdiff0 = bounded` the row converges to
+                // `f(band) + slope * (Vdiff - band)`, an output off its rail by the leak
+                // `slope * excess`, and `slope` grows with the gain-bandwidth product. Measured
+                // 2026-10-11 on `mxr-blue-box` at 4 MHz: the op-amp's own output 0.003 V against a
+                // 0 V rail while the solved node sat at -0.290 V, and the two NPN stages it drives
+                // spent 300 iterations walking out of the junction state that sub-rail voltage put
+                // them in (`docs/spikes/2026-10-11-opamp-gbw-stall.md`). At the fixed point
+                // `Vdiff == rawDifferential`, so the row reads `Vout = output` exactly, on or beyond
+                // the band; inside the band `rawDifferential == bounded` and nothing changes.
+                const linearisedAt = limited ? differential : rawDifferential;
                 matrix[row][stamp.output] += 1;
                 matrix[row][stamp.plus] -= slope;
                 matrix[row][stamp.minus] += slope;
-                rhs[row] = output - slope * differential;
+                rhs[row] = output - slope * linearisedAt;
                 break;
             }
             case "vccs": {