feat(manifold): merge P4 — pipelines + curves run the WASM core; TS ports deleted

2026-07-18 12:22:21 +02:00 · 2026-07-18 12:22:21 +02:00 · a7c1f29aa6
commit a7c1f29aa6
parent 1672fe3474 846a0c373a
17 changed files with 1406 additions and 1449 deletions
--- a/manifold/ONBOARDING.md
+++ b/manifold/ONBOARDING.md
@ -158,9 +158,11 @@ a setting → `--r-*` tokens.
 ### Engine — `src/engine/` (no React except the two binding files)
 - `spine.ts` — **the reactive store.** `setInput(x,y)`/`setInputs(arr)` drive raw input synchronously
-  through input-pipeline → `WasmIML.processInto()` → output-pipeline → backend, all off the render
+  through `WasmIML.processInput` (WASM input chain) → `processInto()` → `WasmIML.processOutput` (WASM
-  cycle, reusing buffers. Bumps a monotonic `version`. `reprocess()` re-ticks the last input after a
+  output chain) → backend, all off the render cycle, reusing buffers. Bumps a monotonic `version`.
-  weight change (stores the full N-D vector so extra axes survive).
+  `reprocess()` re-ticks the last input after a weight change (stores the full N-D vector so extra axes
  survive). Pipeline config lives in `inputConfig_`/`outputConfig_` and is pushed C-side via
  `setInputConfig`/`setOutputConfig` (state itself lives in the WASM pipeline handle since P4).
 - `engine-api.ts` — **`EngineApi`, the framework-neutral facade** everything in the UI talks to:
  `setInput/setInputs`, `getOutputs/routedOutput`, training (`addExample/train/trainAsync/evalLoss`),
  weights (`getWeights/setWeights/process/randomise`), `subscribe/version/on`, plus nested
@ -173,12 +175,17 @@ a setting → `--r-*` tokens.
  buffers, feedback C-ABI bindings (`nisps_ml_feedback_*`), lazy training worker.
 - `wasm-worker.ts` — off-thread training worker. `worklet/nisps-processor.ts` — the AudioWorklet's
  separate WASM instance (raw `WebAssembly.instantiate`, no Emscripten glue; 128-sample blocks).
- `input-pipeline.ts` — per-axis: invert → deadzone → circular clamp → zoom → centred power curve →
+- **Input/output pipelines + curves live in the C++/WASM core (one-core-engine P4).** The input chain
-  EMA smoothing → momentum. **First 2 axes get the full pad pipeline; axes 2+ feed raw to the spine.**
+  (invert → deadzone → circular clamp → momentum-modulated zoom → centred power → EMA → momentum) and
- `output-pipeline.ts` — global power curve → per-output EMA smoothing → slew limit → freeze gate.
+  output chain (global curve → per-output EMA → slew → freeze/mask) are `nisps/pipeline/*`, exposed via
  `nisps_input_*` / `nisps_output_*` and driven by thin `WasmIML` wrappers (`processInput`,
  `processOutput`, `setInputConfig`, `setOutputConfig`, `setOutputFreezeMask`, `reset*`). State lives
  C++-side per pipeline handle. First 2 axes get the full pad pipeline; axes 2+ feed raw to the spine.
  The old TS `input-pipeline.ts` / `output-pipeline.ts` / `curves.ts` are **deleted**; config TYPES are
  `pipeline-types.ts`, the curve NAME↔id contract is `curve-catalog.ts`, and the curve MATHS is sampled
  from the core via `EngineApi.curveApply` / `curveApplyBatch`.
 - `dataset.ts` — JS-side example store + sample-weight modes (uniform/recency/spatial/combined).
- `curves.ts` — math primitives. **Must stay lockstep with C++ `nisps/core/math.hpp`** (golden tests
+  `sink.ts` — `EngineSink` framework boundary. `types.ts` — C-ABI surface types.
  compare WASM vs TS). `sink.ts` — `EngineSink` framework boundary. `types.ts` — C-ABI surface types.
 - `exploration.ts` — `ExplorationController` adapter for the Jolt press + OU explore gestures
  (Learning drawer). **As of one-core-engine P3 the maths lives in the shared C++/WASM core** — this
  class is a thin driver that owns only the control-rate timers and calls `engine.explore.*`
@ -258,7 +265,12 @@ a setting → `--r-*` tokens.
   bit-identical), and `nisps_ml_reshape` swaps in a warm-started net at new dims. Weights = 3148 at
   the default shape; reshaping only the input arity shifts the first layer (e.g. →4 inputs = 2868).
   The firmware MLP stays compile-time templated — only the WASM/browser build is dynamic.
-5. **`curves.ts` ↔ `nisps/core/math.hpp` must stay lockstep** (golden-vector parity tests).
+5. **Curves + input/output pipelines are C++/WASM only (one-core-engine P4).** No TS curve/pipeline
   maths remains; the browser samples `nisps/core/math.hpp` + `nisps/pipeline/*` via the WASM. The
   golden test (`tests/pipeline-golden.test.ts`) drives the WASM chains against the frozen fixtures.
   NOTE: `exp/log/sigmoid/cubic` deliberately changed to the firmware-exact maths at P4 (see
   `tests/fixtures/README.md`); `linear/square/sqrt/centered_power` are unchanged. The 3 momentum input
   configs carry a wide (`1e-2`) tolerance — proven-inherent f32 drift, documented in the test header.
 6. **COOP/COEP headers are mandatory** for the WASM/worklet path — set in `vite.config.ts` for
   dev+preview, and at nginx server scope in prod (inherited by `/next/`).
 7. **Never emit "C15"** in code or bundle — the smoke test fails on it. Synth is "Powerful Synth
--- a/manifold/src/engine/curve-catalog.ts
+++ b/manifold/src/engine/curve-catalog.ts
@ -0,0 +1,56 @@
 /**
 * Curve catalog — NAMES + ids only (one-core-engine P4).
 *
 * The curve MATHS now lives solely in the C++/WASM core
 * (nisps/core/math.hpp), sampled via `EngineApi.curveApply` /
 * `curveApplyBatch` (bindings `nisps_curve_apply` / `_batch`). The old TS
 * `curves.ts` — which mirrored the maths and drifted from the canonical
 * catalog for exp/log/sigmoid/cubic — is deleted. This module keeps only the
 * NAME↔id contract every consumer needs to talk to the WASM.
 *
 * Curve ids (nisps::Curve enum + centred power):
 *   0 linear · 1 exp · 2 log · 3 square · 4 sqrt · 5 sigmoid · 6 cubic
 *   7 centered_power (param = exponent)
 */
 export type CurveName =
  | 'linear'
  | 'exp'
  | 'log'
  | 'square'
  | 'sqrt'
  | 'sigmoid'
  | 'cubic'
  | 'centered_power';
 /** Canonical name → WASM curve id. */
 export const CURVE_ID: Record<CurveName, number> = {
  linear: 0,
  exp: 1,
  log: 2,
  square: 3,
  sqrt: 4,
  sigmoid: 5,
  cubic: 6,
  centered_power: 7,
 };
 export const CURVE_NAMES: ReadonlyArray<CurveName> = [
  'linear', 'exp', 'log', 'square', 'sqrt', 'sigmoid', 'cubic', 'centered_power',
 ];
 /**
 * Default `param` per curve. Only `centered_power` reads its param (the
 * exponent). The named catalog entries (0..6) ignore param C-side; the value is
 * documentary. Kept for the fixture generator / previews.
 */
 export const CURVE_DEFAULT_PARAMS: Record<CurveName, number | null> = {
  linear: null,
  exp: null,
  log: null,
  square: null,
  sqrt: null,
  sigmoid: null,
  cubic: null,
  centered_power: 1.0,
 };
--- a/manifold/src/engine/curves.ts
+++ b/manifold/src/engine/curves.ts
@ -1,128 +0,0 @@
 /**
 * Curve catalog — TypeScript mirror of the named curves from
 * nisps/core/math.hpp (forthcoming, stream 1). All inputs and outputs are in
 * [0, 1] unless noted otherwise.
 *
 * IMPORTANT: This file MUST stay in lockstep with the C++ side. The
 * authoritative reference is `nisps/core/math.hpp`. Golden-vector tests
 * (stream 11) compare WASM-computed vs TS-computed outputs and fail on
 * any drift.
 *
 * Architecture §5.3:
 *   linear, exp, log, square, sqrt, sigmoid, cubic, centered_power
 *
 * The "centered_power" variant comes from the legacy input/output pipelines
 * and shapes around 0.5 instead of 0.0. Kept as a named curve because both
 * input and output pipelines use it.
 */
 export type CurveName =
  | 'linear'
  | 'exp'
  | 'log'
  | 'square'
  | 'sqrt'
  | 'sigmoid'
  | 'cubic'
  | 'centered_power';
 /** Hard clamp to [0, 1]. */
 export function clamp01(v: number): number {
  if (v < 0) return 0;
  if (v > 1) return 1;
  return v;
 }
 /** Generic clamp. */
 export function clamp(v: number, lo: number, hi: number): number {
  if (v < lo) return lo;
  if (v > hi) return hi;
  return v;
 }
 /** Linear: identity. */
 export function curveLinear(x: number): number {
  return clamp01(x);
 }
 /** Exponential: e^(k*x) - 1, normalized to [0,1] over [0,1] input. */
 export function curveExp(x: number, k: number = 4.0): number {
  if (x <= 0) return 0;
  if (x >= 1) return 1;
  const denom = Math.exp(k) - 1.0;
  if (denom === 0) return x;
  return (Math.exp(k * x) - 1.0) / denom;
 }
 /** Inverse of curveExp. */
 export function curveLog(x: number, k: number = 4.0): number {
  if (x <= 0) return 0;
  if (x >= 1) return 1;
  const denom = Math.exp(k) - 1.0;
  if (denom === 0) return x;
  return Math.log(1 + x * denom) / k;
 }
 /** Square: x^2. */
 export function curveSquare(x: number): number {
  const v = clamp01(x);
  return v * v;
 }
 /** Square-root. */
 export function curveSqrt(x: number): number {
  return Math.sqrt(clamp01(x));
 }
 /** Logistic sigmoid mapped onto [0,1] domain (centered at x=0.5). */
 export function curveSigmoid(x: number, slope: number = 8.0): number {
  // Sigmoid centered at 0.5 with given slope. Output is in (0, 1).
  // Normalize so endpoints map exactly to 0 and 1.
  const t = (x - 0.5) * slope;
  const s = 1 / (1 + Math.exp(-t));
  // Anchor: when x=0, t=-slope/2; when x=1, t=+slope/2
  const sLo = 1 / (1 + Math.exp(slope / 2));
  const sHi = 1 / (1 + Math.exp(-slope / 2));
  return (s - sLo) / (sHi - sLo);
 }
 /** Cubic ease-in-out. */
 export function curveCubic(x: number): number {
  const v = clamp01(x);
  // Smoothstep cubic: 3v^2 - 2v^3
  return v * v * (3 - 2 * v);
 }
 /**
 * Centered power curve. Pivots around 0.5.
 *
 *   exponent < 1 → push toward extremes
 *   exponent = 1 → identity
 *   exponent > 1 → pull toward center
 */
 export function curveCenteredPower(x: number, exponent: number): number {
  if (exponent === 1) return clamp01(x);
  const offset = x - 0.5;
  const sign = offset < 0 ? -1 : 1;
  // Range [-0.5, 0.5] -> [-1, 1] for the power op, then halve back.
  const shaped = (sign * Math.pow(Math.abs(offset) * 2, exponent)) / 2;
  return clamp01(shaped + 0.5);
 }
 /** Apply by name. `param` interpretation depends on the curve. */
 export function applyCurve(name: CurveName, x: number, param?: number): number {
  switch (name) {
    case 'linear': return curveLinear(x);
    case 'exp': return curveExp(x, param ?? 4.0);
    case 'log': return curveLog(x, param ?? 4.0);
    case 'square': return curveSquare(x);
    case 'sqrt': return curveSqrt(x);
    case 'sigmoid': return curveSigmoid(x, param ?? 8.0);
    case 'cubic': return curveCubic(x);
    case 'centered_power': return curveCenteredPower(x, param ?? 1.0);
  }
 }
 export const CURVE_NAMES: ReadonlyArray<CurveName> = [
  'linear', 'exp', 'log', 'square', 'sqrt', 'sigmoid', 'cubic', 'centered_power',
 ];
