memlnaut-nisps/docs/specs/plans/one-core-engine-refactor.md

---
kind: plan
status: active
---

# One Core Engine — Firmware + Manifold Reunification Plan

*Dated 2026-07-13. Operator-confirmed scope (see §1). Principle: **one core engine (`nisps/`) for both the
resource-constrained RP2350 hardware and the Manifold browser app.** Everything with behaviour — ML, feedback,
exploration, RNG, DSP, input/output processing, curves — lives once, in C++. TypeScript keeps only UI,
reactivity, and transport. This plan supersedes the browser-side "one engine, two skins" framing of
`../engine-architecture.md` (that seam is built — Manifold is its realisation); the axis of unification now
runs vertically, core↔targets, not horizontally, skin↔skin.*

## 0. Where duplication actually lives today (audited 2026-07-13)

| Component | Canonical | Duplicate / divergence | Disposition |
|---|---|---|---|
| MLP, training, init, RL `move_weights` | `nisps/ml/` | `vcv/src/iml.hpp` full runtime reimpl ("delta #5") | Reunify (P2, P6) |
| Feedback explore-and-place | `nisps/ml/feedback.hpp` | none — firmware + manifold both call it ✓ | Keep |
| Geometric dislike (Mode 1) | *(missing from core)* | `manifold/src/feedback/controller.ts` TS approximation, explicit `C++ GAP` markers (lines ~369, ~436) | Port to core (P3) |
| Jolt weight-morph | `nisps/ml/jolt.hpp` | `playground/src/ml/jolt.ts` TS port; absent in manifold | Expose via WASM (P3) |
| OU exploration noise | `nisps/ml/ou_noise.hpp` | `playground/src/output/ou-explore.ts` TS port; absent in manifold | Expose via WASM (P3) |
| Deterministic RNG | `nisps/core/rng.hpp` | `manifold/src/feedback/rng.ts` (`SeededRng`, self-described stand-in) | Replace with core stream (P3) |
| Input pipeline | *(TS-only concept)* | `playground/src/input/pipeline.ts` ≡ `manifold/src/engine/input-pipeline.ts` | Port to core (P4) |
| Output pipeline + curves | curves mirror `nisps/core/math.hpp` | byte-identical TS pairs in playground + manifold | Port to core (P4) |
| Audio DSP engines (×8) | `nisps/engines/` | none — both targets run the WASM ✓ | Keep |
| TS engine spine (wasm-iml, worker, host, worklet) | — | manifold forked from playground; several files byte-identical | Single home in manifold (P1) |
| Compiled `nisps.wasm` | `scripts/build-wasm.sh` → `playground/public/` | `manifold/public/` byte-identical **manual copy** | Retarget build (P0) |
| Mode param schemas | `schemas/modes/*.json` → codegen | manifold bypasses codegen; hardcodes `MF_MODES` in `console/model.ts` | Codegen for manifold (P5) |
| WASM MLP arity | `bindings.cpp` `MLP<32,10,14,18,126>`; `nisps_ml_create` ignores requested dims | forces clamping, blocks per-mode arch, motivated the VCV reimpl | Runtime-shaped browser MLP (P2) |

## 1. Locked decisions (operator, 2026-07-13)

| Decision | Choice |
|---|---|
| `playground/` | **Retired.** Archived to branch `archive/playground-solidjs`, deleted from main. Manifold is the sole browser app; WASM build, parity-check, codegen all retarget manifold. |
| Depth of "one core" | **All algorithms in C++.** Feedback (incl. geometric dislike), Jolt, OU, RNG, input/output pipelines, curves move into `nisps/`; TS keeps UI/reactivity/transport only. |
| MLP arity | **Template the hardware, dynamic browser.** Firmware keeps compile-time `MLP<...>` (zero-heap contract intact); WASM/VCV targets get a runtime-shaped MLP sharing the same algorithm code. Heap allowed at construction time on non-RP2350 targets only. |
| VCV | **In scope, final phase** (P6); may slip without blocking anything else. |

**Supersedes:** `BUILD-PLAN.md` locked decision "Modular N×M MLP: multiple WASM modules + warm-start; NOT
runtime-shaped" (2026-06-27). The runtime-shaped MLP is now the chosen mechanism; warm-start on reshape is
retained as a feature of it.

## 2. Target architecture

```
                    ┌───────────────────────── nisps/ (ONE CORE) ─────────────────────────┐
                    │ core/   rng, math+curves, buffers, perf attrs                        │
                    │ ml/     algorithms templated on StoragePolicy:                       │
                    │           Fixed<NIn,H1,H2,H3,NOut>  (arrays, zero-heap → RP2350)     │
                    │           Dynamic                    (sized at construction → WASM,VCV)│
                    │         mlp / training / init / rl / jolt / ou_noise / feedback /    │
                    │         geo_push / replay  (geometric dislike lands here)            │
                    │ pipeline/  input chain (deadzone→zoom→curve→smooth→momentum)         │
                    │            output chain (curve→smooth→slew→freeze)      ← NEW        │
                    │ dsp/ engines/ modes/   (unchanged)                                   │
                    └──────────────────────────────────────────────────────────────────────┘
                       ▲ direct #include                ▲ nisps/wasm/bindings.cpp (C ABI)
              ┌────────┴─────────┐            ┌─────────┴──────────┐        ┌───────────────┐
              │ firmware/ glue   │            │ manifold/ (React)  │        │ vcv/ (P6)     │
              │ RP2350, Fixed    │            │ UI + reactive spine│        │ Dynamic       │
              │ storage, no heap │            │ + transports only  │        │ storage       │
              └──────────────────┘            └────────────────────┘        └───────────────┘
```

