@vessel-dsp/runtime 0.3.1 → 0.4.0

package/dist/worklet/v2-audio-worklet.js

@@ -575,34 +575,47 @@ var require_v2_dsp = __commonJS({
         var _v2_engine_create = Module["_v2_engine_create"] = () => (_v2_engine_create = Module["_v2_engine_create"] = wasmExports["g"])();
         var _v2_engine_destroy = Module["_v2_engine_destroy"] = (a0) => (_v2_engine_destroy = Module["_v2_engine_destroy"] = wasmExports["h"])(a0);
         var _v2_engine_load_json = Module["_v2_engine_load_json"] = (a0, a1) => (_v2_engine_load_json = Module["_v2_engine_load_json"] = wasmExports["i"])(a0, a1);
-        var _v2_engine_prepare = Module["_v2_engine_prepare"] = (a0, a1, a2, a3) => (_v2_engine_prepare = Module["_v2_engine_prepare"] = wasmExports["j"])(a0, a1, a2, a3);
-        var _v2_engine_reset = Module["_v2_engine_reset"] = (a0) => (_v2_engine_reset = Module["_v2_engine_reset"] = wasmExports["k"])(a0);
-        var _v2_engine_set_control = Module["_v2_engine_set_control"] = (a0, a1, a2) => (_v2_engine_set_control = Module["_v2_engine_set_control"] = wasmExports["l"])(a0, a1, a2);
-        var _v2_engine_get_control = Module["_v2_engine_get_control"] = (a0, a1) => (_v2_engine_get_control = Module["_v2_engine_get_control"] = wasmExports["m"])(a0, a1);
-        var _v2_engine_set_supply = Module["_v2_engine_set_supply"] = (a0, a1, a2, a3, a4) => (_v2_engine_set_supply = Module["_v2_engine_set_supply"] = wasmExports["n"])(a0, a1, a2, a3, a4);
-        var _v2_engine_process_sample = Module["_v2_engine_process_sample"] = (a0, a1) => (_v2_engine_process_sample = Module["_v2_engine_process_sample"] = wasmExports["o"])(a0, a1);
-        var _v2_engine_process_block = Module["_v2_engine_process_block"] = (a0, a1, a2, a3) => (_v2_engine_process_block = Module["_v2_engine_process_block"] = wasmExports["p"])(a0, a1, a2, a3);
-        var _v2_engine_get_input_buffer = Module["_v2_engine_get_input_buffer"] = (a0, a1) => (_v2_engine_get_input_buffer = Module["_v2_engine_get_input_buffer"] = wasmExports["q"])(a0, a1);
-        var _v2_engine_get_output_buffer = Module["_v2_engine_get_output_buffer"] = (a0, a1) => (_v2_engine_get_output_buffer = Module["_v2_engine_get_output_buffer"] = wasmExports["r"])(a0, a1);
-        var _v2_engine_process_internal = Module["_v2_engine_process_internal"] = (a0, a1) => (_v2_engine_process_internal = Module["_v2_engine_process_internal"] = wasmExports["s"])(a0, a1);
-        var _v2_engine_get_last_iteration_count = Module["_v2_engine_get_last_iteration_count"] = (a0) => (_v2_engine_get_last_iteration_count = Module["_v2_engine_get_last_iteration_count"] = wasmExports["t"])(a0);
-        var _v2_engine_get_last_converged = Module["_v2_engine_get_last_converged"] = (a0) => (_v2_engine_get_last_converged = Module["_v2_engine_get_last_converged"] = wasmExports["u"])(a0);
-        var _v2_engine_get_max_iterations = Module["_v2_engine_get_max_iterations"] = (a0) => (_v2_engine_get_max_iterations = Module["_v2_engine_get_max_iterations"] = wasmExports["v"])(a0);
-        var _v2_engine_get_operating_point = Module["_v2_engine_get_operating_point"] = (a0, a1, a2) => (_v2_engine_get_operating_point = Module["_v2_engine_get_operating_point"] = wasmExports["w"])(a0, a1, a2);
-        var _v2_engine_get_state = Module["_v2_engine_get_state"] = (a0, a1, a2) => (_v2_engine_get_state = Module["_v2_engine_get_state"] = wasmExports["x"])(a0, a1, a2);
-        var _v2_engine_get_last_error = Module["_v2_engine_get_last_error"] = (a0) => (_v2_engine_get_last_error = Module["_v2_engine_get_last_error"] = wasmExports["y"])(a0);
-        var _v2_engine_get_schedule_solves = Module["_v2_engine_get_schedule_solves"] = (a0) => (_v2_engine_get_schedule_solves = Module["_v2_engine_get_schedule_solves"] = wasmExports["z"])(a0);
-        var _v2_engine_get_schedule_fallbacks = Module["_v2_engine_get_schedule_fallbacks"] = (a0) => (_v2_engine_get_schedule_fallbacks = Module["_v2_engine_get_schedule_fallbacks"] = wasmExports["A"])(a0);
-        var _v2_engine_get_kernel_solves = Module["_v2_engine_get_kernel_solves"] = (a0) => (_v2_engine_get_kernel_solves = Module["_v2_engine_get_kernel_solves"] = wasmExports["B"])(a0);
-        var _v2_engine_get_repivoted_schedule_blocks = Module["_v2_engine_get_repivoted_schedule_blocks"] = (a0) => (_v2_engine_get_repivoted_schedule_blocks = Module["_v2_engine_get_repivoted_schedule_blocks"] = wasmExports["C"])(a0);
-        var _v2_engine_get_abandoned_schedule_blocks = Module["_v2_engine_get_abandoned_schedule_blocks"] = (a0) => (_v2_engine_get_abandoned_schedule_blocks = Module["_v2_engine_get_abandoned_schedule_blocks"] = wasmExports["D"])(a0);
-        var _v2_engine_get_dropped_schedule_blocks = Module["_v2_engine_get_dropped_schedule_blocks"] = (a0) => (_v2_engine_get_dropped_schedule_blocks = Module["_v2_engine_get_dropped_schedule_blocks"] = wasmExports["E"])(a0);
-        var _malloc = Module["_malloc"] = (a0) => (_malloc = Module["_malloc"] = wasmExports["F"])(a0);
-        var _free = Module["_free"] = (a0) => (_free = Module["_free"] = wasmExports["G"])(a0);
-        var ___trap = () => (___trap = wasmExports["H"])();
-        var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports["I"])(a0);
-        var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports["J"])(a0);
-        var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["K"])();
+        var _v2_engine_prepare = Module["_v2_engine_prepare"] = (a0, a1, a2, a3, a4) => (_v2_engine_prepare = Module["_v2_engine_prepare"] = wasmExports["j"])(a0, a1, a2, a3, a4);
+        var _v2_engine_get_host_sample_rate = Module["_v2_engine_get_host_sample_rate"] = (a0) => (_v2_engine_get_host_sample_rate = Module["_v2_engine_get_host_sample_rate"] = wasmExports["k"])(a0);
+        var _v2_engine_get_oversample_latency = Module["_v2_engine_get_oversample_latency"] = (a0) => (_v2_engine_get_oversample_latency = Module["_v2_engine_get_oversample_latency"] = wasmExports["l"])(a0);
+        var _v2_resample_stage_count = Module["_v2_resample_stage_count"] = () => (_v2_resample_stage_count = Module["_v2_resample_stage_count"] = wasmExports["m"])();
+        var _v2_resample_prototype_length = Module["_v2_resample_prototype_length"] = (a0) => (_v2_resample_prototype_length = Module["_v2_resample_prototype_length"] = wasmExports["n"])(a0);
+        var _v2_resample_prototype_tap = Module["_v2_resample_prototype_tap"] = (a0, a1) => (_v2_resample_prototype_tap = Module["_v2_resample_prototype_tap"] = wasmExports["o"])(a0, a1);
+        var _v2_testonly_resample_create = Module["_v2_testonly_resample_create"] = (a0) => (_v2_testonly_resample_create = Module["_v2_testonly_resample_create"] = wasmExports["p"])(a0);
+        var _v2_testonly_resample_reset = Module["_v2_testonly_resample_reset"] = (a0) => (_v2_testonly_resample_reset = Module["_v2_testonly_resample_reset"] = wasmExports["q"])(a0);
+        var _v2_testonly_resample_process = Module["_v2_testonly_resample_process"] = (a0, a1) => (_v2_testonly_resample_process = Module["_v2_testonly_resample_process"] = wasmExports["r"])(a0, a1);
+        var _v2_testonly_resample_destroy = Module["_v2_testonly_resample_destroy"] = (a0) => (_v2_testonly_resample_destroy = Module["_v2_testonly_resample_destroy"] = wasmExports["s"])(a0);
+        var _v2_engine_reset = Module["_v2_engine_reset"] = (a0) => (_v2_engine_reset = Module["_v2_engine_reset"] = wasmExports["t"])(a0);
+        var _v2_engine_set_control = Module["_v2_engine_set_control"] = (a0, a1, a2) => (_v2_engine_set_control = Module["_v2_engine_set_control"] = wasmExports["u"])(a0, a1, a2);
+        var _v2_engine_get_control = Module["_v2_engine_get_control"] = (a0, a1) => (_v2_engine_get_control = Module["_v2_engine_get_control"] = wasmExports["v"])(a0, a1);
+        var _v2_engine_set_supply = Module["_v2_engine_set_supply"] = (a0, a1, a2, a3, a4) => (_v2_engine_set_supply = Module["_v2_engine_set_supply"] = wasmExports["w"])(a0, a1, a2, a3, a4);
+        var _v2_engine_process_sample = Module["_v2_engine_process_sample"] = (a0, a1) => (_v2_engine_process_sample = Module["_v2_engine_process_sample"] = wasmExports["x"])(a0, a1);
+        var _v2_engine_process_block = Module["_v2_engine_process_block"] = (a0, a1, a2, a3) => (_v2_engine_process_block = Module["_v2_engine_process_block"] = wasmExports["y"])(a0, a1, a2, a3);
+        var _v2_engine_get_input_buffer = Module["_v2_engine_get_input_buffer"] = (a0, a1) => (_v2_engine_get_input_buffer = Module["_v2_engine_get_input_buffer"] = wasmExports["z"])(a0, a1);
+        var _v2_engine_get_output_buffer = Module["_v2_engine_get_output_buffer"] = (a0, a1) => (_v2_engine_get_output_buffer = Module["_v2_engine_get_output_buffer"] = wasmExports["A"])(a0, a1);
+        var _v2_engine_process_internal = Module["_v2_engine_process_internal"] = (a0, a1) => (_v2_engine_process_internal = Module["_v2_engine_process_internal"] = wasmExports["B"])(a0, a1);
+        var _v2_engine_get_last_iteration_count = Module["_v2_engine_get_last_iteration_count"] = (a0) => (_v2_engine_get_last_iteration_count = Module["_v2_engine_get_last_iteration_count"] = wasmExports["C"])(a0);
+        var _v2_engine_get_last_converged = Module["_v2_engine_get_last_converged"] = (a0) => (_v2_engine_get_last_converged = Module["_v2_engine_get_last_converged"] = wasmExports["D"])(a0);
+        var _v2_engine_get_max_iterations = Module["_v2_engine_get_max_iterations"] = (a0) => (_v2_engine_get_max_iterations = Module["_v2_engine_get_max_iterations"] = wasmExports["E"])(a0);
+        var _v2_engine_get_operating_point = Module["_v2_engine_get_operating_point"] = (a0, a1, a2) => (_v2_engine_get_operating_point = Module["_v2_engine_get_operating_point"] = wasmExports["F"])(a0, a1, a2);
+        var _v2_engine_get_state = Module["_v2_engine_get_state"] = (a0, a1, a2) => (_v2_engine_get_state = Module["_v2_engine_get_state"] = wasmExports["G"])(a0, a1, a2);
+        var _v2_engine_get_last_error = Module["_v2_engine_get_last_error"] = (a0) => (_v2_engine_get_last_error = Module["_v2_engine_get_last_error"] = wasmExports["H"])(a0);
+        var _v2_engine_get_schedule_solves = Module["_v2_engine_get_schedule_solves"] = (a0) => (_v2_engine_get_schedule_solves = Module["_v2_engine_get_schedule_solves"] = wasmExports["I"])(a0);
+        var _v2_engine_get_schedule_fallbacks = Module["_v2_engine_get_schedule_fallbacks"] = (a0) => (_v2_engine_get_schedule_fallbacks = Module["_v2_engine_get_schedule_fallbacks"] = wasmExports["J"])(a0);
+        var _v2_engine_get_predictor_seeds = Module["_v2_engine_get_predictor_seeds"] = (a0) => (_v2_engine_get_predictor_seeds = Module["_v2_engine_get_predictor_seeds"] = wasmExports["K"])(a0);
+        var _v2_engine_get_one_iteration_solves = Module["_v2_engine_get_one_iteration_solves"] = (a0) => (_v2_engine_get_one_iteration_solves = Module["_v2_engine_get_one_iteration_solves"] = wasmExports["L"])(a0);
+        var _v2_engine_get_total_iterations = Module["_v2_engine_get_total_iterations"] = (a0) => (_v2_engine_get_total_iterations = Module["_v2_engine_get_total_iterations"] = wasmExports["M"])(a0);
+        var _v2_engine_get_predictor_order = Module["_v2_engine_get_predictor_order"] = (a0, a1) => (_v2_engine_get_predictor_order = Module["_v2_engine_get_predictor_order"] = wasmExports["N"])(a0, a1);
+        var _v2_engine_get_kernel_solves = Module["_v2_engine_get_kernel_solves"] = (a0) => (_v2_engine_get_kernel_solves = Module["_v2_engine_get_kernel_solves"] = wasmExports["O"])(a0);
+        var _v2_engine_get_repivoted_schedule_blocks = Module["_v2_engine_get_repivoted_schedule_blocks"] = (a0) => (_v2_engine_get_repivoted_schedule_blocks = Module["_v2_engine_get_repivoted_schedule_blocks"] = wasmExports["P"])(a0);
+        var _v2_engine_get_abandoned_schedule_blocks = Module["_v2_engine_get_abandoned_schedule_blocks"] = (a0) => (_v2_engine_get_abandoned_schedule_blocks = Module["_v2_engine_get_abandoned_schedule_blocks"] = wasmExports["Q"])(a0);
+        var _v2_engine_get_dropped_schedule_blocks = Module["_v2_engine_get_dropped_schedule_blocks"] = (a0) => (_v2_engine_get_dropped_schedule_blocks = Module["_v2_engine_get_dropped_schedule_blocks"] = wasmExports["R"])(a0);
+        var _malloc = Module["_malloc"] = (a0) => (_malloc = Module["_malloc"] = wasmExports["S"])(a0);
+        var _free = Module["_free"] = (a0) => (_free = Module["_free"] = wasmExports["T"])(a0);
+        var ___trap = () => (___trap = wasmExports["U"])();
+        var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports["V"])(a0);
+        var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports["W"])(a0);
+        var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["X"])();
         Module["ccall"] = ccall;
         Module["cwrap"] = cwrap;
         Module["setValue"] = setValue;