--- a/manifold/src/engine/engine-api.ts
+++ b/manifold/src/engine/engine-api.ts
@ -16,6 +16,7 @@
 */
 import { EngineHost } from './engine-host';
 import type { InputConfig, OutputConfig } from './pipeline-types';
 import { Spine, type BackendSend } from './spine';
 import type { EngineId, FeedbackMode, LayerStats } from './types';
 import { WasmIML } from './wasm-iml';
@ -273,6 +274,30 @@ export class EngineApi {
    this.spine.reprocess();
  }
  // ---- Pipeline config + curves (one-core-engine P4) -----------------
  /** Replace the input-pipeline config (forwarded into the WASM input chain). */
  setInputConfig(cfg: InputConfig): void {
    this.spine.setInputConfig(cfg);
  }
  /** Replace the output-pipeline config (forwarded into the WASM output chain). */
  setOutputConfig(cfg: OutputConfig): void {
    this.spine.setOutputConfig(cfg);
  }
  /** Sample one catalog curve via the WASM core. id 0..6 = nisps::Curve (param
   *  ignored); id 7 = centred power (param = exponent). */
  curveApply(id: number, x: number, param = 0): number {
    return this.iml.curveApply(id, x, param);
  }
  /** Batch-sample a curve over `xs` into `out` (one WASM call, chunked). Use for
   *  previews / bulk shaping instead of per-value curveApply. */
  curveApplyBatch(id: number, xs: ArrayLike<number>, out: Float32Array, param = 0): void {
    this.iml.curveApplyBatch(id, xs, out, param);
  }
  // ---- Training ------------------------------------------------------
  addExample(features: ReadonlyArray<number>, labels: ReadonlyArray<number>): boolean {
--- a/manifold/src/engine/index.ts
+++ b/manifold/src/engine/index.ts
@ -40,17 +40,23 @@ export { EngineProvider, EngineContext } from './EngineProvider';
 export type { EngineProviderProps } from './EngineProvider';
 export { useEngine, useEngineOrThrow, useEngineVersion } from './useEngine';
-// Pure pipelines (re-exported for consumers that need to configure them).
+// Pipeline config types + defaults. The PROCESSING lives in the C++/WASM core
 // (one-core-engine P4); configure via EngineApi.setInputConfig / setOutputConfig.
 export {
  processInput,
  defaultInputConfig,
  defaultInputState,
 } from './input-pipeline';
 export type { InputConfig, InputState } from './input-pipeline';
 export {
  processOutput,
  defaultOutputConfig,
-  defaultOutputState,
+  anchorModeToInt,
-} from './output-pipeline';
+  momentumModeToInt,
-export type { OutputConfig, OutputState } from './output-pipeline';
+} from './pipeline-types';
-export * as curves from './curves';
+export type {
  InputConfig,
  OutputConfig,
  AnchorMode,
  MomentumZoomMode,
  InputProcessResult,
 } from './pipeline-types';
 // Curve catalog NAME↔id contract (maths lives in the core; sample via
 // EngineApi.curveApply / curveApplyBatch).
 export { CURVE_ID, CURVE_NAMES, CURVE_DEFAULT_PARAMS } from './curve-catalog';
 export type { CurveName } from './curve-catalog';
--- a/manifold/src/engine/input-pipeline.ts
+++ b/manifold/src/engine/input-pipeline.ts
@ -1,307 +0,0 @@
 /**
 * Input pipeline — pure TS port of legacy `js/ui/input-pipeline.js`.
 *
 * Stages (in order), each input/output in [0,1]:
 *   0. Invert (per-axis flip)
 *   1. Deadzone (suppress jitter near center, remap live zone to [0,1])
 *   2. Circular clamp (constrain to unit disk centered at 0.5,0.5)
 *   3. Zoom (narrow window around anchor, modulated by momentum)
 *   4. Centered power curve (per-axis exponent)
 *   5. EMA smoothing (frame-rate-independent)
 *   6. Momentum-as-zoom update (consumed next frame)
 *
 * `processInput` is a pure function over (raw, cfg, prev): returns the new
 * processed coordinate plus the next-frame state. Consumer (input-store)
 * holds the state and calls this each frame.
 *
 * Math is intentionally bit-for-bit equivalent to the legacy implementation.
 */
 import { clamp, curveCenteredPower } from './curves';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 export const ZOOM_MIN = 0.01;
 export const ZOOM_MAX = 1.0;
 export const FREEZE_THRESHOLD = ZOOM_MIN;
 export const DEADZONE_MAX = 0.4;
 export const INPUT_CURVE_MIN = 0.2;
 export const INPUT_CURVE_MAX = 5.0;
 export const SMOOTHING_MAX = 0.95;
 export const VELOCITY_WINDOW_DEFAULT = 150; // ms
 const REFERENCE_DT = 1 / 60;
 export type MomentumZoomMode = 'off' | 'gentle' | 'strong';
 export type AnchorMode = 'auto' | 'sticky' | 'center';
 interface MomentumPreset {
  factor: number;
  minZoomMul: number;
  maxZoomMul: number;
 }
 const MOMENTUM_PRESETS: Record<MomentumZoomMode, MomentumPreset | null> = {
  off: null,
  gentle: { factor: 0.6, minZoomMul: 0.3, maxZoomMul: 1.0 },
  strong: { factor: 1.5, minZoomMul: 0.15, maxZoomMul: 1.0 },
 };
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 export interface InputConfig {
  /** Global zoom level [0.01, 1.0] */
  zoom: number;
  /** Optional per-axis zoom; overrides global when not null */
  zoomX: number | null;
  zoomY: number | null;
  /** Anchor point [0,1]^2 (used in sticky/auto modes) */
  anchorX: number;
  anchorY: number;
  anchorMode: AnchorMode;
  /** Deadzone fraction of half-travel [0, 0.4] */
  deadzone: number;
  /** Centered power curve exponent [0.2, 5.0] (1.0 = linear) */
  inputCurve: number;
  inputCurveX: number | null;
  inputCurveY: number | null;
  /** EMA smoothing factor [0, 0.95] */
  smoothing: number;
  /** Momentum-as-zoom preset */
  momentumZoom: MomentumZoomMode;
  velocityWindow: number;
  /** Per-axis inversion */
  invertX: boolean;
  invertY: boolean;
 }
 export interface InputState {
  /** Last smoothed output x; seed at 0.5 */
  smoothedX: number;
  smoothedY: number;
  /** Velocity history ring used for momentum-zoom */
  velocityHistory: ReadonlyArray<{ x: number; y: number; t: number }>;
  /** Most recent momentum-zoom multiplier (1 = no scale) */
  momentumZoomMultiplier: number;
  /** Whether last process call returned frozen=true */
  frozen: boolean;
 }
 export interface ProcessResult {
  x: number;
  y: number;
  frozen: boolean;
  /** Next frame's state — consumer should keep this and pass it back. */
  state: InputState;
 }
 // ---------------------------------------------------------------------------
 // Defaults
 // ---------------------------------------------------------------------------
 export function defaultInputConfig(): InputConfig {
  return {
    zoom: 1.0,
    zoomX: null,
    zoomY: null,
    anchorX: 0.5,
    anchorY: 0.5,
    anchorMode: 'center',
    deadzone: 0,
    inputCurve: 1.0,
    inputCurveX: null,
    inputCurveY: null,
    smoothing: 0,
    momentumZoom: 'off',
    velocityWindow: VELOCITY_WINDOW_DEFAULT,
    invertX: false,
    invertY: false,
  };
 }
 export function defaultInputState(): InputState {
  return {
    smoothedX: 0.5,
    smoothedY: 0.5,
    velocityHistory: [],
    momentumZoomMultiplier: 1,
    frozen: false,
  };
 }
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function applyDeadzone(input: number, deadzone: number): number {
  if (deadzone <= 0) return input;
  const offset = input - 0.5;
  const absOff = Math.abs(offset);
  const halfDz = deadzone * 0.5;
  if (absOff <= halfDz) return 0.5;
  const sign = offset < 0 ? -1 : 1;
  const remapped = ((absOff - halfDz) / (0.5 - halfDz)) * 0.5;
  return 0.5 + sign * remapped;
 }
 function applyZoom(input: number, anchor: number, zoomLevel: number): number {
  return clamp(anchor + (input - 0.5) * zoomLevel, 0, 1);
 }
 function emaSmooth(prev: number, raw: number, smoothing: number, dt: number): number {
  if (smoothing <= 0) return raw;
  const effectiveDt = dt > 0 ? dt : REFERENCE_DT;
  const alpha = 1 - smoothing;
  const alphaEff = 1 - Math.pow(1 - alpha, effectiveDt / REFERENCE_DT);
  return prev + alphaEff * (raw - prev);
 }
 function updateMomentumZoomMultiplier(
  cfg: InputConfig,
  state: InputState,
  rawX: number,
  rawY: number,
  dt: number,
 ): { multiplier: number; history: InputState['velocityHistory'] } {
  const preset = MOMENTUM_PRESETS[cfg.momentumZoom];
  if (!preset) {
    return { multiplier: 1, history: [] };
  }
  const now = performance.now();
  const window = cfg.velocityWindow;
  // Append, drop entries older than `window` ms
  const trimmed = state.velocityHistory.filter((p) => now - p.t <= window);
  const newHist = [...trimmed, { x: rawX, y: rawY, t: now }];
  if (newHist.length < 2) {
    return { multiplier: 1, history: newHist };
  }
  const a = newHist[0]!;
  const b = newHist[newHist.length - 1]!;
  const dtMs = b.t - a.t;
  if (dtMs <= 0) return { multiplier: state.momentumZoomMultiplier, history: newHist };
  const dx = b.x - a.x;
  const dy = b.y - a.y;
  const dist = Math.sqrt(dx * dx + dy * dy);
  const speed = dist / (dtMs / 1000); // [0,1]-space units per second
  const normSpeed = clamp(speed * preset.factor, 0, 1);
  // Higher speed → smaller multiplier (zoom out faster movements)
  const target = preset.maxZoomMul - (preset.maxZoomMul - preset.minZoomMul) * normSpeed;
  // Smooth toward target so the zoom doesn't jitter
  const smoothCoeff = clamp(dt * 6, 0, 1);
  const next = state.momentumZoomMultiplier + smoothCoeff * (target - state.momentumZoomMultiplier);
  return { multiplier: next, history: newHist };
 }
 function resolveAnchorX(cfg: InputConfig, state: InputState): number {
  if (cfg.anchorMode === 'center') return 0.5;
  if (cfg.anchorMode === 'sticky') return cfg.anchorX;
  // auto: use stored anchor (input-store updates it on zoom changes)
  return cfg.anchorX;
 }
 function resolveAnchorY(cfg: InputConfig, state: InputState): number {
  if (cfg.anchorMode === 'center') return 0.5;
  if (cfg.anchorMode === 'sticky') return cfg.anchorY;
  return cfg.anchorY;
 }
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 /**
 * Process raw 2D input through the pipeline.
 *
 * @param raw    raw input [x, y] in [0,1]
 * @param cfg    pipeline configuration
 * @param state  prior state (use {@link defaultInputState} on first call)
 * @param dt     seconds since last call (default 1/60)
 */
 export function processInput(
  raw: readonly [number, number],
  cfg: InputConfig,
  state: InputState,
  dt: number = REFERENCE_DT,
 ): ProcessResult {
  const safeDt = Math.max(0, dt);
  const baseZoomX = cfg.zoomX ?? cfg.zoom;
  const baseZoomY = cfg.zoomY ?? cfg.zoom;
  const frozenX = baseZoomX <= FREEZE_THRESHOLD;
  const frozenY = baseZoomY <= FREEZE_THRESHOLD;
  const fullyFrozen = frozenX && frozenY;
  if (fullyFrozen) {
    return {
      x: state.smoothedX,
      y: state.smoothedY,
      frozen: true,
      state: { ...state, frozen: true },
    };
  }
  let [rawX, rawY] = raw;
  // 0. Invert
  let x = cfg.invertX ? 1 - rawX : rawX;
  let y = cfg.invertY ? 1 - rawY : rawY;
  // 1. Deadzone
  x = applyDeadzone(x, cfg.deadzone);
  y = applyDeadzone(y, cfg.deadzone);
  // 2. Circular clamp to unit disk centered at (0.5, 0.5)
  {
    const cx = x - 0.5;
    const cy = y - 0.5;
    const dist = Math.sqrt(cx * cx + cy * cy);
    if (dist > 0.5 && dist > 1e-12) {
      const scale = 0.5 / dist;
      x = 0.5 + cx * scale;
      y = 0.5 + cy * scale;
    }
  }
  // 3. Zoom around anchor (with momentum modulation)
  const anchorX = resolveAnchorX(cfg, state);
  const anchorY = resolveAnchorY(cfg, state);
  const effZoomX = frozenX
    ? FREEZE_THRESHOLD
    : clamp(baseZoomX * state.momentumZoomMultiplier, ZOOM_MIN, ZOOM_MAX);
  const effZoomY = frozenY
    ? FREEZE_THRESHOLD
    : clamp(baseZoomY * state.momentumZoomMultiplier, ZOOM_MIN, ZOOM_MAX);
  x = frozenX ? state.smoothedX : applyZoom(x, anchorX, effZoomX);
  y = frozenY ? state.smoothedY : applyZoom(y, anchorY, effZoomY);
  // 4. Centered power curve
  const curveX = cfg.inputCurveX ?? cfg.inputCurve;
  const curveY = cfg.inputCurveY ?? cfg.inputCurve;
  if (!frozenX) x = curveCenteredPower(x, curveX);
  if (!frozenY) y = curveCenteredPower(y, curveY);
  // 5. EMA smoothing
  const smoothedX = frozenX ? state.smoothedX : emaSmooth(state.smoothedX, x, cfg.smoothing, safeDt);
  const smoothedY = frozenY ? state.smoothedY : emaSmooth(state.smoothedY, y, cfg.smoothing, safeDt);
  // 6. Update momentum-zoom for next frame
  const { multiplier, history } = updateMomentumZoomMultiplier(cfg, state, rawX, rawY, safeDt);
  return {
    x: smoothedX,
    y: smoothedY,
    frozen: false,
    state: {
      smoothedX,
      smoothedY,
      velocityHistory: history,
      momentumZoomMultiplier: multiplier,
      frozen: false,
    },
  };
 }