Litmus test per file: **if it computes behaviour that affects sound, weights, or parameter values, it is C++
in `nisps/`; if it schedules, renders, or transports, it may be TS.** The existing browser litmus (JSX/DOM =
skin) still applies inside manifold; this plan adds the vertical one.

## 3. Phases

Each phase ends green on its test gate and is independently landable. File phases as **ergo** tasks
(one per phase, sub-tasks per bullet); do not start a phase before its predecessor's gate is green.

### P0 — Plumbing hygiene (hours, no behaviour change) — ✅ landed 2026-07-13

- ✅ `scripts/build-wasm.sh` emits to `manifold/public/` (keep `playground/public/` copy only until P1 lands).
- ✅ `scripts/parity-check.sh` (and `tests/cpp/parity_wasm.mjs`) read the manifold artifact.
- ✅ Fix stale doc: the `MLP<2,…>` line was in `docs/AGENT-REFERENCE.md` + `nisps/wasm/README.md` (MAP.md was already correct); both now say `MLP<32u,10u,14u,18u,126u>`.
- ✅ `ml-debug.log`/`graphify-out/` were already absent from the tree; `.claude/worktrees/` gitignored.
- **Gate met:** `run-all-tests.sh` green (Playwright leg via the BUILD-PLAN non-snap-node VPS runner); parity PASS reading `manifold/public/` (max delta 2.4e-7); manifold typecheck+build green against the freshly-built artifact.

### P1 — Retire playground, single TS home (≈1 day) — ✅ landed 2026-07-13