@@ -862,7 +875,7 @@ function slotLabel(slot, index) {
   return slot.kind === "processor" ? `slot ${index} (${slot.processor.id})` : `slot ${index}`;
 }
 
-// src/numeric-pivot.ts
+// ../compiler/src/sparse-schedule.ts
 var NUMERIC_REPIVOT_TAU = 1e-3;
 function computeNumericRepivot(schedule, size, matrix, tau = NUMERIC_REPIVOT_TAU) {
   const rows = Array.from({ length: size }, () => /* @__PURE__ */ new Set());
@@ -1027,6 +1040,132 @@ function computeNumericRepivot(schedule, size, matrix, tau = NUMERIC_REPIVOT_TAU
   };
 }
 
+// src/resample.ts
+var RESAMPLE_STAGE_SPECS = [
+  [41, 6],
+  [29, 7],
+  [21, 6]
+];
+function resampleStageSpec(index) {
+  return RESAMPLE_STAGE_SPECS[Math.min(index, RESAMPLE_STAGE_SPECS.length - 1)];
+}
+var RESAMPLE_KAISER_BETA = 8.3;
+function besselI0(x) {
+  let sum = 1;
+  let term = 1;
+  const half = x * x / 4;
+  for (let k = 1; k <= 32; k += 1) {
+    term *= half / (k * k);
+    sum += term;
+    if (term < 1e-17 * sum) break;
+  }
+  return sum;
+}
+function designHalfBand2x(taps = 57, beta = RESAMPLE_KAISER_BETA) {
+  if (!Number.isInteger(taps) || taps < 9 || taps % 4 !== 1) {
+    throw new Error(
+      `half-band prototype needs an odd tap count of 1 mod 4 (got ${String(taps)})`
+    );
+  }
+  const center = (taps - 1) / 2;
+  const denom = besselI0(beta);
+  const out = new Float64Array(taps);
+  for (let i = 0; i < taps; i += 1) {
+    const d = i - center;
+    const r = d / center;
+    const window2 = besselI0(beta * Math.sqrt(Math.max(0, 1 - r * r))) / denom;
+    if (d === 0) {
+      out[i] = 0.5;
+    } else if (d % 2 === 0) {
+      out[i] = 0;
+    } else {
+      out[i] = window2 * Math.sin(Math.PI * d / 2) / (Math.PI * d);
+    }
+  }
+  let oddSum = 0;
+  for (let i = 1; i < taps; i += 2) oddSum += out[i];
+  const scale = 0.5 / oddSum;
+  for (let i = 1; i < taps; i += 2) out[i] = out[i] * scale;
+  out[center] = 0.5;
+  return out;
+}
+var HalfBandStage2x = class {
+  odd;
+  /** Input samples of history behind the even (passthrough) output. */
+  upDelay;
+  /** Group delay in high-rate samples, each direction. */
+  delayHighRate;
+  histUp;
+  histDown;
+  constructor(prototype) {
+    const taps = prototype.length;
+    if (taps % 4 !== 1 || taps < 9) {
+      throw new Error(
+        `half-band stage needs a 1-mod-4 prototype (got ${taps})`
+      );
+    }
+    const center = (taps - 1) / 2;
+    if (prototype[center] !== 0.5) {
+      throw new Error("half-band prototype center tap must be exactly 0.5");
+    }
+    const oddCount = (taps - 1) / 2;
+    const odd = new Float64Array(oddCount);
+    for (let j = 0; j < oddCount; j += 1)
+      odd[j] = prototype[2 * j + 1];
+    this.odd = odd;
+    this.upDelay = center / 2;
+    this.delayHighRate = center;
+    this.histUp = new Float64Array(oddCount);
+    this.histDown = new Float64Array(taps);
+  }
+  /** Zero both histories. */
+  reset() {
+    this.histUp.fill(0);
+    this.histDown.fill(0);
+  }
+  /**
+   * Interpolate one input sample into two: `out[at]` is the delayed input
+   * itself (bit-exact, coefficient 1), `out[at+1]` the filtered midpoint.
+   */
+  interpolate(x, out, at) {
+    this.histUp.copyWithin(1, 0, this.histUp.length - 1);
+    this.histUp[0] = x;
+    out[at] = this.histUp[this.upDelay];
+    let mid = 0;
+    const odd = this.odd;
+    for (let j = 0; j < odd.length; j += 1) {
+      mid += odd[j] * this.histUp[j];
+    }
+    out[at + 1] = 2 * mid;
+  }
+  /**
+   * Decimate a consecutive pair (`first` older, `second` newer) to one
+   * sample at gain 1.
+   */
+  decimate(first, second) {
+    this.histDown.copyWithin(2, 0, this.histDown.length - 2);
+    this.histDown[0] = second;
+    this.histDown[1] = first;
+    let acc = 0.5 * this.histDown[this.delayHighRate];
+    const odd = this.odd;
+    for (let j = 0; j < odd.length; j += 1) {
+      acc += odd[j] * this.histDown[2 * j + 1];
+    }
+    return acc;
+  }
+};
+function cascadeLatencyHostSamples(stages) {
+  if (!Number.isInteger(stages) || stages < 1) {
+    throw new Error(`resampler cascade needs a positive integer stage count (got ${String(stages)})`);
+  }
+  let total = 0;
+  for (let s = 0; s < stages; s += 1) {
+    const center = (resampleStageSpec(s)[0] - 1) / 2;
+    total += (2 * center - 1) / 2 ** (s + 1);
+  }
+  return total;
+}
+
 // src/taper.ts
 function taperFraction(taper, position) {
   const x = Math.min(1, Math.max(0, position));
@@ -1520,6 +1659,20 @@ var ReferenceRuntime = class {
    * correct at the sub-sample rate. `hostSampleRate()` is the rate a caller passed in.
    */
   oversample = 1;
+  /**
+   * Band-limited resampling around the solver, one 2x half-band stage per
+   * entry, cascaded for 4x and 8x. Empty unless `oversample` is a power of
+   * two greater than 1; any other factor keeps the legacy hold-and-last
+   * path below. Built fresh (zero state) in `prepare()`, so the filter
+   * state never leaks across renders and block splits stay bit-identical.
+   */
+  resampleUp = [];
+  resampleDown = [];
+  /** Scratch for the sub-sample streams, sized to `oversample` in `prepare()`. */
+  resampleBufA = new Float64Array(0);
+  resampleBufB = new Float64Array(0);
+  /** Total resampler group delay in host samples (0 on the legacy path). */
+  resampleLatencyHost = 0;
   positions = /* @__PURE__ */ new Map();
   lastShiftedSample = /* @__PURE__ */ new Map();
   /**
@@ -1760,6 +1913,37 @@ var ReferenceRuntime = class {
    * samples 4800 of 4800 -> 22.
    */
   unproductiveUntilSample = /* @__PURE__ */ new Map();
+  /**
+   * Per block, the last three converged sub-sample solutions and the extrapolation order
+   * that would have predicted the newest of them best, for the Newton start predictor.
+   *
+   * **The start of a Newton solve is a guess, and the previous solution is only the
+   * cheapest guess, not the best one.** At 4x oversampling the circuit moves a quarter as
+   * far per solve, and a quadratic extrapolation of the last three solutions lands inside
+   * the convergence tolerance on most sub-samples, so the first Newton step is already the
+   * answer and the check that follows it is the whole solve: one iteration where the
+   * previous-solution start needs two (one step, one check). Measured 2026-10-09 on the six
+   * profile packets at os4 (`docs/spikes/2026-10-09-newton-iteration-budget.md`): iterations
+   * per host sample fall 38-47 % on the pedals with every converged solution within 0.02
+   * tolerance units of the full-Newton solution from the same state.
+   *
+   * **The order is chosen by the block's own history, not by a constant.** After every
+   * converged solve the three candidate starts the history could have produced (order 0 =
+   * the previous solution, 1 = linear, 2 = quadratic) are scored against the solution just
+   * reached, in tolerance units, and the best one is used for the next solve -- but only
+   * when that solve took at most two iterations (the floor: one step and one check). A
+   * solve that needed more was hunting across a knee, and there a closer start is not a
+   * cheaper one (`recordNewtonSolution` has the measurement). On a hard edge the
+   * extrapolations overshoot the clipping knee and score worse than the previous solution,
+   * so the next solve starts exactly where it always did; on a signal it cannot predict it
+   * costs nothing. A non-converged solve breaks the chain (no history to extrapolate from).
+   *
+   * Only the start moves. The convergence test, the limiter histories, the relaxation rule
+   * 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.
+   */
+  newtonStartHistory = /* @__PURE__ */ new Map();
   blockNewtonCensus = /* @__PURE__ */ new Map();
   totalIterations = 0;
   nonFiniteSamples = 0;
@@ -2001,6 +2185,28 @@ var ReferenceRuntime = class {
     }
     this.oversample = oversample;
     this.sampleRate = sampleRate2 * oversample;
+    const resampleStages = Math.log2(oversample);
+    if (Number.isInteger(resampleStages) && resampleStages >= 1) {
+      const prototypes = Array.from({ length: resampleStages }, (_, stage) => {
+        const [taps, beta] = resampleStageSpec(stage);
+        return designHalfBand2x(taps, beta);
+      });
+      this.resampleUp = prototypes.map(
+        (prototype) => new HalfBandStage2x(prototype)
+      );
+      this.resampleDown = prototypes.map(
+        (prototype) => new HalfBandStage2x(prototype)
+      );
+      this.resampleBufA = new Float64Array(oversample);
+      this.resampleBufB = new Float64Array(oversample);
+      this.resampleLatencyHost = cascadeLatencyHostSamples(resampleStages);
+    } else {
+      this.resampleUp = [];
+      this.resampleDown = [];
+      this.resampleBufA = new Float64Array(0);
+      this.resampleBufB = new Float64Array(0);
+      this.resampleLatencyHost = 0;
+    }
     this.maxNewtonIterations = maxNewtonIterations;
     this.inputSourceOhms = Math.max(0, options.inputSourceOhms ?? 0);
     this.timeSeconds = 0;
@@ -2016,6 +2222,7 @@ var ReferenceRuntime = class {
     this.solvedButFlaggedSamples = 0;
     this.blockNewtonCensus.clear();
     this.unproductiveUntilSample.clear();
+    this.newtonStartHistory.clear();
     this.totalIterations = 0;
     this.nonFiniteSamples = 0;
     this.peakIterations = 0;
@@ -2749,7 +2956,8 @@ var ReferenceRuntime = class {
       values: new Float64Array(schedule.slots),
       rhs: new Float64Array(size),
       factors: new Float64Array(schedule.factorCount),
-      consecutiveFallbacks: 0
+      consecutiveFallbacks: 0,
+      repivotAttempted: false
     });
   }
   /**
@@ -2863,6 +3071,16 @@ var ReferenceRuntime = class {
   * smallest dropped disagreement is `boss-aw-2` at `9.8e+3`. Dense is not
   * assumed right -- `tw-1` diverges on 61 samples densely while converging
   * sparsely -- the gate only fires where the replay demonstrably collapses.
+  *
+  * A validating shipped order is still replaced when the value-aware candidate
+  * reaches the audio-agreement bar (1e-9) an order of magnitude more cleanly
+  * without meaningful fill cost -- the refinement in `SCHEDULE_REFINEMENT_BAR`.
+  * Bar-clean ties keep shipped even when the audios differ: the
+  * operating-point replay cannot adjudicate audio-time divergence (`boss-os-2`
+  * replays 3.4e-10 shipped vs 2.5e-13 candidate while the audios differ 1000x),
+  * so the rule only moves past the bar it can measure, never on a tie.
+  * Measured adopters: `boss-sd-1` (1.8e-9 to 4.2e-13, audio 6.9e-8 to
+  * 6.5e-12).
   */
   settlePivotOrders() {
     if (this.pivotOrdersSettled) {
@@ -2963,10 +3181,8 @@ var ReferenceRuntime = class {
         planRow.worstPivotRatio = worstRatio;
         planRow.pivotDisagreement = Number.isFinite(disagreement) ? disagreement : null;
       }
-      if (disagreement <= SCHEDULE_VALIDATION_TOL) {
-        continue;
-      }
       const candidate = computeNumericRepivot(schedule, size, matrix);
+      let candidateDisagreement = Infinity;
       if (candidate !== null) {
         const candidateValues = new Float64Array(candidate.slots);
         const candidateRhs = new Float64Array(size);
@@ -2988,28 +3204,39 @@ var ReferenceRuntime = class {
           candidateDiffSquares += difference * difference;
           candidateDenseSquares += denseOut[index] ** 2;
         }
-        const candidateDisagreement = candidateReplayed ? Math.sqrt(candidateDiffSquares) / Math.max(Math.sqrt(candidateDenseSquares), 1e-9) : Infinity;
-        if (candidateDisagreement <= SCHEDULE_VALIDATION_TOL) {
-          this.sparseSchedules.set(blockId, {
-            schedule: candidate,
-            values: new Float64Array(candidate.slots),
-            rhs: new Float64Array(size),
-            factors: new Float64Array(candidate.factorCount),
-            consecutiveFallbacks: 0
-          });
-          this.repivotedSchedules.add(blockId);
-          this.droppedSchedules.delete(blockId);
-          if (planRow !== void 0) {
-            planRow.path = "sparse";
-            planRow.reason = `numeric re-pivot ${candidateDisagreement.toExponential(1)} vs dense`;
-            planRow.pivotDisagreement = candidateDisagreement;
-            planRow.repivoted = true;
-            planRow.patternEntries = candidate.slots;
-            planRow.sparseOps = candidate.sparseOps;
-            planRow.unprovenPivots = candidate.unprovenPivots;
-          }
+        candidateDisagreement = candidateReplayed ? Math.sqrt(candidateDiffSquares) / Math.max(Math.sqrt(candidateDenseSquares), 1e-9) : Infinity;
+      }
+      if (disagreement <= SCHEDULE_VALIDATION_TOL) {
+        if (candidate !== null && shouldRefinePivotOrder({
+          shippedDisagreement: disagreement,
+          candidateDisagreement,
+          shippedOps: schedule.sparseOps,
+          shippedSlots: schedule.slots,
+          candidateOps: candidate.sparseOps,
+          candidateSlots: candidate.slots
+        })) {
+          this.adoptRepivotedSchedule(
+            blockId,
+            candidate,
+            size,
+            planRow,
+            `numeric re-pivot ${candidateDisagreement.toExponential(1)} vs dense (shipped ${Number.isFinite(disagreement) ? disagreement.toExponential(1) : "replay refused"}); +${((candidate.sparseOps / Math.max(schedule.sparseOps, 1) - 1) * 100).toFixed(1)}% ops`,
+            candidateDisagreement
+          );
           continue;
         }
+        continue;
+      }
+      if (candidate !== null && candidateDisagreement <= SCHEDULE_VALIDATION_TOL) {
+        this.adoptRepivotedSchedule(
+          blockId,
+          candidate,
+          size,
+          planRow,
+          `numeric re-pivot ${candidateDisagreement.toExponential(1)} vs dense`,
+          candidateDisagreement
+        );
+        continue;
       }
       this.sparseSchedules.delete(blockId);
       this.droppedSchedules.add(blockId);
@@ -3023,6 +3250,115 @@ var ReferenceRuntime = class {
       }
     }
   }
+  /**
+   * Adopt a value-aware replacement order for a block, from settle or from
+   * the mid-run re-pivot, with one shared bookkeeping shape.
+   *
+   * The replacement's slots are a superset of the shipped filled pattern
+   * whose extra cells no stamp writes (see `computeNumericRepivot`), so the
+   * pattern-sized matrix refresh keeps reading correct zeros and neither
+   * `clearPairs` nor the selective-copy machinery needs a rebuild -- the
+   * same reason a dropped block, which does change the refresh, sets
+   * `clearPairs` to null where this does not.
+   */
+  adoptRepivotedSchedule(blockId, candidate, size, planRow, reason, pivotDisagreement) {
+    this.sparseSchedules.set(blockId, {
+      schedule: candidate,
+      values: new Float64Array(candidate.slots),
+      rhs: new Float64Array(size),
+      factors: new Float64Array(candidate.factorCount),
+      consecutiveFallbacks: 0,
+      repivotAttempted: false
+    });
+    this.repivotedSchedules.add(blockId);
+    this.droppedSchedules.delete(blockId);
+    if (planRow !== void 0) {
+      planRow.path = "sparse";
+      planRow.reason = reason;
+      planRow.pivotDisagreement = pivotDisagreement;
+      planRow.repivoted = true;
+      planRow.patternEntries = candidate.slots;
+      planRow.sparseOps = candidate.sparseOps;
+      planRow.unprovenPivots = candidate.unprovenPivots;
+    }
+  }
+  /**
+   * The mid-run half of the pivot-guard contract: at the consecutive-trip
+   * limit, re-pivot once from the current matrix instead of abandoning.
+   *
+   * Takes the stamped matrix and rhs snapshotted before the dense fallback
+   * destroyed them, plus the fallback's answer, and returns whether a
+   * value-aware order was adopted. Adoption needs the rescue standard --
+   * replay within `SCHEDULE_VALIDATION_TOL` of the dense answer on this
+   * matrix -- the same bar a collapse rescue clears at settle, because this
+   * is a rescue: the shipped order demonstrably does not suit this
+   * operating region. A refusal (null candidate, tripped replay, or a
+   * disagreeing replay) returns false and the caller abandons exactly as
+   * before, with the reason naming the refusal. Either outcome lands in
+   * the plan row, so a mid-run adoption is as visible as a settle one.
+   *
+   * Structured for direct unit testing (pure inputs, boolean verdict): the
+   * corpus never trips the guard, so no corpus run exercises this path.
+   */
+  adoptMidRunRepivot(blockId, entry, matrix, rhs, denseAnswer) {
+    const planRow = this.solverPlanRows.find(
+      (candidate2) => candidate2.blockId === blockId
+    );
+    const block = this.blocksById.get(blockId);
+    const size = block !== void 0 && block.kind === "mna" ? block.nodeCount + block.auxCount : 0;
+    const refuse = (reason) => {
+      if (planRow !== void 0) {
+        planRow.reason += ` mid-run re-pivot ${reason}; abandoned`;
+      }
+      return false;
+    };
+    if (block === void 0 || block.kind !== "mna" || size <= 0) {
+      return refuse("refused (unknown block)");
+    }
+    const candidate = computeNumericRepivot(entry.schedule, size, matrix);
+    if (candidate === null) {
+      return refuse("refused (no candidate meets the threshold)");
+    }
+    const values = new Float64Array(candidate.slots);
+    const scratchRhs = new Float64Array(size);
+    const factors = new Float64Array(candidate.factorCount);
+    const out = new Array(size).fill(0);
+    const replayed = runSparseSchedule(
+      candidate,
+      matrix,
+      rhs,
+      values,
+      scratchRhs,
+      factors,
+      out
+    );
+    let diffSquares = 0;
+    let denseSquares = 0;
+    for (let index = 0; index < size; index += 1) {
+      const difference = out[index] - denseAnswer[index];
+      diffSquares += difference * difference;
+      denseSquares += denseAnswer[index] ** 2;
+    }
+    const disagreement = replayed ? Math.sqrt(diffSquares) / Math.max(Math.sqrt(denseSquares), 1e-9) : Infinity;
+    if (!(disagreement <= SCHEDULE_VALIDATION_TOL)) {
+      return refuse(
+        `refused (replay ${Number.isFinite(disagreement) ? disagreement.toExponential(1) : "tripped"} vs dense)`
+      );
+    }
+    this.adoptRepivotedSchedule(
+      blockId,
+      candidate,
+      size,
+      planRow,
+      `mid-run numeric re-pivot ${disagreement.toExponential(1)} vs dense after ${SCHEDULE_CONSECUTIVE_FALLBACK_LIMIT} guard trips`,
+      disagreement
+    );
+    const adopted = this.sparseSchedules.get(blockId);
+    if (adopted !== void 0) {
+      adopted.repivotAttempted = true;
+    }
+    return true;
+  }
   /**
    * Which blocks took the static schedule and which kept the dense solve, and how often the
    * pivot guard sent a solve back to the dense path.
@@ -3051,52 +3387,131 @@ var ReferenceRuntime = class {
     }
     const output = new Float64Array(input.length);
     this.samples += input.length;
-    for (let index = 0; index < input.length; index += 1) {
-      const sample = input[index] ?? 0;
-      let hostResult = 0;
-      let hostNonConverged = false;
-      let hostNonFinite = false;
-      for (let sub = 0; sub < this.oversample; sub += 1) {
-        this.timeSeconds = this.elapsedSamples / this.sampleRate;
-        let result = 0;
-        this.sampleNonConverged = false;
-        this.sampleNonFinite = false;
-        for (const id of this.program.order) {
-          const block = this.blocksById.get(id);
-          if (block === void 0) {
-            continue;
-          }
-          const blockOutput = this.processBlock(block, sample);
-          if (block.kind === "mna" && block.outputNode !== null) {
-            result = blockOutput;
-          }
-        }
-        if (this.sampleNonConverged) {
-          hostNonConverged = true;
-        }
-        if (this.sampleNonFinite) {
-          hostNonFinite = true;
-        }
-        for (const branch of this.supplyBranchSlots) {
-          const amps = this.nodeVoltages.get(branch.blockId)?.[branch.slot] ?? 0;
-          const magnitude = Math.abs(amps);
-          if (magnitude > this.renderedSupplyPeakAmps) {
-            this.renderedSupplyPeakAmps = magnitude;
-          }
-        }
-        this.elapsedSamples += 1;
-        hostResult = result;
+    if (this.resampleUp.length === 0) {
+      for (let index = 0; index < input.length; index += 1) {
+        output[index] = this.processHeldSample(input[index] ?? 0);
       }
-      if (hostNonConverged) {
-        this.nonConvergedSamples += 1;
-      }
-      if (hostNonFinite) {
-        this.nonFiniteSamples += 1;
+    } else {
+      for (let index = 0; index < input.length; index += 1) {
+        output[index] = this.processResampledSample(input[index] ?? 0);
       }
-      output[index] = hostResult;
     }
     return output;
   }
+  /**
+   * One host sample through the legacy path: the input held flat across the
+   * sub-samples, the last sub-sample kept. Bit-identical to the behaviour
+   * before the band-limited resampler existed, which is what makes factor 1
+   * (and non-power-of-two factors) cost nothing and change nothing.
+   */
+  processHeldSample(sample) {
+    let hostResult = 0;
+    let hostNonConverged = false;
+    let hostNonFinite = false;
+    for (let sub = 0; sub < this.oversample; sub += 1) {
+      hostResult = this.solveSubSample(sample);
+      if (this.sampleNonConverged) {
+        hostNonConverged = true;
+      }
+      if (this.sampleNonFinite) {
+        hostNonFinite = true;
+      }
+    }
+    if (hostNonConverged) {
+      this.nonConvergedSamples += 1;
+    }
+    if (hostNonFinite) {
+      this.nonFiniteSamples += 1;
+    }
+    return hostResult;
+  }
+  /**
+   * One host sample through the band-limited path: half-band interpolate up
+   * by 2 per stage, solve each sub-sample, FIR-decimate back to one host
+   * sample. The resampler state lives on the stages across `process()`
+   * calls, so any block split renders bit-identically to one long call;
+   * the group delay this adds is reported by `oversampleLatency()`.
+   */
+  processResampledSample(sample) {
+    const stages = this.resampleUp.length;
+    let cur = this.resampleBufA;
+    let next = this.resampleBufB;
+    this.resampleUp[0].interpolate(sample, cur, 0);
+    let width = 2;
+    for (let stage = 1; stage < stages; stage += 1) {
+      for (let i = 0; i < width; i += 1) {
+        this.resampleUp[stage].interpolate(
+          cur[i],
+          next,
+          2 * i
+        );
+      }
+      const swap = cur;
+      cur = next;
+      next = swap;
+      width *= 2;
+    }
+    let hostNonConverged = false;
+    let hostNonFinite = false;
+    for (let sub = 0; sub < width; sub += 1) {
+      next[sub] = this.solveSubSample(cur[sub]);
+      if (this.sampleNonConverged) {
+        hostNonConverged = true;
+      }
+      if (this.sampleNonFinite) {
+        hostNonFinite = true;
+      }
+    }
+    const hi = next;
+    for (let stage = stages - 1; stage >= 0; stage -= 1) {
+      const half = width / 2;
+      for (let i = 0; i < half; i += 1) {
+        hi[i] = this.resampleDown[stage].decimate(
+          hi[2 * i],
+          hi[2 * i + 1]
+        );
+      }
+      width = half;
+    }
+    if (hostNonConverged) {
+      this.nonConvergedSamples += 1;
+    }
+    if (hostNonFinite) {
+      this.nonFiniteSamples += 1;
+    }
+    return hi[0];
+  }
+  /**
+   * One sub-sample solve at the solver rate: every block stepped once at
+   * `t = elapsedSamples / sampleRate`, returning the output jack's value.
+   * Shared by the held and the resampled paths, so factor 1 executes the
+   * same operations in the same order as before the resampler existed.
+   */
+  solveSubSample(subInput) {
+    this.timeSeconds = this.elapsedSamples / this.sampleRate;
+    let result = 0;
+    this.sampleNonConverged = false;
+    this.sampleNonFinite = false;
+    for (const id of this.program.order) {
+      const block = this.blocksById.get(id);
+      if (block === void 0) {
+        continue;
+      }
+      const blockOutput = this.processBlock(block, subInput);
+      if (block.kind === "mna" && block.outputNode !== null) {
+        result = blockOutput;
+      }
+    }
+    for (const branch of this.supplyBranchSlots) {
+      const amps = this.nodeVoltages.get(branch.blockId)?.[branch.slot] ?? 0;
+      const magnitude = Math.abs(amps);
+      if (magnitude > this.renderedSupplyPeakAmps) {
+        this.renderedSupplyPeakAmps = magnitude;
+      }
+    }
+    this.elapsedSamples += 1;
+    return result;
+  }
   /**
    * The rate the caller passed to `prepare`, as opposed to the solver's sub-sample rate.
    *
@@ -3106,6 +3521,17 @@ var ReferenceRuntime = class {
   hostSampleRate() {
     return this.sampleRate === null ? null : this.sampleRate / this.oversample;
   }
+  /**
+   * The resampler's total group delay in **host** samples, or `null` before
+   * `prepare()`. Zero when the resampler is bypassed (factor 1, or a factor
+   * that is not a power of two and keeps the legacy path): the held path
+   * adds no latency by construction. At 2x/4x/8x this is 19.5/26.25/28.625
+   * host samples for the stage-specific half-band cascade -- a real, reported
+   * latency the caller must absorb or declare, not a hidden one.
+   */
+  oversampleLatency() {
+    return this.sampleRate === null ? null : this.resampleLatencyHost;
+  }
   processBlock(block, input) {
     if (block.kind === "composed") {
       this.processComposedBlock(block);
@@ -3571,8 +3997,10 @@ var ReferenceRuntime = class {
     const { matrix, rhs, solutionA, solutionB } = scratch;
     const sparse = dc ? void 0 : this.sparseSchedules.get(block.id);
     const blockIndex = this.blockIndexById.get(block.id) ?? 0;
+    const predictorPass = !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] = start[index] ?? 0;
+      solutionA[index] = seed[index] ?? 0;
     }
     let current = solutionA;
     let next = solutionB;
@@ -3690,11 +4118,26 @@ var ReferenceRuntime = class {
           this.scheduleFallbacks += 1;
           sparse.consecutiveFallbacks += 1;
           if (sparse.consecutiveFallbacks >= SCHEDULE_CONSECUTIVE_FALLBACK_LIMIT) {
-            this.sparseSchedules.delete(block.id);
-            this.abandonedSchedules.add(block.id);
+            if (!sparse.repivotAttempted) {
+              sparse.repivotAttempted = true;
+              const matrixCopy = matrix.map((row) => [...row]);
+              const rhsCopy = [...rhs];
+              scratch.denseDirty = true;
+              solve(matrix, rhs, next);
+              if (!this.adoptMidRunRepivot(block.id, sparse, matrixCopy, rhsCopy, next)) {
+                this.sparseSchedules.delete(block.id);
+                this.abandonedSchedules.add(block.id);
+              }
+            } else {
+              this.sparseSchedules.delete(block.id);
+              this.abandonedSchedules.add(block.id);
+              scratch.denseDirty = true;
+              solve(matrix, rhs, next);
+            }
+          } else {
+            scratch.denseDirty = true;
+            solve(matrix, rhs, next);
           }
-          scratch.denseDirty = true;
-          solve(matrix, rhs, next);
         }
       }
       if (relaxing) {
@@ -3789,6 +4232,9 @@ var ReferenceRuntime = class {
         if (used > census.peakIterations) census.peakIterations = used;
       }
     }
+    if (predictorPass) {
+      this.recordNewtonSolution(block.id, current, converged, used);
+    }
     return { solution: current, converged, used, worstNode, worstDelta };
   }
   /**
@@ -4005,8 +4451,10 @@ var ReferenceRuntime = class {
         full[portRows[p]] = y[p];
       }
     };
+    const predictorPass = !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] = start[portRows[p]] ?? 0;
+      scratch.yCurrent[p] = seed[portRows[p]] ?? 0;
     }
     reconstructFull(scratch.yCurrent, scratch.fullCurrent);
     const iterations = this.maxNewtonIterations;
@@ -4138,6 +4586,9 @@ var ReferenceRuntime = class {
         if (used > census.peakIterations) census.peakIterations = used;
       }
     }
+    if (predictorPass) {
+      this.recordNewtonSolution(block.id, current, converged, used);
+    }
     return { solution: current, converged, used, worstNode, worstDelta };
   }
   /**
@@ -4379,6 +4830,86 @@ var ReferenceRuntime = class {
     this.opampHistory.clear();
     this.triodeHistory.clear();
   }
+  /**
+   * The Newton start `newtonStartHistory` selects for this block, or `null` to start from
+   * the caller's previous solution (order 0, or a chain too short for the chosen order).
+   * The returned array is the block's reused scratch: read it before the next solve.
+   */
+  predictedNewtonStart(blockId, size) {
+    const history = this.newtonStartHistory.get(blockId);
+    if (history === void 0 || history.order === 0) {
+      return null;
+    }
+    if (history.candidate.length !== size) {
+      history.candidate = new Array(size).fill(0);
+    }
+    return extrapolateNewtonStart(history, history.order, size, history.candidate) ? history.candidate : null;
+  }
+  /**
+   * Record a finished standard-pass solve: on convergence, score the three candidate
+   * starts the history could have produced against the solution just reached (one fused
+   * pass, no allocation) and keep the best order for the next solve, then rotate the
+   * solution into the history ring; on failure, break the chain.
+   */
+  recordNewtonSolution(blockId, solution, converged, used) {
+    let history = this.newtonStartHistory.get(blockId);
+    if (history === void 0) {
+      history = { x1: null, x2: null, x3: null, chain: 0, order: 0, candidate: [] };
+      this.newtonStartHistory.set(blockId, history);
+    }
+    if (!converged) {
+      history.chain = 0;
+      history.order = 0;
+      return;
+    }
+    const size = solution.length;
+    const { x1, x2, x3 } = history;
+    const has1 = history.chain >= 1 && x1 !== null && x1.length === size;
+    const has2 = has1 && history.chain >= 2 && x2 !== null && x2.length === size;
+    const has3 = has2 && history.chain >= 3 && x3 !== null && x3.length === size;
+    let error0 = has1 ? 0 : Number.POSITIVE_INFINITY;
+    let error1 = has2 ? 0 : Number.POSITIVE_INFINITY;
+    let error2 = has3 ? 0 : Number.POSITIVE_INFINITY;
+    if (has1) {
+      for (let index = 0; index < size; index += 1) {
+        const s = solution[index];
+        const magnitude = Math.abs(s);
+        const v1 = x1[index];
+        const ratio0 = Math.abs(v1 - s) / (NEWTON_RELATIVE_TOLERANCE * Math.max(Math.abs(v1), magnitude) + NEWTON_VOLTAGE_TOLERANCE);
+        if (ratio0 > error0) error0 = ratio0;
+        if (!has2) continue;
+        const v2 = x2[index];
+        const guess1 = 2 * v1 - v2;
+        const ratio1 = Math.abs(guess1 - s) / (NEWTON_RELATIVE_TOLERANCE * Math.max(Math.abs(guess1), magnitude) + NEWTON_VOLTAGE_TOLERANCE);
+        if (ratio1 > error1) error1 = ratio1;
+        if (!has3) continue;
+        const guess2 = 3 * v1 - 3 * v2 + x3[index];
+        const ratio2 = Math.abs(guess2 - s) / (NEWTON_RELATIVE_TOLERANCE * Math.max(Math.abs(guess2), magnitude) + NEWTON_VOLTAGE_TOLERANCE);
+        if (ratio2 > error2) error2 = ratio2;
+      }
+    }
+    let best = 0;
+    let bestError = error0;
+    if (error1 < bestError) {
+      best = 1;
+      bestError = error1;
+    }
+    if (error2 < bestError) {
+      best = 2;
+    }
+    if (used > 2) {
+      best = 0;
+    }
+    history.order = best;
+    const oldest = history.x3;
+    history.x3 = history.x2;
+    history.x2 = history.x1;
+    history.x1 = oldest !== null && oldest.length === size ? oldest : new Array(size).fill(0);
+    for (let index = 0; index < size; index += 1) {
+      history.x1[index] = solution[index];
+    }
+    history.chain += 1;
+  }
   snapshotLimiterHistories() {
     return {
       diode: new Map(this.diodeHistory),
@@ -5570,8 +6101,17 @@ function solve(matrix, rhs, out) {
 var SCHEDULE_OP_WIDTH = 4;
 var SCHEDULE_PIVOT_FLOOR = 1e-18;
 var SCHEDULE_VALIDATION_TOL = 1e-3;
+var SCHEDULE_REFINEMENT_BAR = 1e-9;
+var SCHEDULE_REFINEMENT_RATIO = 10;
+var SCHEDULE_REFINEMENT_MAX_COST_GROWTH = 1.1;
 var SCHEDULE_MINIMUM_SAVING = 4;
 var SCHEDULE_CONSECUTIVE_FALLBACK_LIMIT = 64;
+function shouldRefinePivotOrder(input) {
+  if (!Number.isFinite(input.shippedDisagreement) || !Number.isFinite(input.candidateDisagreement)) {
+    return false;
+  }
+  return input.shippedDisagreement > SCHEDULE_REFINEMENT_BAR && input.candidateDisagreement <= SCHEDULE_REFINEMENT_BAR && input.candidateDisagreement < input.shippedDisagreement / SCHEDULE_REFINEMENT_RATIO && input.candidateOps <= SCHEDULE_REFINEMENT_MAX_COST_GROWTH * input.shippedOps && input.candidateSlots <= SCHEDULE_REFINEMENT_MAX_COST_GROWTH * input.shippedSlots;
+}
 function runSparseSchedule(schedule, matrix, rhs, values, scratchRhs, factors, out) {
   const { ops, gatherRow, gatherColumn, slots, size } = schedule;
   for (let index = 0; index < slots; index += 1) {
@@ -5692,6 +6232,26 @@ function relativeResidual(matrix, rhs, x, pairs, size) {
   }
   return Number.isFinite(worst) ? worst : Number.POSITIVE_INFINITY;
 }
+function extrapolateNewtonStart(history, order, size, out) {
+  const { x1, x2, x3, chain } = history;
+  if (order === 0) {
+    if (chain < 1 || x1 === null) return false;
+    for (let index = 0; index < size; index += 1) out[index] = x1[index];
+    return true;
+  }
+  if (order === 1) {
+    if (chain < 2 || x1 === null || x2 === null) return false;
+    for (let index = 0; index < size; index += 1) {
+      out[index] = 2 * x1[index] - x2[index];
+    }
+    return true;
+  }
+  if (chain < 3 || x1 === null || x2 === null || x3 === null) return false;
+  for (let index = 0; index < size; index += 1) {
+    out[index] = 3 * x1[index] - 3 * x2[index] + x3[index];
+  }
+  return true;
+}
 function withinTolerance(next, previous) {
   for (let index = 0; index < next.length; index += 1) {
     const a = next[index] ?? 0;
@@ -6127,7 +6687,33 @@ var V2WasmEngine = class _V2WasmEngine {
     const sr = options.sampleRate ?? 48e3;
     const maxIters = options.maxNewtonIterations ?? DEFAULT_NEWTON_MAX_ITERATIONS;
     const inputOhms = options.inputSourceOhms ?? 0;
-    this.mod._v2_engine_prepare(this.handle, sr, maxIters, inputOhms);
+    const oversample = Math.max(1, Math.floor(options.oversample ?? 1));
+    if (!Number.isFinite(oversample)) {
+      throw new RuntimeError(
+        `oversample must be a finite integer of at least 1, got ${String(options.oversample)}`
+      );
+    }
+    this.mod._v2_engine_prepare(this.handle, sr, maxIters, inputOhms, oversample);
+  }
+  /**
+   * The rate `prepare` was called with (the host rate), as opposed to the
+   * solver's sub-sample rate -- the same name and semantics as
+   * `ReferenceRuntime.hostSampleRate()`, including `null` before
+   * `prepare()`.
+   */
+  hostSampleRate() {
+    const value = this.mod._v2_engine_get_host_sample_rate(this.handle);
+    return value < 0 ? null : value;
+  }
+  /**
+   * The resampler's total group delay in **host** samples -- the same name
+   * and semantics as `ReferenceRuntime.oversampleLatency()`, including
+   * `null` before `prepare()` and 0 on the held path (factor 1 or a factor
+   * that is not a power of two).
+   */
+  oversampleLatency() {
+    const value = this.mod._v2_engine_get_oversample_latency(this.handle);
+    return value < 0 ? null : value;
   }
   reset() {
     this.mod._v2_engine_reset(this.handle);
@@ -6318,6 +6904,25 @@ var V2WasmEngine = class _V2WasmEngine {
    * A healthy packet reads `fallbacks === 0` and `abandonedBlocks === 0`. Anything else is a
    * cost defect even though the audio is correct.
    */
+  /**
+   * Newton start predictor telemetry, the console-side mirror of the reference's
+   * `newtonStartHistory` decisions: `seedsUsed` counts standard-pass solves that started
+   * from an extrapolated solution (order > 0), `oneIterationSolves` those that converged in
+   * exactly one iteration -- the saving itself, attributable on the shipping console.
+   * Counted since `prepare()`/`reset()`. `predictorOrder(blockIdx)` reads the order the
+   * block's next solve will seed from (0 = previous solution, 1 = linear, 2 = quadratic;
+   * -1 for a bad index), so a decision can be compared against the reference per sample.
+   */
+  getPredictorTelemetry() {
+    return {
+      seedsUsed: this.mod._v2_engine_get_predictor_seeds(this.handle),
+      oneIterationSolves: this.mod._v2_engine_get_one_iteration_solves(this.handle),
+      totalIterations: this.mod._v2_engine_get_total_iterations(this.handle)
+    };
+  }
+  getPredictorOrder(blockIdx) {
+    return this.mod._v2_engine_get_predictor_order(this.handle, blockIdx);
+  }
   getScheduleTelemetry() {
     return {
       solves: this.mod._v2_engine_get_schedule_solves(this.handle),