--- a/manifold/src/engine/output-pipeline.ts
+++ b/manifold/src/engine/output-pipeline.ts
@ -1,153 +0,0 @@
 /**
 * Output pipeline — pure TS port of legacy `js/ui/output-pipeline.js`.
 *
 * Stages (in order) for each output:
 *   1. Global power curve (raw^exponent, exponent in [0.2, 5.0])
 *   2. Per-output EMA smoothing (frame-rate-independent)
 *   3. Slew-rate limiting (max change per second per output)
 *   4. Freeze gate (global) and per-output freeze mask
 *
 * `processOutput` is a pure function: takes the raw output vector, the prior
 * processed vector (or null on first call), and config; returns a new
 * Float32Array. Consumer (output-store) holds prev between frames.
 *
 * NOTE: Reuses an internal scratch buffer ONLY when a prev buffer of the
 * exact same length is supplied AND `cfg.reuseBuffer === true`. Otherwise it
 * allocates a fresh Float32Array (safer for cross-component sharing).
 */
 import { clamp, clamp01 } from './curves';
 export const GLOBAL_CURVE_MIN = 0.2;
 export const GLOBAL_CURVE_MAX = 5.0;
 export const SMOOTHING_MAX = 0.95;
 export const SLEW_RATE_MIN = 0.005;
 const REFERENCE_DT = 1 / 60;
 export interface OutputConfig {
  /** Power curve exponent applied to ALL outputs. 1 = linear. */
  globalCurve: number;
  /** EMA smoothing factor [0, 0.95]. */
  smoothing: number;
  /** Max change per second per output. Infinity = unlimited. */
  slewRate: number;
  /** Global freeze gate. */
  freezeOutput: boolean;
  /** Per-output freeze mask (1 = frozen). Length must match output vector. */
  freezeMask: Uint8Array | null;
  /** If true and prev buffer matches length, reuse it for processed output. */
  reuseBuffer: boolean;
 }
 export interface OutputState {
  /** Last processed output (kept here for slew/freeze logic). */
  prev: Float32Array | null;
  /** Last EMA-smoothed values per output. */
  smoothed: Float32Array | null;
 }
 export function defaultOutputConfig(): OutputConfig {
  return {
    globalCurve: 1.0,
    smoothing: 0,
    slewRate: Infinity,
    freezeOutput: false,
    freezeMask: null,
    reuseBuffer: false,
  };
 }
 export function defaultOutputState(): OutputState {
  return { prev: null, smoothed: null };
 }
 function emaSmooth(prev: number, raw: number, smoothing: number, dt: number): number {
  if (smoothing <= 0) return raw;
  const effectiveDt = dt > 0 ? dt : REFERENCE_DT;
  const alpha = 1 - smoothing;
  const alphaEff = 1 - Math.pow(1 - alpha, effectiveDt / REFERENCE_DT);
  return prev + alphaEff * (raw - prev);
 }
 /**
 * Process raw outputs through global curve → smoothing → slew → freeze gate.
 *
 * @param raw      raw output vector (Float32Array of size N)
 * @param cfg      pipeline config
 * @param state    prior state (use {@link defaultOutputState} first call)
 * @param dtMs     time since last call in milliseconds
 * @returns        { processed, state } with the new outputs and updated state
 */
 export function processOutput(
  raw: Float32Array,
  cfg: OutputConfig,
  state: OutputState,
  dtMs: number,
 ): { processed: Float32Array; state: OutputState } {
  const n = raw.length;
  const dt = Math.max(0, dtMs / 1000);
  let prev = state.prev;
  let smoothed = state.smoothed;
  if (!prev || prev.length !== n) {
    prev = new Float32Array(n);
    // Seed from raw on first call
    for (let i = 0; i < n; i++) prev[i] = clamp01(raw[i] ?? 0);
  }
  if (!smoothed || smoothed.length !== n) {
    smoothed = new Float32Array(n);
    for (let i = 0; i < n; i++) smoothed[i] = clamp01(raw[i] ?? 0);
  }
  let processed: Float32Array;
  if (cfg.reuseBuffer && prev.length === n) {
    processed = prev;
  } else {
    processed = new Float32Array(n);
  }
  // Stage 1: global curve (mutates a working scratch via direct compute)
  const exp = cfg.globalCurve;
  if (cfg.freezeOutput) {
    // Output frozen: hold prior values.
    if (processed !== prev) {
      processed.set(prev);
    }
    return { processed, state: { prev: processed, smoothed } };
  }
  for (let i = 0; i < n; i++) {
    const r = clamp01(raw[i] ?? 0);
    const curved = exp === 1.0 ? r : Math.pow(r, exp);
    // Per-output freeze
    if (cfg.freezeMask && cfg.freezeMask[i]) {
      processed[i] = prev[i] ?? curved;
      continue;
    }
    // Stage 2: EMA smoothing
    let value = emaSmooth(smoothed[i] ?? curved, curved, cfg.smoothing, dt);
    smoothed[i] = value;
    // Stage 3: slew-rate limit
    if (isFinite(cfg.slewRate) && cfg.slewRate > 0) {
      const maxDelta = cfg.slewRate * dt;
      const delta = value - (prev[i] ?? value);
      if (Math.abs(delta) > maxDelta) {
        value = (prev[i] ?? value) + Math.sign(delta) * maxDelta;
      }
    }
    processed[i] = clamp01(value);
  }
  // Update prev for next call
  if (processed !== prev) {
    prev = new Float32Array(processed); // copy so caller can hold processed buffer freely
  }
  return { processed, state: { prev, smoothed } };
 }
--- a/manifold/src/engine/pipeline-types.ts
+++ b/manifold/src/engine/pipeline-types.ts
@ -0,0 +1,117 @@
 /**
 * Pipeline config types (one-core-engine P4).
 *
 * The input/output PROCESSING now lives in the C++/WASM core
 * (nisps/pipeline/{input,output}_chain.hpp); state is owned C++-side per
 * pipeline handle. These are the TS-side CONFIG shapes the front-end fills in
 * and the spine forwards into the WASM wrappers (WasmIML.setInputConfig /
 * setOutputConfig). No behaviour maths lives here — this is a types-only module
 * plus pure defaults, the residue of the deleted input-pipeline.ts /
 * output-pipeline.ts.
 *
 * The 15-float input wire layout the config maps onto is documented in
 * nisps/wasm/bindings.cpp (nisps_input_set_config).
 */
 export type MomentumZoomMode = 'off' | 'gentle' | 'strong';
 export type AnchorMode = 'auto' | 'sticky' | 'center';
 /** Config-range constants (UI clamps + defaults). Kept for the front-end. */
 export const ZOOM_MIN = 0.01;
 export const ZOOM_MAX = 1.0;
 export const FREEZE_THRESHOLD = ZOOM_MIN;
 export const DEADZONE_MAX = 0.4;
 export const INPUT_CURVE_MIN = 0.2;
 export const INPUT_CURVE_MAX = 5.0;
 export const SMOOTHING_MAX = 0.95;
 export const VELOCITY_WINDOW_DEFAULT = 150; // ms
 export const GLOBAL_CURVE_MIN = 0.2;
 export const GLOBAL_CURVE_MAX = 5.0;
 export const SLEW_RATE_MIN = 0.005;
 export interface InputConfig {
  /** Global zoom level [0.01, 1.0]. */
  zoom: number;
  /** Optional per-axis zoom; overrides global when not null. */
  zoomX: number | null;
  zoomY: number | null;
  /** Anchor point [0,1]^2 (used in sticky/auto modes). */
  anchorX: number;
  anchorY: number;
  anchorMode: AnchorMode;
  /** Deadzone fraction of half-travel [0, 0.4]. */
  deadzone: number;
  /** Centred power curve exponent [0.2, 5.0] (1.0 = linear). */
  inputCurve: number;
  inputCurveX: number | null;
  inputCurveY: number | null;
  /** EMA smoothing factor [0, 0.95]. */
  smoothing: number;
  /** Momentum-as-zoom preset. */
  momentumZoom: MomentumZoomMode;
  /** Velocity window in MILLISECONDS (mapped to seconds at the wire). */
  velocityWindow: number;
  /** Per-axis inversion. */
  invertX: boolean;
  invertY: boolean;
 }
 export interface OutputConfig {
  /** Power curve exponent applied to ALL outputs. 1 = linear. */
  globalCurve: number;
  /** EMA smoothing factor [0, 0.95]. */
  smoothing: number;
  /** Max change per second per output. Infinity = unlimited (→ 0 at the wire). */
  slewRate: number;
  /** Global freeze gate. */
  freezeOutput: boolean;
  /** Per-output freeze mask (1 = frozen). null clears it. */
  freezeMask: Uint8Array | null;
 }
 /** Result of one input-pipeline step (mirrors the C++ InputChainResult). */
 export interface InputProcessResult {
  x: number;
  y: number;
  frozen: boolean;
 }
 export function defaultInputConfig(): InputConfig {
  return {
    zoom: 1.0,
    zoomX: null,
    zoomY: null,
    anchorX: 0.5,
    anchorY: 0.5,
    anchorMode: 'center',
    deadzone: 0,
    inputCurve: 1.0,
    inputCurveX: null,
    inputCurveY: null,
    smoothing: 0,
    momentumZoom: 'off',
    velocityWindow: VELOCITY_WINDOW_DEFAULT,
    invertX: false,
    invertY: false,
  };
 }
 export function defaultOutputConfig(): OutputConfig {
  return {
    globalCurve: 1.0,
    smoothing: 0,
    slewRate: Infinity,
    freezeOutput: false,
    freezeMask: null,
  };
 }
 /** anchorMode string → wire int (0 auto / 1 sticky / 2 centre). */
 export function anchorModeToInt(m: AnchorMode): number {
  return m === 'sticky' ? 1 : m === 'center' ? 2 : 0;
 }
 /** momentumZoom string → wire int (0 off / 1 gentle / 2 strong). */
 export function momentumModeToInt(m: MomentumZoomMode): number {
  return m === 'gentle' ? 1 : m === 'strong' ? 2 : 0;
 }
--- a/manifold/src/engine/spine.ts
+++ b/manifold/src/engine/spine.ts
@ -6,9 +6,9 @@
 * which recomputes on Solid's reactive graph. In React we must NOT couple the
 * per-frame audio inference to the render scheduler. So the spine is a tiny
 * hand-rolled observable: the `setInput` ACTION derives processed → ml → routed