- ✅ Branch `archive/playground-solidjs` + tag `playground-solidjs-final`; `playground/` deleted from main.
  Parity fixtures for P4 captured FIRST: `manifold/tests/fixtures/` (288-event gesture trace, curve
  goldens, input/output pipeline goldens under 14+8 configs) + drift-guard `pipeline-golden.test.ts`.
  Note: input pipeline's momentum path reads `performance.now()` — fixtures pin a clock contract (see
  fixtures README). C15 (stub + c15.wasm) now lives only on the archive branch (ALIGNMENT defect #1).
- ✅ Jolt press + OU explore UI shells in the Learning drawer; interim TS math via get/set_weights in
  `manifold/src/engine/{exploration,jolt,ou-explore}.ts`, marked `P3 SWAP POINT`.
- ✅ Keeper Playwright specs ported: `probe-api.spec.ts` (15 tests), `spine.spec.ts` (4). Playground UI/
  persistence specs dropped with the playground.
- ✅ References retargeted: run-all-tests stage 5 → manifold, ci.yml manifold-tests job, osc-bridge.yml
  (was already broken), codegen TS target removed (returns P5), AGENTS/README/MAP/ALIGNMENT/
  AGENT-REFERENCE/specs-MAIN. The VPS deploy webhook already built only manifold — no change needed.
- **Gate met:** full `run-all-tests.sh` green with playground gone (ctest 4/4, parity PASS, lint clean,
  manifold 9 unit + 20 e2e).

### P2 — Storage-policy split: templated hardware, dynamic browser (the structural centre, ≈1 wk)

- Refactor `nisps/ml/` so algorithms (forward, backprop/SGD, init, `move_weights`, jolt, OU, feedback)
  are written once against a storage concept: `weights()`, `layer_sizes()`, `scratch()`. Two models:
  - `FixedStorage<NIn,H1,H2,H3,NOut>` — `std::array`, `NISPS_AUDIO_MEM`-able, zero heap. Firmware target;
    existing `MLP<...>` becomes an alias. **RP2350 performance contract untouched.**
  - `DynamicStorage` — sizes at construction, single arena allocation, no per-call allocation after
    construction. Compiled only for WASM/native-test/VCV targets (guarded so `lint-cpp.sh` still fails heap
    use in firmware paths).
- `nisps_ml_create(input, output, hidden[])` honours its arguments. Reshape = new instance + warm-start
  copy of overlapping weights (the BUILD-PLAN warm-start idea, now runtime).
- Manifold drops input clamping/phantom-channel handling; XIASRI/sound-analysis multi-input modes become
  browser-viable.
- **Gate:** parity — fixed and dynamic storage produce bit-identical outputs for identical shapes/seeds
  (new ctest); `parity-check.sh` native↔WASM ≤1e-5 unchanged; firmware builds byte-comparable (chokepoint B:
  compile PAFSynth, compare `.text` size ±1%).

### P3 — Exploration + feedback fully in core (≈3–4 days)

- **Geometric dislike:** port firmware k-NN centroid push (upstream `InterfaceRL.cpp:602-738`) into
  `nisps/ml/geo_push.hpp` + `replay.hpp` + `mlp.train_targets`, per `docs/adr/rl-feedback-design.md` §4.
  Expose via `nisps_ml_feedback_dislike_geometric`. Delete the TS approximation + both `C++ GAP` blocks in
  `manifold/src/feedback/controller.ts`.
- **Jolt / OU:** expose `nisps/ml/jolt.hpp` + `ou_noise.hpp` through bindings
  (`nisps_ml_jolt_press/release`, `nisps_ml_explore_intensity`); manifold's P1 UI shells switch to them.
  The playground TS ports die with P1.
- **RNG:** feedback/exploration randomness in the browser comes from the core's seeded `Rng` streams
  (already per-instance, ctor-seeded). Delete `manifold/src/feedback/rng.ts`.
- **Gate:** new cross-platform parity test — scripted feedback session (seeded) produces identical weight
  trajectories native↔WASM; firmware spot-check on hardware (chokepoint A) for geometric dislike feel.

### P4 — Input/output pipelines + curves into core (≈3 days)

- New `nisps/pipeline/`: input chain and output chain as plain structs satisfying the perf contract
  (usable per-sample on firmware if ever wanted; per-pointer-event in browser — JS↔WASM call cost is
  trivial at that rate).
- Curves: single catalog in `nisps/core/math.hpp` (already canonical); bindings expose
  `nisps_curve_apply(id, x)` and batch variant; TS `curves.ts` (both copies) deleted, UI curve *previews*
  render by sampling the WASM.
- Manifold `input-pipeline.ts` / `output-pipeline.ts` become thin calls into the main-thread WASM instance
  (state lives C++-side, per-instance, serialisable for persistence).
- Golden TS-vs-C++ tests retire; replaced by direct use.
- **Gate:** spine e2e unchanged; recorded-gesture regression: same pointer trace → same routed output
  pre/post migration (capture fixture before starting).

### P5 — Schema/codegen serves manifold (≈2 days)

- `codegen/generate.ts` emits `manifold/src/modes/generated/` alongside the C++ headers (playground target
  removed in P1). `MF_MODES` in `console/model.ts` is derived from generated schemas, not hand-written —
  labels/ordering may stay a manifold-side overlay, but params/ranges/ml-config come from schema truth.
- With P2's dynamic MLP, per-mode `ml.input_size/output_size/hidden` in schemas becomes *real* in the
  browser; codegen gains a check that firmware modes still fit the fixed template.
- **Gate:** codegen idempotence golden test extended to manifold output; e2e per-mode param count/range
  assertions driven from schema.

### P6 — VCV reunification (later; may slip)

- `vcv/src/iml.hpp` deleted; module consumes `nisps/ml/` with `DynamicStorage` (its 8→16 runtime shape is
  exactly the P2 case). `DetRng` replaced by `nisps/core/rng.hpp`. Closes vcv-module.md delta #5.
- OSC server stays vcv-local (transport, not behaviour).
- **Gate:** vcv builds; seeded train/infer parity vs native ctest.

## 4. Risks

| Risk | Mitigation |
|---|---|
| P2 template refactor destabilises firmware perf (chokepoint B) | Fixed-storage path stays `std::array` + same attrs; compare `.text`/RAM and audio-callback timing before/after; land behind a ctest parity gate. |
| Dynamic storage leaks heap use into firmware paths | Compile-time guard (`#if NISPS_TARGET_EMBEDDED` excludes `DynamicStorage`); `lint-cpp.sh` already fails heap under `nisps/` — carve an explicit allowlist for the dynamic TU only. |
| Per-event WASM calls for pipelines add latency | Pointer-rate ≈120 Hz, one call each — negligible; batch API as fallback. rAF/canvas never calls WASM. |
| Geometric-dislike port changes feel vs firmware | Port from upstream source verbatim, seeded-trajectory parity test, then hardware A/B (chokepoint A) before deleting the TS fallback. |
| Retiring playground loses a working reference | Archive branch + tag; parity fixtures (recorded gestures, golden outputs) extracted *before* deletion in P1. |
| Manifold worklet + main thread now both depend on retargeted wasm build | P0 gate builds manifold from fresh artifact in CI, killing the manual-copy hazard permanently. |

## 5. Doc-sync obligations

- On each phase landing: update `MAP.md` (it is the shipped-behaviour authority) and burn down this plan's
  phase table; when all phases land, set `status: executed`.
- `MAIN.md` registry: this file added; `engine-architecture.md` remains authoritative for the *browser-side*
  seam only; BUILD-PLAN.md's MLP row annotated as superseded (done 2026-07-13).
- `ALIGNMENT.md` defect #3 (fixed WASM arity) closes at P2; the accepted-divergence log entries for Jolt/OU
  TS ports and vcv delta #5 close at P3/P6.