- * EAGERLY + SYNCHRONOUSLY (input pipeline → WasmIML.processInto → output
+ * EAGERLY + SYNCHRONOUSLY (WasmIML.processInput → processInto → processOutput,
- * pipeline) and fires the single `backend.send` at the action TAIL, off React's
+ * all C++/WASM chains since one-core-engine P4) and fires the single
- * render cycle.
+ * `backend.send` at the action TAIL, off React's render cycle.
 *
 * React subscribes via `useSyncExternalStore(subscribe, version)` — the version
 * counter, NOT the array — and reads the live `Float32Array` imperatively (so
@ -20,18 +20,10 @@
 import {
  defaultInputConfig,
  defaultInputState,
  processInput,
  type InputConfig,
  type InputState,
 } from './input-pipeline';
 import {
  defaultOutputConfig,
-  defaultOutputState,
+  type InputConfig,
  processOutput,
  type OutputConfig,
-  type OutputState,
+} from './pipeline-types';
 } from './output-pipeline';
 import type { EngineSink, EngineStatePatch } from './sink';
 import type { WasmIML } from './wasm-iml';
@ -83,11 +75,13 @@ export class Spine implements EngineSink {
  private iml: WasmIML | null = null;
  private backendSend: BackendSend | null = null;
-  // Pipeline config + per-frame state.
+  // Pipeline config (source of truth on the TS side). The PROCESSING + per-frame
-  inputConfig: InputConfig = defaultInputConfig();
+  // state live C++-side per pipeline handle (one-core-engine P4); the spine
-  outputConfig: OutputConfig = { ...defaultOutputConfig(), reuseBuffer: true };
+  // forwards config into the WASM wrappers via {@link setInputConfig} /
-  private inputState: InputState = defaultInputState();
+  // {@link setOutputConfig} and drives the chains each tick. Reads default until
-  private outputState: OutputState = defaultOutputState();
+  // a UI control sets them.
  private inputConfig_: InputConfig = defaultInputConfig();
  private outputConfig_: OutputConfig = defaultOutputConfig();
  // Reused per-frame buffers — NO per-frame allocation in the hot path.
  private rawInput: [number, number] = [0.5, 0.5];
@ -179,6 +173,45 @@ export class Spine implements EngineSink {
    if (this.routedBuf === null || this.routedBuf.length !== iml.architecture.outputSize) {
      this.routedBuf = new Float32Array(iml.architecture.outputSize);
    }
    // Push the current config into the freshly-created C++ pipeline handle and
    // reset its state (smoothing/velocity ring/prev buffers seed on first tick).
    this.pushInputConfig_();
    this.pushOutputConfig_();
    iml.resetInput();
    iml.resetOutput();
  }
  // ---- Pipeline config (forwarded into the WASM chains) --------------
  get inputConfig(): Readonly<InputConfig> { return this.inputConfig_; }
  get outputConfig(): Readonly<OutputConfig> { return this.outputConfig_; }
  /** Replace the input-pipeline config and push it C-side. */
  setInputConfig(cfg: InputConfig): void {
    this.inputConfig_ = cfg;
    this.pushInputConfig_();
  }
  /** Replace the output-pipeline config (scalar params + freeze mask) and push
   *  it C-side. */
  setOutputConfig(cfg: OutputConfig): void {
    this.outputConfig_ = cfg;
    this.pushOutputConfig_();
  }
  private pushInputConfig_(): void {
    if (this.iml) this.iml.setInputConfig(this.inputConfig_);
  }
  private pushOutputConfig_(): void {
    if (!this.iml) return;
    this.iml.setOutputConfig({
      globalCurve: this.outputConfig_.globalCurve,
      smoothing: this.outputConfig_.smoothing,
      slewRate: this.outputConfig_.slewRate,
      freezeOutput: this.outputConfig_.freezeOutput,
    });
    this.iml.setOutputFreezeMask(this.outputConfig_.freezeMask);
  }
  setBackendSend(backendSend: BackendSend | null): void {
@ -232,8 +265,7 @@ export class Spine implements EngineSink {
    this.rawInput[1] = y;
    this.lastRawX = x;
    this.lastRawY = y;
-    const proc = processInput(this.rawInput, this.inputConfig, this.inputState, dt);
+    const proc = iml.processInput(x, y, dt);
    this.inputState = proc.state;
    iml.setInput(0, proc.x);
    iml.setInput(1, proc.y);
@ -252,15 +284,12 @@ export class Spine implements EngineSink {
    iml.processInto(this.mlBuf);
    this.liveOutputs.set(this.mlBuf.subarray(0, this.liveOutputs.length));
-    // 4. routed (output pipeline → reused routedBuf).
+    // 4. routed (output chain, in place on the reused routedBuf → C++-side state).
-    const routedRes = processOutput(this.mlBuf, this.outputConfig, this.outputState, dt * 1000);
+    if (!this.routedBuf || this.routedBuf.length !== this.mlBuf.length) {
-    this.outputState = routedRes.state;
+      this.routedBuf = new Float32Array(this.mlBuf.length);
    const routed = routedRes.processed;
    if (this.routedBuf && this.routedBuf.length === routed.length) {
      this.routedBuf.set(routed);
    } else {
      this.routedBuf = routed;
    }
    this.routedBuf.set(this.mlBuf);
    iml.processOutput(this.routedBuf, dt);
    // 4b. optional exploration morph on the routed vector (OU noise). Inert
    //     unless a controller has registered one AND it is turned up.
--- a/manifold/src/engine/types.ts
+++ b/manifold/src/engine/types.ts
@ -129,6 +129,32 @@ export interface NispsModule {
  _nisps_ml_explore_get_intensity(ml: number): number;
  _nisps_ml_explore_apply(ml: number, inout_ptr: number, n: number): void;
  // Pipelines (one-core-engine P4). Input/output processing chains; state lives
  // C++-side per pipeline handle. Input config is a 15-float wire buffer (layout
  // documented in nisps/wasm/bindings.cpp). Output config: globalCurve,
  // smoothing, slewRate (<=0 ⇒ unlimited), freeze (0/1). Both process calls take
  // dt in SECONDS.
  _nisps_pipeline_create(): number;
  _nisps_pipeline_destroy(p: number): void;
  _nisps_input_set_config(p: number, cfg_ptr: number, n: number): void;
  // Returns 1 when the chain is frozen; writes {x,y} into out_xy_ptr (2 floats).
  _nisps_input_process(p: number, x: number, y: number, dt_s: number, out_xy_ptr: number): number;
  _nisps_input_reset(p: number): void;
  _nisps_output_set_config(p: number, global_curve: number, smoothing: number, slew_rate: number, freeze: number): void;
  _nisps_output_set_freeze_mask(p: number, mask_ptr: number, n: number): void;
  // In place: processes the first n floats of inout_ptr.
  _nisps_output_process(p: number, inout_ptr: number, n: number, dt_s: number): void;
  _nisps_output_reset(p: number): void;
  _nisps_pipeline_state_size(p: number): number;
  _nisps_pipeline_save_state(p: number, out_ptr: number): void;
  _nisps_pipeline_load_state(p: number, in_ptr: number, n: number): void;
  // Curve catalog (one-core-engine P4). ids 0..6 = nisps::Curve (param ignored);
  // id 7 = centred power (param = exponent). nisps/core/math.hpp is the single
  // source of truth; the browser samples it instead of mirroring the maths.
  _nisps_curve_apply(id: number, x: number, param: number): number;
  _nisps_curve_apply_batch(id: number, xs_ptr: number, out_ptr: number, n: number, param: number): void;
  // Engines.
  _nisps_engine_create(id_ptr: number, sample_rate: number): number;
  _nisps_engine_destroy(engine: number): void;
--- a/manifold/src/engine/wasm-iml.ts
+++ b/manifold/src/engine/wasm-iml.ts
@ -19,6 +19,13 @@
 */
 import { Dataset } from './dataset';
 import {
  anchorModeToInt,
  momentumModeToInt,
  type InputConfig,
  type InputProcessResult,
  type OutputConfig,
 } from './pipeline-types';
 import { noopSink, type EngineSink } from './sink';
 import {
  FEEDBACK_MODE_FROM_INT,
@ -136,6 +143,16 @@ export class WasmIML {
  private feedbackBuf!: HeapBuffer; // kDefaultOutputs scratch for feedback static/down
  private describePtr = 0;
  // Pipeline (one-core-engine P4): the input/output processing chains live
  // C++-side per handle. These wrappers own the handle + bridge buffers.
  private pipelineHandle = 0;
  private inCfgBuf!: HeapBuffer;   // 15-float input config wire buffer
  private inXYBuf!: HeapBuffer;    // 2-float processed-input scratch
  private outProcBuf!: HeapBuffer; // outputSize scratch for in-place output processing
  private pipeMaskBuf!: HeapU8;    // outputSize per-output freeze mask
  private curveBuf!: HeapBuffer;   // curve batch scratch (chunked)
  private static CURVE_CHUNK = 256;
  readonly dataset: Dataset;
  private readonly sink: EngineSink;
  private lastLoss_: number | null = null;
@ -197,6 +214,15 @@ export class WasmIML {
    this.pinMaskBuf = new HeapU8(this.module, this.arch_.outputSize);
    this.feedbackBuf = new HeapBuffer(this.module, this.arch_.outputSize);
    // Pipeline handle + bridge buffers (input/output chains, curve batch).
    this.pipelineHandle = this.module._nisps_pipeline_create();
    if (!this.pipelineHandle) throw new Error('[wasm-iml] nisps_pipeline_create returned null');
    this.inCfgBuf = new HeapBuffer(this.module, 15);
    this.inXYBuf = new HeapBuffer(this.module, 2);
    this.outProcBuf = new HeapBuffer(this.module, this.arch_.outputSize);
    this.pipeMaskBuf = new HeapU8(this.module, this.arch_.outputSize);
    this.curveBuf = new HeapBuffer(this.module, WasmIML.CURVE_CHUNK);
    this.sink.setState({
      inputSize: this.arch_.inputSize,
      outputSize: this.arch_.outputSize,
@ -239,6 +265,15 @@ export class WasmIML {
    if (this.batchOutBuf) this.batchOutBuf.free();
    if (this.pinMaskBuf) this.pinMaskBuf.free();
    if (this.feedbackBuf) this.feedbackBuf.free();
    if (this.module && this.pipelineHandle) {
      this.module._nisps_pipeline_destroy(this.pipelineHandle);
      this.pipelineHandle = 0;
    }
    if (this.inCfgBuf) this.inCfgBuf.free();
    if (this.inXYBuf) this.inXYBuf.free();
    if (this.outProcBuf) this.outProcBuf.free();
    if (this.pipeMaskBuf) this.pipeMaskBuf.free();
    if (this.curveBuf) this.curveBuf.free();
    if (this.describePtr) this.module._free(this.describePtr);
    this.sink.setState({ ready: false });
  }
@ -313,6 +348,8 @@ export class WasmIML {
    this.batchOutBuf.free();
    this.pinMaskBuf.free();
    this.feedbackBuf.free();
    this.outProcBuf.free();
    this.pipeMaskBuf.free();
    this.featuresBuf = new HeapBuffer(this.module, this.arch_.inputSize);
    this.labelsBuf = new HeapBuffer(this.module, this.arch_.outputSize);
    this.weightsBuf = new HeapBuffer(this.module, this.weightCount_);
@ -321,6 +358,8 @@ export class WasmIML {
    this.batchOutBuf = new HeapBuffer(this.module, WasmIML.MAX_BATCH * this.arch_.outputSize);
    this.pinMaskBuf = new HeapU8(this.module, this.arch_.outputSize);
    this.feedbackBuf = new HeapBuffer(this.module, this.arch_.outputSize);
    this.outProcBuf = new HeapBuffer(this.module, this.arch_.outputSize);
    this.pipeMaskBuf = new HeapU8(this.module, this.arch_.outputSize);
    this.featuresBuf.rebind();
    this.labelsBuf.rebind();
    this.weightsBuf.rebind();
@ -329,6 +368,13 @@ export class WasmIML {
    this.batchOutBuf.rebind();
    this.pinMaskBuf.rebind();
    this.feedbackBuf.rebind();
    this.outProcBuf.rebind();
    this.pipeMaskBuf.rebind();
    // Fixed-size pipeline buffers were not reallocated but a grow above may have
    // detached their views — rebind so later writes hit the live heap.
    this.inCfgBuf.rebind();
    this.inXYBuf.rebind();
    this.curveBuf.rebind();
    // C-side dataset/examples reset on reshape → clear the TS mirror to match.
    this.dataset.clear();
@ -424,6 +470,100 @@ export class WasmIML {
    return result;
  }
  // -------------------------------------------------------------------
  // Pipelines (one-core-engine P4). Thin wrappers over the C++ input/output
  // chains; state lives C++-side per pipeline handle. The spine drives these
  // each tick; config is pushed on change.
  // -------------------------------------------------------------------
  /** Map a TS InputConfig onto the 15-float wire layout and push it C-side. */
  setInputConfig(cfg: InputConfig): void {
    const v = this.inCfgBuf.view;
    v[0] = cfg.zoom;
    v[1] = cfg.zoomX ?? 0;          // 0 ⇒ null (use global zoom)
    v[2] = cfg.zoomY ?? 0;
    v[3] = cfg.anchorX;
    v[4] = cfg.anchorY;
    v[5] = anchorModeToInt(cfg.anchorMode);
    v[6] = cfg.deadzone;
    v[7] = cfg.inputCurve;
    v[8] = cfg.inputCurveX ?? 0;    // 0 ⇒ null (use inputCurve)
    v[9] = cfg.inputCurveY ?? 0;
    v[10] = cfg.smoothing;
    v[11] = momentumModeToInt(cfg.momentumZoom);
    v[12] = cfg.velocityWindow / 1000; // ms → SECONDS
    v[13] = cfg.invertX ? 1 : 0;
    v[14] = cfg.invertY ? 1 : 0;
    this.module._nisps_input_set_config(this.pipelineHandle, this.inCfgBuf.ptr, 15);
  }
  /** Process one raw [0,1] XY sample through the input chain. `dtSeconds` =
   *  seconds since the previous call (0 falls back to the reference dt C-side). */
  processInput(x: number, y: number, dtSeconds: number): InputProcessResult {
    const frozen = this.module._nisps_input_process(
      this.pipelineHandle, x, y, dtSeconds, this.inXYBuf.ptr,
    );
    return { x: this.inXYBuf.view[0], y: this.inXYBuf.view[1], frozen: frozen === 1 };
  }
  resetInput(): void {
    this.module._nisps_input_reset(this.pipelineHandle);
  }
  /** Push the output-chain scalar config. `slewRate` Infinity → 0 (unlimited). */
  setOutputConfig(cfg: { globalCurve: number; smoothing: number; slewRate: number; freezeOutput: boolean }): void {
    const slew = Number.isFinite(cfg.slewRate) ? cfg.slewRate : 0;
    this.module._nisps_output_set_config(
      this.pipelineHandle, cfg.globalCurve, cfg.smoothing, slew, cfg.freezeOutput ? 1 : 0,
    );
  }
  /** Per-output freeze mask (1 = frozen). null / empty clears it. */
  setOutputFreezeMask(mask: Uint8Array | null): void {
    if (!mask || mask.length === 0) {
      this.module._nisps_output_set_freeze_mask(this.pipelineHandle, 0, 0);
      return;
    }
    const n = Math.min(mask.length, this.pipeMaskBuf.count);
    this.pipeMaskBuf.view.set(mask.subarray(0, n));
    this.module._nisps_output_set_freeze_mask(this.pipelineHandle, this.pipeMaskBuf.ptr, n);
  }
  /** Process `vec` (first n ≤ outputSize floats) through the output chain IN
   *  PLACE. `dtSeconds` = seconds since the previous call. */
  processOutput(vec: Float32Array, dtSeconds: number): void {
    const n = Math.min(vec.length, this.outProcBuf.count);
    if (n <= 0) return;
    this.outProcBuf.view.set(vec.subarray(0, n));
    this.module._nisps_output_process(this.pipelineHandle, this.outProcBuf.ptr, n, dtSeconds);
    vec.set(this.outProcBuf.view.subarray(0, n));
  }
  resetOutput(): void {
    this.module._nisps_output_reset(this.pipelineHandle);
  }
  // ---- Curve catalog (stateless; nisps/core/math.hpp is the source of truth) --
  /** Sample one curve. id 0..6 = nisps::Curve (param ignored); id 7 = centred
   *  power (param = exponent). */
  curveApply(id: number, x: number, param = 0): number {
    return this.module._nisps_curve_apply(id, x, param);
  }
  /** Batch-sample a curve over `xs` into `out` (chunked through a heap scratch).
   *  Use for previews / bulk shaping — one call per frame, not one per value. */
  curveApplyBatch(id: number, xs: ArrayLike<number>, out: Float32Array, param = 0): void {
    const total = Math.min(xs.length, out.length);
    const chunk = this.curveBuf.count;
    for (let offset = 0; offset < total; offset += chunk) {
      const n = Math.min(chunk, total - offset);
      for (let i = 0; i < n; ++i) this.curveBuf.view[i] = xs[offset + i];
      this.module._nisps_curve_apply_batch(id, this.curveBuf.ptr, this.curveBuf.ptr, n, param);
      out.set(this.curveBuf.view.subarray(0, n), offset);
    }
  }
  // -------------------------------------------------------------------
  // Training
  // -------------------------------------------------------------------
--- a/manifold/tests/fixtures/README.md
+++ b/manifold/tests/fixtures/README.md
@ -1,71 +1,92 @@
 # Pipeline golden fixtures
-**Captured 2026-07-13** from the current **TypeScript** engine implementations,
+Originally captured **2026-07-13** from the TypeScript engine implementations,
 **before** the P4 "one core engine" migration
-(`docs/specs/plans/one-core-engine-refactor.md` §P4) replaces the TS
+(`docs/specs/plans/one-core-engine-refactor.md` §P4). As of **2026-07-18** that
-curve/input/output code with calls into the C++/WASM core.
+migration has landed: the curve / input-pipeline / output-pipeline maths now
 live solely in the C++/WASM core (`nisps/pipeline/*`, `nisps/core/math.hpp`),
 and the TS `curves.ts` / `input-pipeline.ts` / `output-pipeline.ts` are deleted.
-P4's own gate reads: *"recorded-gesture regression: same pointer trace → same
+These fixtures are the recorded-gesture pre/post-migration regression P4's gate
-routed output pre/post migration (capture fixture before starting)."* These
+calls for: *"same pointer trace → same routed output pre/post migration."* The
-files are that capture.
+test (`../pipeline-golden.test.ts`) now drives the WASM chains against them.
 ## What is here
-| File | What it pins | Source under test |
+| File | What it pins | Driven through (now) |
 |---|---|---|
-| `gesture-trace.json` | One canonical synthetic pointer trace (288 events, fixed 120 Hz dt) over the input pipeline's native `[0,1]²` domain: h/v sweeps, diagonal, spiral, figure-eight, dwell + abrupt corner jumps. Pure formula — no `Math.random`, no `Date.now`. | (input to the input pipeline) |
+| `gesture-trace.json` | One canonical synthetic pointer trace (288 events, fixed 120 Hz dt) over the input pipeline's native `[0,1]²` domain: h/v sweeps, diagonal, spiral, figure-eight, dwell + abrupt corner jumps. Pure formula — no `Math.random`, no `Date.now`. | (input to the input chain) |
-| `curves-golden.json` | `applyCurve(name, x)` for every curve id in `curves.ts`, 129 samples of `x ∈ [0,1]` inclusive, at each curve's default `param`. | `src/engine/curves.ts` |
+| `curves-golden.json` | The curve catalog, 129 samples of `x ∈ [0,1]` inclusive. **See "Curves re-baselined" below.** | `nisps_curve_apply` (WASM) |
-| `input-pipeline-golden.json` | The gesture trace run through `processInput` under 14 representative configs (default, deadzone, zoom, sticky anchor, per-axis, curves, smoothing, invert, momentum gentle/strong, frozen axis, fully frozen, combined). Records `{x, y, frozen}` per event. Configs embedded. | `src/engine/input-pipeline.ts` |
+| `input-pipeline-golden.json` | The gesture trace run through the input pipeline under 14 representative configs (default, deadzone, zoom, sticky anchor, per-axis, curves, smoothing, invert, momentum gentle/strong, frozen axis, fully frozen, combined). Records `{x, y, frozen}` per event. Configs embedded. **FROZEN** pre-migration capture. | `nisps_input_*` (WASM) |
-| `output-pipeline-golden.json` | A deterministic raw-output sequence (120 vectors × 8 channels of offset sines, quantised to f32) run through `processOutput` under 8 configs (default, curves, smoothing, slew limiting, global-freeze toggled mid-sequence, per-output freeze mask, combined). Records the processed vector per step. Configs embedded. | `src/engine/output-pipeline.ts` |
+| `output-pipeline-golden.json` | A deterministic raw-output sequence (120 vectors × 8 channels of offset sines, quantised to f32) run through the output pipeline under 8 configs (default, curves, smoothing, slew, global-freeze toggled mid-sequence, per-output freeze mask, combined). Records the processed vector per step. Configs embedded. **FROZEN** pre-migration capture. | `nisps_output_*` (WASM) |
-## The drift guard
+## The regression guard
-`../pipeline-golden.test.ts` (`bun test`) re-runs the **current** TS
+`../pipeline-golden.test.ts` (`bun test`) loads the built WASM
-implementations against these fixtures and asserts equality within **1e-9**. It
+(`../../public/nisps.{js,wasm}`) via the indirect-eval shim (`../wasm-load.ts`,
-reads the trace, raw sequence, and configs **from the JSON** — the fixtures are
+same technique as `tests/cpp/parity_wasm.mjs`), creates a pipeline handle, and
-authoritative, so editing `pipeline-golden-lib.ts` config lists cannot mask a
+re-runs the **committed fixtures** through the C++ chains. The fixtures are
-regression. Any change to `curves.ts` / `input-pipeline.ts` / `output-pipeline.ts`
+authoritative: the trace, raw sequence, and per-run configs are read FROM the
-that alters numeric behaviour breaks this test until the goldens are
+JSON, so the config lists in `pipeline-golden-lib.ts` cannot mask a regression.
 deliberately re-captured.
-To re-capture (only when intended): `cd manifold && bun tests/fixtures/_generate.ts`.
+### Tolerances (f32 WASM vs f64-captured fixtures)
 - **Input / output pipelines: `1e-5`.** Measured max non-momentum drift `<5e-7`.
 - **Momentum configs (`momentum-gentle` / `momentum-strong` / `combined`):
  `1e-2`.** This is proven-inherent f32 drift, **not** a core bug. The velocity
  ring's window-membership test (`now − t ≤ window`) is a DISCRETE boundary that
  f32 rounding can flip during fast gestures, shifting which sample is the
  window's oldest by a whole frame (~8 ms) → a step change in the measured speed
  → integrated by the momentum-zoom IIR. A byte-faithful f32 port of the exact
  original TS algorithm reproduces the WASM to `<6e-8` while both diverge from
  the f64 capture by the same `~7–9e-3` (measured max `8.6e-3` on
  momentum-strong). Reconciling it would require f64 momentum maths, which would
  break firmware parity — so the momentum runs are guarded at `1e-2` (the core
  is still tightly pinned to the algorithm by the `<6e-8` faithful-f32 identity;
  a real behavioural regression would blow far past `1e-2`).
 ## Curves re-baselined (2026-07-18)
 `curves-golden.json` is now a MIX, recorded in its `provenance` field:
 - **`linear` / `square` / `sqrt` / `centered_power`** — the ORIGINAL 2026-07-13
  f64 TS captures, kept unchanged. The C++ core reproduces them within `1e-5`
  (measured `<3e-8`), proving **no behaviour change** for these curves.
 - **`exp` / `log` / `sigmoid` / `cubic`** — **RE-BASELINED from the WASM.** The
  browser deliberately adopted the canonical firmware-exact maths: the old TS
  `curves.ts` used `k=4` exp/log, slope-8 sigmoid, and a smoothstep "cubic"; the
  canonical `nisps/core/math.hpp` catalog uses `k=1`-normalised exp/log, a
  slope-6 sigmoid, and a true cubic `x³`. The test asserts WASM stability
  against these regenerated values.
 ## Contracts you must reproduce to consume these
-### State contract (both pipelines are stateful)
+### State contract (both chains are stateful, C++-side per pipeline handle)
 - **Input:** EMA-smoothed x/y, a velocity ring, and a momentum-zoom multiplier.
 - **Output:** `prev` + `smoothed` buffers driving slew/freeze.
-Each config **run resets state** (`defaultInputState()` / `defaultOutputState()`)
+Each config **run resets state** (`nisps_input_reset` / `nisps_output_reset`)
 at step 0. Runs are independent; do not carry state between them.
 ### Clock contract (input pipeline only)
-`input-pipeline.ts`'s momentum-zoom path reads `performance.now()` (wall clock)
+The C++ input chain accumulates its own clock from the per-call `dt` (seconds)
-for its 150 ms velocity window. To make the momentum configs reproducible, the
+for the momentum velocity window; it takes **no** wall clock. To reproduce the
-capture pins `performance.now()` to each event's `t_ms` before processing it, so
+capture, the test feeds each event's `dt` = the per-event `t_ms` delta in
-the velocity window slides over the gesture's own timescale. `dt` passed to
+seconds, with the **first event's `dt` = 0** (matching the original TS capture,
-`processInput` is the per-event `t_ms` delta in seconds (fixed `1000/120` ms).
+which pinned `performance.now()` to each event's `t_ms`). The output chain uses
-A future consumer that ports this to C++ must feed the same per-event timestamps
+a constant per-step `dt` of `1000/60` ms (→ seconds).
 (the trace's `t_ms`) into whatever owns the velocity ring, or the momentum runs
 will not match. The output pipeline uses no wall clock; its `dtMs` is a fixed
 `1000/60`.
 ### JSON encodings
- `slewRate: null` in an output spec means `Infinity` (JSON has no `Infinity`).
+- `slewRate: null` in an output spec means `Infinity` (JSON has no `Infinity`);
  it maps to the wire's `slew_rate <= 0 ⇒ unlimited`.
 - Output raw values are pre-quantised with `Math.fround` so they equal exactly
  what a `Float32Array` holds.
-## How P4 should consume these
+## Re-capture
-After the input/output/curve logic moves into the C++/WASM core, flip
+`bun tests/fixtures/_generate.ts` regenerates `gesture-trace.json` (pure data)
-`pipeline-golden.test.ts` to drive the **WASM** implementations (via the
+and re-baselines the 4 changed curves in `curves-golden.json` from the WASM
-main-thread `nisps` instance) instead of the TS `run*` helpers, keeping the same
+(preserving the 4 unchanged f64 entries + provenance). It does **not** rewrite
-fixtures as the expected values. That proves *same pointer trace → same routed
+the input/output pipeline goldens — those are the frozen pre-migration capture
-output* across the migration.
+the regression is measured against; there is no TS pipeline left to capture
-
+from. `scripts/build-wasm.sh` must have run first.
 **Tolerance:** these goldens were produced in TS **f64**. The WASM core computes
 in **f32** for many paths, so exact 1e-9 equality will not hold post-migration —
 relax the comparison to about **1e-5** (and expect the sigmoid/exp/log curve tails
 and long smoothing/slew accumulations to be the widest-drifting points). If any
 value drifts materially beyond that, it is a real behavioural divergence, not
 float noise, and must be reconciled in the core rather than by widening tolerance.
--- a/manifold/tests/fixtures/_generate.ts
+++ b/manifold/tests/fixtures/_generate.ts
@ -1,98 +1,100 @@
 /**
- * Regenerates the pipeline golden fixtures from the CURRENT TS implementations.
+ * Fixture (re)generator. Run from manifold/:  `bun tests/fixtures/_generate.ts`
 *
- * Run once, from manifold/:  `bun tests/fixtures/_generate.ts`
+ * SCOPE SINCE ONE-CORE-ENGINE P4 (2026-07-18):
 *   - gesture-trace.json — pure deterministic data (regenerated identically).
 *   - curves-golden.json — the exp/log/sigmoid/cubic entries are RE-BASELINED
 *     from the canonical C++/WASM core (nisps/core/math.hpp); the
 *     linear/square/sqrt/centered_power entries are PRESERVED as their original
 *     2026-07-13 f64 TS captures (the C++ core matches them within 1e-5, so
 *     there is no behaviour change to record). Provenance is embedded.
 *
- * This is the capture tool. It must only be re-run intentionally (it overwrites
+ * The input-pipeline-golden.json / output-pipeline-golden.json fixtures are a
- * the goldens). The drift guard lives in tests/pipeline-golden.test.ts, which
+ * FROZEN pre-migration capture — this tool does NOT rewrite them (there is no
- * re-runs the same code against the committed fixtures without rewriting them.
+ * TS pipeline left to capture from; the regression is proven by driving the
- *
+ * WASM chains against the frozen goldens in pipeline-golden.test.ts).
 * Captured 2026-07-13, before the P4 core migration
 * (docs/specs/plans/one-core-engine-refactor.md §P4).
 */
-import { writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import {
+
-  CURVE_DEFAULT_PARAMS,
+import { CURVE_ID, CURVE_NAMES, CURVE_DEFAULT_PARAMS, type CurveName } from '../../src/engine/curve-catalog';
-  CURVE_SAMPLE_COUNT,
+import { INPUT_DT_MS, CURVE_SAMPLE_COUNT, buildGestureTrace } from '../pipeline-golden-lib';
-  INPUT_DT_MS,
+import { loadPipelineWasm } from '../wasm-load';
  OUTPUT_DIMS,
  OUTPUT_DT_MS,
  buildGestureTrace,
  buildOutputSequence,
  inputRunSpecs,
  outputRunSpecs,
  runInputPipeline,
  runOutputPipeline,
  sampleAllCurves,
 } from '../pipeline-golden-lib';
 const DIR = dirname(fileURLToPath(import.meta.url));
 const write = (name: string, data: unknown) => {
-  const path = join(DIR, name);
+  writeFileSync(join(DIR, name), JSON.stringify(data, null, 2) + '\n');
  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
  console.log('wrote', name);
 };
-const CAPTURED = '2026-07-13';
+/** Curves whose maths deliberately changed at the P4 migration. */
-const SOURCE_NOTE =
+const REBASELINED: ReadonlyArray<CurveName> = ['exp', 'log', 'sigmoid', 'cubic'];
-  'Captured from the TS engine implementations before the P4 one-core-engine migration. See tests/fixtures/README.md.';
+const UNCHANGED: ReadonlyArray<CurveName> = ['linear', 'square', 'sqrt', 'centered_power'];
-// 1. Gesture trace ----------------------------------------------------------
+async function main(): Promise<void> {
-const trace = buildGestureTrace();
+  const wasm = await loadPipelineWasm();
-write('gesture-trace.json', {
+
  // 1. Gesture trace (pure data) ---------------------------------------------
  const trace = buildGestureTrace();
  write('gesture-trace.json', {
    description: 'Canonical synthetic pointer trace over the input pipeline native [0,1]^2 domain.',
-  captured: CAPTURED,
+    captured: '2026-07-13',
-  note: SOURCE_NOTE,
+    note: 'Pure deterministic data; the input chain (WASM) is driven over it in pipeline-golden.test.ts.',
    dt_ms: INPUT_DT_MS,
    count: trace.length,
    domain: { x: [0, 1], y: [0, 1] },
    segments: ['h-sweep', 'v-sweep', 'diagonal', 'spiral', 'figure-eight', 'dwell+jumps'],
    events: trace,
-});
+  });
-// 2. Curves -----------------------------------------------------------------
+  // 2. Curves — preserve the unchanged f64 entries, re-baseline the 4 changed --
-write('curves-golden.json', {
+  const existing = JSON.parse(
-  description: 'applyCurve(name, x) sampled at 129 points x in [0,1] inclusive, using default params.',
+    readFileSync(join(DIR, 'curves-golden.json'), 'utf8'),
-  captured: CAPTURED,
+  ) as { curves: Record<string, number[]> };
-  note: SOURCE_NOTE,
+
  const curves: Record<string, number[]> = {};
  for (const name of CURVE_NAMES) {
    if (UNCHANGED.includes(name)) {
      curves[name] = existing.curves[name]!; // keep the original f64 capture
      continue;
    }
    const id = CURVE_ID[name];
    const param = name === 'centered_power' ? 1.0 : 0;
    const out: number[] = [];
    for (let i = 0; i < CURVE_SAMPLE_COUNT; i++) {
      out.push(wasm.curveApply(id, i / (CURVE_SAMPLE_COUNT - 1), param));
    }
    curves[name] = out;
  }
  write('curves-golden.json', {
    description:
      'Curve catalog sampled at 129 points x in [0,1] inclusive. linear/square/sqrt/centered_power are the original 2026-07-13 f64 TS captures (behaviour unchanged); exp/log/sigmoid/cubic RE-BASELINED from the canonical C++/WASM core (nisps/core/math.hpp) on the 2026-07-18 P4 migration — see provenance and README.',
    captured: '2026-07-13',
    sampleCount: CURVE_SAMPLE_COUNT,
    xStep: 1 / (CURVE_SAMPLE_COUNT - 1),
    defaultParams: CURVE_DEFAULT_PARAMS,
-  curves: sampleAllCurves(),
+    provenance: {
-});
+      unchanged: {
        curves: UNCHANGED,
        source: 'TS f64 capture 2026-07-13; C++ core matches within 1e-5 (no behaviour change).',
      },
      rebaselined: {
        curves: REBASELINED,
        date: '2026-07-18',
        source:
          'nisps/core/math.hpp via nisps_curve_apply (WASM). The old TS curves.ts used k=4 exp/log, slope-8 sigmoid, smoothstep cubic; the canonical catalog uses k=1-normalised exp/log, slope-6 sigmoid, true cubic x^3. The browser now adopts the firmware-exact behaviour.',
      },
    },
    curves,
  });
-// 3. Input pipeline ---------------------------------------------------------
+  console.log('NOTE: input/output pipeline goldens are frozen; not regenerated.');
-write('input-pipeline-golden.json', {
+}
  description: 'Gesture trace (gesture-trace.json) run through processInput under representative configs.',
  captured: CAPTURED,
  note: SOURCE_NOTE,
  traceRef: 'gesture-trace.json',
  dt_ms: INPUT_DT_MS,
  clockContract: 'performance.now() is pinned to each event t_ms during capture so momentum is deterministic.',
  stateContract: 'State reset to defaultInputState() at step 0 of every run.',
  runs: inputRunSpecs().map(({ id, config }) => ({
    id,
    config,
    outputs: runInputPipeline(trace, config),
  })),
 });
-// 4. Output pipeline --------------------------------------------------------
+main().catch((err) => {
-const sequence = buildOutputSequence();
+  console.error('[_generate] error:', err);
-write('output-pipeline-golden.json', {
+  process.exit(1);
  description: 'Deterministic raw output vectors (offset sines, f32) run through processOutput under representative configs.',
  captured: CAPTURED,
  note: SOURCE_NOTE,
  dt_ms: OUTPUT_DT_MS,
  dims: OUTPUT_DIMS,
  stateContract: 'State reset to defaultOutputState() at step 0 of every run. slewRate null = Infinity.',
  sequence,
  runs: outputRunSpecs().map((spec) => ({
    id: spec.id,
    spec,
    outputs: runOutputPipeline(sequence, spec),
  })),
 });
--- a/manifold/tests/fixtures/curves-golden.json
+++ b/manifold/tests/fixtures/curves-golden.json
--- a/manifold/tests/pipeline-golden-lib.ts
+++ b/manifold/tests/pipeline-golden-lib.ts
@ -1,47 +1,32 @@
 /**
- * Shared runner + generator library for the pipeline golden fixtures.
+ * Fixture-support library for the pipeline golden tests.
 *
- * Captured 2026-07-13, BEFORE the P4 "one core engine" migration
+ * Since the one-core-engine P4 migration the input/output PROCESSING lives in
- * (docs/specs/plans/one-core-engine-refactor.md §P4) replaces the TS
+ * the C++/WASM core; the golden test (tests/pipeline-golden.test.ts) drives the
- * curve/input/output implementations with C++/WASM calls.
+ * WASM chains against the committed fixtures. This module no longer runs any TS
 * pipeline maths — it only provides the PURE, deterministic fixture DATA
 * (gesture trace, raw output sequence) + the representative config lists + the
 * curve catalog metadata. The gesture/sequence/config data is embedded in the
 * committed *.json fixtures, so the test re-derives nothing hidden.
 *
- * This module is imported by BOTH:
+ * The gesture/output goldens are a FROZEN pre-migration capture (2026-07-13):
- *   - tests/fixtures/_generate.ts  — writes the *.json fixtures once, and
+ * the test proves the WASM chains reproduce them within an f32 tolerance. The
- *   - tests/pipeline-golden.test.ts — re-runs the CURRENT TS implementations
+ * curve goldens were partly re-baselined on 2026-07-18 (see README + the
- *     against the committed fixtures and asserts exact equality.
+ * curves-golden.json provenance field).
 *
 * The `run*` functions are the single source of truth for how a fixture was
 * produced. The fixtures embed the trace / raw sequence / configs, so the test
 * re-derives outputs purely from committed data — no hidden inputs.
 *
 * --- Determinism / clock contract -----------------------------------------
 * `input-pipeline.ts`'s momentum-zoom path reads `performance.now()` (wall
 * clock) for its velocity ring. To make the momentum configs reproducible,
 * `runInputPipeline` overrides `performance.now` with a synthetic clock driven
 * by the trace's own `t_ms`: before processing event i, the clock is pinned to
 * `events[i].t_ms`. The velocity window (150 ms) therefore slides over the
 * gesture's own timescale, deterministically. The original `performance.now`
 * is restored afterwards. `output-pipeline.ts` uses no wall clock.
 *
 * --- State contract --------------------------------------------------------
 * Both pipelines are STATEFUL (input: EMA smoothing + velocity ring + momentum
 * multiplier; output: prev + smoothed buffers for slew/freeze). Each config run
 * RESETS state to `defaultInputState()` / `defaultOutputState()` at step 0, so
 * runs are independent and order-free.
 */
-import { CURVE_NAMES, applyCurve, type CurveName } from '../src/engine/curves';
+import {
  CURVE_DEFAULT_PARAMS,
  CURVE_NAMES,
  type CurveName,
 } from '../src/engine/curve-catalog';
 import {
  defaultInputConfig,
  defaultInputState,
  processInput,
  type InputConfig,
-} from '../src/engine/input-pipeline';
+} from '../src/engine/pipeline-types';
-import {
+
-  defaultOutputState,
+export { CURVE_DEFAULT_PARAMS, CURVE_NAMES };
-  processOutput,
+export type { CurveName, InputConfig };
  type OutputConfig,
 } from '../src/engine/output-pipeline';
 // ---------------------------------------------------------------------------
 // Shared timebases
@ -157,47 +142,20 @@ export function buildGestureTrace(): GestureEvent[] {
 }
 // ---------------------------------------------------------------------------
-// 2. Curve sampling
+// 2. Curve sampling metadata
 // ---------------------------------------------------------------------------
 export const CURVE_SAMPLE_COUNT = 129; // 0..1 inclusive, step 1/128
 /** Default `param` used per curve (mirrors applyCurve's `?? default`). */
 export const CURVE_DEFAULT_PARAMS: Record<CurveName, number | null> = {
  linear: null,
  exp: 4.0,
  log: 4.0,
  square: null,
  sqrt: null,
  sigmoid: 8.0,
  cubic: null,
  centered_power: 1.0,
 };
 export function sampleCurve(name: CurveName): number[] {
  const out: number[] = [];
  for (let i = 0; i < CURVE_SAMPLE_COUNT; i++) {
    const x = i / (CURVE_SAMPLE_COUNT - 1); // inclusive endpoints
    out.push(applyCurve(name, x));
  }
  return out;
 }
 export function sampleAllCurves(): Record<string, number[]> {
  const out: Record<string, number[]> = {};
  for (const name of CURVE_NAMES) out[name] = sampleCurve(name);
  return out;
 }
 // ---------------------------------------------------------------------------
-// 3. Input pipeline configs + runner
+// 3. Input pipeline configs
 // ---------------------------------------------------------------------------
 function cfg(overrides: Partial<InputConfig>): InputConfig {
  return { ...defaultInputConfig(), ...overrides };
 }
-/** Representative input configs. Exercises every branch of processInput. */
+/** Representative input configs. Exercises every branch of the input chain. */
 export function inputRunSpecs(): InputRunSpec[] {
  return [
    { id: 'default', config: cfg({}) },
@ -220,36 +178,8 @@ export function inputRunSpecs(): InputRunSpec[] {
  ];
 }
 /**
 * Run the gesture trace through the input pipeline under one config.
 * Resets state at step 0. Drives a synthetic `performance.now` from the trace's
 * t_ms so the momentum path is deterministic (see clock contract above).
 */
 export function runInputPipeline(trace: readonly GestureEvent[], config: InputConfig): InputRunOutput[] {
  const perf = globalThis.performance as { now(): number };
  const realNow = perf.now;
  let clock = 0;
  perf.now = () => clock;
  try {
    let state = defaultInputState();
    const outputs: InputRunOutput[] = [];
    let prevT = trace.length > 0 ? trace[0]!.t_ms : 0;
    for (const ev of trace) {
      clock = ev.t_ms;
      const dt = Math.max(0, (ev.t_ms - prevT) / 1000);
      prevT = ev.t_ms;
      const res = processInput([ev.x, ev.y], config, state, dt);
      outputs.push({ x: res.x, y: res.y, frozen: res.frozen });
      state = res.state;
    }
    return outputs;
  } finally {
    perf.now = realNow;
  }
 }
 // ---------------------------------------------------------------------------
-// 4. Output raw sequence + configs + runner
+// 4. Output raw sequence + configs
 // ---------------------------------------------------------------------------
 /**
@ -285,38 +215,3 @@ export function outputRunSpecs(): OutputRunSpec[] {
    { id: 'combined', globalCurve: 1.8, smoothing: 0.7, slewRate: 1.0, freezeMaskIndices: null, freezeSteps: [90, 110], reuseBuffer: false },
  ];
 }
 function outputConfigForStep(spec: OutputRunSpec, step: number, dims: number): OutputConfig {
  const frozen = spec.freezeSteps ? step >= spec.freezeSteps[0] && step < spec.freezeSteps[1] : false;
  let mask: Uint8Array | null = null;
  if (spec.freezeMaskIndices) {
    mask = new Uint8Array(dims);
    for (const i of spec.freezeMaskIndices) if (i >= 0 && i < dims) mask[i] = 1;
  }
  return {
    globalCurve: spec.globalCurve,
    smoothing: spec.smoothing,
    slewRate: spec.slewRate === null ? Infinity : spec.slewRate,
    freezeOutput: frozen,
    freezeMask: mask,
    reuseBuffer: spec.reuseBuffer,
  };
 }
 /**
 * Run the raw sequence through the output pipeline under one spec. Resets state
 * at step 0. The global-freeze gate follows `spec.freezeSteps`.
 */
 export function runOutputPipeline(sequence: readonly number[][], spec: OutputRunSpec): number[][] {
  const dims = sequence.length > 0 ? sequence[0]!.length : 0;
  let state = defaultOutputState();
  const outputs: number[][] = [];
  for (let s = 0; s < sequence.length; s++) {
    const raw = Float32Array.from(sequence[s]!);
    const config = outputConfigForStep(spec, s, dims);
    const res = processOutput(raw, config, state, OUTPUT_DT_MS);
    outputs.push(Array.from(res.processed));
    state = res.state;
  }
  return outputs;
 }
--- a/manifold/tests/pipeline-golden.test.ts
+++ b/manifold/tests/pipeline-golden.test.ts
@ -1,47 +1,99 @@
 /**
- * Pipeline golden drift guard (run with `bun test`).
+ * Pipeline golden regression (run with `bun test`).
 *
- * Re-runs the CURRENT TS curve / input-pipeline / output-pipeline
+ * The one-core-engine P4 migration moved the curve / input-pipeline /
- * implementations against the committed fixtures in ./fixtures and asserts
+ * output-pipeline maths into the C++/WASM core (nisps/pipeline/*, nisps/core/
- * exact equality (tolerance 1e-9). It pins:
+ * math.hpp). This test now drives the SAME committed fixtures through the WASM
- *   - the pointer trace (gesture-trace.json) → routed input output,
+ * chains and asserts they reproduce the recorded gestures. It is the
- *   - applyCurve(name, x) over the curve catalog,
+ * recorded-gesture pre/post-migration regression the plan (§P4) calls for:
- *   - the raw-output sequence → processed output.
+ * same pointer trace → same routed output across the migration.
 *
- * Purpose: guard the TS implementations against silent drift until P4
+ * Tolerances (f32 WASM vs f64-captured fixtures):
- * (docs/specs/plans/one-core-engine-refactor.md §P4) flips these assertions to
+ *   - Input / output pipelines: 1e-5. Measured max non-momentum drift <5e-7.
- * the C++/WASM implementations. See fixtures/README.md for the migration
+ *   - Momentum configs (momentum-gentle / momentum-strong / combined): 1e-2.
- * playbook and the f32-vs-f64 tolerance note.
+ *     This path is NOT float noise in the usual sense: the velocity ring's
 *     window-membership test (`now - t <= window`) is a DISCRETE boundary that
 *     f32 rounding can flip during fast gestures, changing which sample is the
 *     window's oldest by a whole frame (~8 ms) → a step change in the measured
 *     speed → integrated by the momentum-zoom IIR. It is proven-inherent to the
 *     deliberately-f32 core, NOT a core bug: a byte-faithful f32 port of the
 *     exact original TS algorithm reproduces the WASM to <6e-8 while both
 *     diverge from the f64 capture by the same ~7-9e-3 (measured max 8.6e-3 on
 *     momentum-strong). Reconciling it in the core would require f64 momentum
 *     maths, which would break firmware parity. See fixtures/README.md.
 *   - Curves: 1e-5. linear/square/sqrt/centered_power match the ORIGINAL f64
 *     capture (proving no behaviour change); exp/log/sigmoid/cubic were
 *     RE-BASELINED from the WASM on 2026-07-18 (deliberate switch to the
 *     canonical firmware-exact maths — see fixtures/README.md + the
 *     curves-golden.json provenance) so the test asserts WASM stability against
 *     the regenerated values.
 *
- * The fixtures are authoritative: configs, trace, and raw sequence are read
+ * The fixtures are authoritative: the trace, raw sequence, and configs are read
- * FROM the JSON, so editing pipeline-golden-lib.ts config lists cannot mask a
+ * FROM the JSON.
 * regression here — only re-running fixtures/_generate.ts updates the goldens.
 */
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { expect, test } from 'bun:test';
+import { beforeAll, expect, test } from 'bun:test';
-import type { CurveName } from '../src/engine/curves';
+import { CURVE_ID, type CurveName } from '../src/engine/curve-catalog';
 import { applyCurve } from '../src/engine/curves';
 import type { InputConfig } from '../src/engine/input-pipeline';
 import {
-  runInputPipeline,
+  anchorModeToInt,
-  runOutputPipeline,
+  momentumModeToInt,
-  type GestureEvent,
+  type InputConfig,
-  type OutputRunSpec,
+} from '../src/engine/pipeline-types';
-} from './pipeline-golden-lib';
+import type { GestureEvent, OutputRunSpec } from './pipeline-golden-lib';
 import { loadPipelineWasm, type PipelineWasm } from './wasm-load';
 const DIR = dirname(fileURLToPath(import.meta.url));
 const readFixture = <T>(name: string): T =>
  JSON.parse(readFileSync(join(DIR, 'fixtures', name), 'utf8')) as T;
-const TOL = 1e-9;
+const TOL = 1e-5;
-const close = (a: number, b: number, ctx: string) => {
+/**
 * Momentum configs only: proven-inherent f32 drift of the velocity-ring +
 * momentum-zoom IIR (see the file header). Measured max 8.6e-3; 1e-2 leaves a
 * small margin. The core is still tightly guarded — a byte-faithful f32 port of
 * the original algorithm matches the WASM to <6e-8 — so a real behavioural
 * regression (wrong preset / broken window logic) would blow far past 1e-2.
 */
 const MOMENTUM_TOL = 1e-2;
 const MOMENTUM_RUNS = new Set(['momentum-gentle', 'momentum-strong', 'combined']);
 const close = (a: number, b: number, tol: number, ctx: string) => {
  if (a === b) return;
-  expect(Math.abs(a - b), ctx).toBeLessThanOrEqual(TOL);
+  expect(Math.abs(a - b), ctx).toBeLessThanOrEqual(tol);
 };
 /** InputConfig → the 15-float wire layout (nisps_input_set_config). */
 function inputConfigToWire(c: InputConfig): number[] {
  return [
    c.zoom,
    c.zoomX ?? 0,
    c.zoomY ?? 0,
    c.anchorX,
    c.anchorY,
    anchorModeToInt(c.anchorMode),
    c.deadzone,
    c.inputCurve,
    c.inputCurveX ?? 0,
    c.inputCurveY ?? 0,
    c.smoothing,
    momentumModeToInt(c.momentumZoom),
    c.velocityWindow / 1000,
    c.invertX ? 1 : 0,
    c.invertY ? 1 : 0,
  ];
 }
 let wasm: PipelineWasm;
 let pipe = 0;
 beforeAll(async () => {
  wasm = await loadPipelineWasm();
  pipe = wasm.pipelineCreate();
  expect(pipe).toBeGreaterThan(0);
 });
 // ---------------------------------------------------------------------------
 test('gesture trace fixture is well-formed (>=240 events, fixed dt, in-domain)', () => {
@ -50,7 +102,7 @@ test('gesture trace fixture is well-formed (>=240 events, fixed dt, in-domain)',
  expect(trace.events.length).toBeGreaterThanOrEqual(240);
  for (let i = 0; i < trace.events.length; i++) {
    const ev = trace.events[i]!;
-    close(ev.t_ms, i * trace.dt_ms, `event ${i} t_ms`);
+    close(ev.t_ms, i * trace.dt_ms, TOL, `event ${i} t_ms`);
    expect(ev.x).toBeGreaterThanOrEqual(0);
    expect(ev.x).toBeLessThanOrEqual(1);
    expect(ev.y).toBeGreaterThanOrEqual(0);
@ -58,53 +110,84 @@ test('gesture trace fixture is well-formed (>=240 events, fixed dt, in-domain)',
  }
 });
-test('curves-golden: applyCurve matches captured samples', () => {
+test('curves-golden: WASM curveApply matches the (re-baselined) catalog', () => {
  const fx = readFixture<{ sampleCount: number; curves: Record<string, number[]> }>('curves-golden.json');
  const names = Object.keys(fx.curves) as CurveName[];
  expect(names.length).toBeGreaterThan(0);
  for (const name of names) {
    const golden = fx.curves[name]!;
    const id = CURVE_ID[name];
    const param = name === 'centered_power' ? 1.0 : 0;
    expect(golden.length).toBe(fx.sampleCount);
    for (let i = 0; i < golden.length; i++) {
      const x = i / (fx.sampleCount - 1);
-      close(applyCurve(name, x), golden[i]!, `curve ${name}[${i}] (x=${x})`);
+      close(wasm.curveApply(id, x, param), golden[i]!, TOL, `curve ${name}[${i}] (x=${x})`);
    }
  }
 });
-test('input-pipeline-golden: processInput matches captured outputs', () => {
+test('input-pipeline-golden: WASM input chain matches captured outputs', () => {
  const trace = readFixture<{ events: GestureEvent[] }>('gesture-trace.json').events;
  const fx = readFixture<{
    runs: Array<{ id: string; config: InputConfig; outputs: Array<{ x: number; y: number; frozen: boolean }> }>;
  }>('input-pipeline-golden.json');
  expect(fx.runs.length).toBeGreaterThan(0);
  for (const run of fx.runs) {
-    const got = runInputPipeline(trace, run.config);
+    const tol = MOMENTUM_RUNS.has(run.id) ? MOMENTUM_TOL : TOL;
-    expect(got.length, `run ${run.id} length`).toBe(run.outputs.length);
+    wasm.inputReset(pipe);
-    for (let i = 0; i < got.length; i++) {
+    wasm.inputSetConfig(pipe, inputConfigToWire(run.config));
-      close(got[i]!.x, run.outputs[i]!.x, `input ${run.id}[${i}].x`);
+    expect(run.outputs.length, `run ${run.id} length`).toBe(trace.length);
-      close(got[i]!.y, run.outputs[i]!.y, `input ${run.id}[${i}].y`);
+
-      expect(got[i]!.frozen, `input ${run.id}[${i}].frozen`).toBe(run.outputs[i]!.frozen);
+    // Honour the fixture clock contract: dt = per-event t_ms delta in seconds,
    // with the first event's dt = 0 (matches the pre-migration capture).
    let prevT = trace.length > 0 ? trace[0]!.t_ms : 0;
    for (let i = 0; i < trace.length; i++) {
      const ev = trace[i]!;
      const dt = Math.max(0, (ev.t_ms - prevT) / 1000);
      prevT = ev.t_ms;
      const got = wasm.inputProcess(pipe, ev.x, ev.y, dt);
      const want = run.outputs[i]!;
      close(got.x, want.x, tol, `input ${run.id}[${i}].x`);
      close(got.y, want.y, tol, `input ${run.id}[${i}].y`);
      expect(got.frozen, `input ${run.id}[${i}].frozen`).toBe(want.frozen);
    }
  }
 });
-test('output-pipeline-golden: processOutput matches captured outputs', () => {
+test('output-pipeline-golden: WASM output chain matches captured outputs', () => {
  const fx = readFixture<{
    dt_ms: number;
    sequence: number[][];
    runs: Array<{ id: string; spec: OutputRunSpec; outputs: number[][] }>;
  }>('output-pipeline-golden.json');
  expect(fx.runs.length).toBeGreaterThan(0);
  expect(fx.sequence.length).toBeGreaterThanOrEqual(100);
  const dtSeconds = fx.dt_ms / 1000; // constant per step (matches the capture)
  const dims = fx.sequence[0]!.length;
  for (const run of fx.runs) {
-    const got = runOutputPipeline(fx.sequence, run.spec);
+    const spec = run.spec;
-    expect(got.length, `run ${run.id} length`).toBe(run.outputs.length);
+    wasm.outputReset(pipe);
-    for (let s = 0; s < got.length; s++) {
+    // Per-output freeze mask (whole-run), applied once.
-      const gotRow = got[s]!;
+    let mask: Uint8Array | null = null;
-      const wantRow = run.outputs[s]!;
+    if (spec.freezeMaskIndices) {
-      expect(gotRow.length, `output ${run.id}[${s}] width`).toBe(wantRow.length);
+      mask = new Uint8Array(dims);
-      for (let j = 0; j < gotRow.length; j++) {
+      for (const i of spec.freezeMaskIndices) if (i >= 0 && i < dims) mask[i] = 1;
-        close(gotRow[j]!, wantRow[j]!, `output ${run.id}[${s}][${j}]`);
+    }
    wasm.outputSetFreezeMask(pipe, mask);
    expect(run.outputs.length, `run ${run.id} length`).toBe(fx.sequence.length);
    const slew = spec.slewRate === null ? Infinity : spec.slewRate;
    for (let s = 0; s < fx.sequence.length; s++) {
      const frozen = spec.freezeSteps ? s >= spec.freezeSteps[0] && s < spec.freezeSteps[1] : false;
      wasm.outputSetConfig(pipe, spec.globalCurve, spec.smoothing, slew, frozen);
      const vec = Float32Array.from(fx.sequence[s]!);
      wasm.outputProcess(pipe, vec, dtSeconds);
      const want = run.outputs[s]!;
      expect(vec.length, `output ${run.id}[${s}] width`).toBe(want.length);
      for (let j = 0; j < vec.length; j++) {
        close(vec[j]!, want[j]!, TOL, `output ${run.id}[${s}][${j}]`);
      }
    }
  }
--- a/manifold/tests/wasm-load.ts
+++ b/manifold/tests/wasm-load.ts
@ -0,0 +1,112 @@
 /**
 * Load the built nisps WASM module under `bun test` / a Bun script, without a
 * DOM. The Emscripten glue (`manifold/public/nisps.js`) is MODULARIZE output
 * WITHOUT ES exports — it assigns a global `createNispsModule` with only
 * CommonJS/AMD fallbacks. Neither `require()` nor `import()` extracts the
 * factory cleanly (the public/ dir is a `type:module` sub-package), so we read
 * the glue as text and indirect-eval it inside a thin shim that returns the
 * factory — the same technique as tests/cpp/parity_wasm.mjs.
 *
 * Returns a friendly wrapper around the pipeline + curve C ABI used by the
 * golden tests (the ML surface is exercised elsewhere).
 */
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 interface EmModule {
  HEAPF32: Float32Array;
  HEAPU8: Uint8Array;
  _malloc(bytes: number): number;
  _free(ptr: number): void;
  cwrap(name: string, ret: string | null, args: string[]): (...a: number[]) => number;
 }
 type Factory = (opts: { wasmBinary: Uint8Array }) => Promise<EmModule>;
 export interface PipelineWasm {
  module: EmModule;
  pipelineCreate(): number;
  pipelineDestroy(p: number): void;
  inputSetConfig(p: number, cfg: ArrayLike<number>): void;
  /** Returns { x, y, frozen }. */
  inputProcess(p: number, x: number, y: number, dtSeconds: number): { x: number; y: number; frozen: boolean };
  inputReset(p: number): void;
  outputSetConfig(p: number, globalCurve: number, smoothing: number, slewRate: number, freeze: boolean): void;
  outputSetFreezeMask(p: number, mask: Uint8Array | null): void;
  /** Process `vec` in place (first vec.length floats). */
  outputProcess(p: number, vec: Float32Array, dtSeconds: number): void;
  outputReset(p: number): void;
  curveApply(id: number, x: number, param?: number): number;
 }
 let cached: PipelineWasm | null = null;
 export async function loadPipelineWasm(): Promise<PipelineWasm> {
  if (cached) return cached;
  const dir = dirname(fileURLToPath(import.meta.url));
  const gluePath = join(dir, '..', 'public', 'nisps.js');
  const wasmPath = join(dir, '..', 'public', 'nisps.wasm');
  const source = readFileSync(gluePath, 'utf8');
  // eslint-disable-next-line @typescript-eslint/no-implied-eval
  const factory = new Function(
    'module', 'exports',
    `${source}\n;return typeof createNispsModule === 'function' ? createNispsModule : null;`,
  )({ exports: {} }, {}) as Factory | null;
  if (typeof factory !== 'function') throw new Error('[wasm-load] createNispsModule not found in glue');
  const wasmBinary = readFileSync(wasmPath);
  const M = await factory({ wasmBinary });
  const cPipelineCreate = M.cwrap('nisps_pipeline_create', 'number', []);
  const cPipelineDestroy = M.cwrap('nisps_pipeline_destroy', null, ['number']);
  const cInputSetConfig = M.cwrap('nisps_input_set_config', null, ['number', 'number', 'number']);
  const cInputProcess = M.cwrap('nisps_input_process', 'number', ['number', 'number', 'number', 'number', 'number']);
  const cInputReset = M.cwrap('nisps_input_reset', null, ['number']);
  const cOutputSetConfig = M.cwrap('nisps_output_set_config', null, ['number', 'number', 'number', 'number', 'number']);
  const cOutputSetFreezeMask = M.cwrap('nisps_output_set_freeze_mask', null, ['number', 'number', 'number']);
  const cOutputProcess = M.cwrap('nisps_output_process', null, ['number', 'number', 'number', 'number']);
  const cOutputReset = M.cwrap('nisps_output_reset', null, ['number']);
  const cCurveApply = M.cwrap('nisps_curve_apply', 'number', ['number', 'number', 'number']);
  // Reusable scratch buffers (sized to the fixtures' needs).
  const cfgPtr = M._malloc(15 * 4);
  const xyPtr = M._malloc(2 * 4);
  const OUT_CAP = 64;
  const outPtr = M._malloc(OUT_CAP * 4);
  const maskPtr = M._malloc(OUT_CAP);
  cached = {
    module: M,
    pipelineCreate: () => cPipelineCreate(),
    pipelineDestroy: (p) => cPipelineDestroy(p),
    inputSetConfig(p, cfg) {
      const v = new Float32Array(M.HEAPF32.buffer, cfgPtr, 15);
      for (let i = 0; i < 15; i++) v[i] = cfg[i] ?? 0;
      cInputSetConfig(p, cfgPtr, 15);
    },
    inputProcess(p, x, y, dtSeconds) {
      const frozen = cInputProcess(p, x, y, dtSeconds, xyPtr);
      const v = new Float32Array(M.HEAPF32.buffer, xyPtr, 2);
      return { x: v[0]!, y: v[1]!, frozen: frozen === 1 };
    },
    inputReset: (p) => cInputReset(p),
    outputSetConfig(p, globalCurve, smoothing, slewRate, freeze) {
      const slew = Number.isFinite(slewRate) ? slewRate : 0;
      cOutputSetConfig(p, globalCurve, smoothing, slew, freeze ? 1 : 0);
    },
    outputSetFreezeMask(p, mask) {
      if (!mask || mask.length === 0) { cOutputSetFreezeMask(p, 0, 0); return; }
      const n = Math.min(mask.length, OUT_CAP);
      new Uint8Array(M.HEAPU8.buffer, maskPtr, n).set(mask.subarray(0, n));
      cOutputSetFreezeMask(p, maskPtr, n);
    },
    outputProcess(p, vec, dtSeconds) {
      const n = Math.min(vec.length, OUT_CAP);
      new Float32Array(M.HEAPF32.buffer, outPtr, n).set(vec.subarray(0, n));
      cOutputProcess(p, outPtr, n, dtSeconds);
      vec.set(new Float32Array(M.HEAPF32.buffer, outPtr, n).subarray(0, n));
    },
    outputReset: (p) => cOutputReset(p),
    curveApply: (id, x, param = 0) => cCurveApply(id, x, param),
  };
  return cached;
 }