@libraz/libsonare 1.5.2 → 1.5.3

package/dist/worklet.js

@@ -205,1199 +205,1212 @@ function sendTimingCode(timing) {
   return timing === "preFader" ? 1 : 0;
 }
 
-// src/mixer.ts
-var Mixer = class _Mixer {
-  constructor(mixer) {
-    this.mixer = mixer;
-  }
-  /**
-   * Build a mixer from a scene JSON string.
-   *
-   * @param json - Scene JSON (strips, buses, sends, connections, inserts)
-   * @param sampleRate - Sample rate in Hz (default: 48000)
-   * @param blockSize - Maximum block size per {@link processStereo} call (default: 512)
-   */
-  static fromSceneJson(json, sampleRate = 48e3, blockSize = 512) {
+// src/realtime_engine.ts
+var EXPECTED_ENGINE_ABI_VERSION = 3;
+function engineCapabilities() {
+  const abiVersion = getSonareModule().engineAbiVersion();
+  const sharedArrayBuffer = typeof globalThis.SharedArrayBuffer === "function";
+  const atomics = typeof globalThis.Atomics === "object";
+  const audioWorklet = typeof AudioWorkletNode !== "undefined" || typeof globalThis.AudioWorkletProcessor !== "undefined";
+  return {
+    engineAbiVersion: abiVersion,
+    expectedEngineAbiVersion: EXPECTED_ENGINE_ABI_VERSION,
+    abiCompatible: abiVersion === EXPECTED_ENGINE_ABI_VERSION,
+    sharedArrayBuffer,
+    atomics,
+    audioWorklet,
+    mode: sharedArrayBuffer && atomics ? "sab" : "postMessage"
+  };
+}
+var RealtimeEngine = class {
+  constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024) {
     const module2 = getSonareModule();
-    return new _Mixer(module2.createMixerFromSceneJson(json, sampleRate, blockSize));
+    const capabilities = engineCapabilities();
+    if (!capabilities.abiCompatible) {
+      throw new Error(
+        `Engine ABI mismatch: wasm=${capabilities.engineAbiVersion}, expected=${capabilities.expectedEngineAbiVersion}`
+      );
+    }
+    this.native = new module2.RealtimeEngine(
+      sampleRate,
+      maxBlockSize,
+      commandCapacity,
+      telemetryCapacity
+    );
   }
-  /** Rebuild and compile the routing graph from the current scene topology. */
-  compile() {
-    this.mixer.compile();
+  prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024) {
+    this.native.prepare(sampleRate, maxBlockSize, commandCapacity, telemetryCapacity);
   }
-  /**
-   * Non-fatal warnings captured when this mixer was built from scene JSON: one
-   * entry per channel-strip insert that was handed param keys it does not read
-   * (a likely typo, or a key meant for a different processor). The scene still
-   * loaded; these keys simply took no effect. Empty when every key was consumed.
-   * Use {@link masteringInsertParamNames} to discover the keys an insert accepts.
-   */
-  sceneWarnings() {
-    return this.mixer.sceneWarnings();
+  /** Queue a sample-accurate parameter change (engine kSetParam). */
+  setParameter(paramId, value, renderFrame = -1) {
+    this.native.setParameter(paramId, value, renderFrame);
   }
-  /**
-   * Mix one block of per-strip stereo audio into the stereo master.
-   *
-   * @param leftChannels - `leftChannels[i]` is the left channel of strip `i`
-   * @param rightChannels - `rightChannels[i]` is the right channel of strip `i`
-   * @returns Mixed stereo master (`left`, `right`, `sampleRate`)
-   */
-  processStereo(leftChannels, rightChannels) {
-    if (leftChannels.length !== rightChannels.length) {
-      throw new Error("leftChannels and rightChannels must have the same length.");
-    }
-    return this.mixer.processStereo(leftChannels, rightChannels);
+  /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
+  setParameterSmoothed(paramId, value, renderFrame = -1) {
+    this.native.setParameterSmoothed(paramId, value, renderFrame);
   }
   /**
-   * Mix one block into caller-owned output arrays.
-   *
-   * This avoids allocating the result object and result `Float32Array`s. It is
-   * intended for realtime bridges such as AudioWorklet; the input channel count
-   * must match the scene strip count and all arrays must have the same length.
+   * Set the default ramp time (ms) for engine-level smoothed parameters —
+   * fader/pan glides, insert-parameter automation, and MIDI-CC mappings. The
+   * default is 20 ms; pass `0` for instant (un-ramped) changes.
    */
-  processStereoInto(leftChannels, rightChannels, outLeft, outRight) {
-    if (leftChannels.length !== rightChannels.length) {
-      throw new Error("leftChannels and rightChannels must have the same length.");
-    }
-    if (outLeft.length !== outRight.length) {
-      throw new Error("outLeft and outRight must have the same length.");
-    }
-    this.mixer.processStereoInto(leftChannels, rightChannels, outLeft, outRight);
+  setParamSmoothingMs(smoothingMs) {
+    this.native.setParamSmoothingMs(smoothingMs);
   }
-  /**
-   * Create reusable WASM-heap input/output views for realtime-style processing.
-   *
-   * Fill `leftInputs[i]` / `rightInputs[i]`, call `process()`, then read
-   * `outLeft` / `outRight`. The views are owned by this mixer and become invalid
-   * after {@link delete}.
-   */
-  createRealtimeBuffer() {
-    const stripCount = this.stripCount();
-    let leftInputs = [];
-    let rightInputs = [];
-    let outLeft = this.mixer.outputLeftView();
-    let outRight = this.mixer.outputRightView();
-    const acquire = () => {
-      leftInputs = [];
-      rightInputs = [];
-      for (let index = 0; index < stripCount; index++) {
-        leftInputs.push(this.mixer.inputLeftView(index));
-        rightInputs.push(this.mixer.inputRightView(index));
-      }
-      outLeft = this.mixer.outputLeftView();
-      outRight = this.mixer.outputRightView();
-    };
-    acquire();
-    const reacquireIfDetached = () => {
-      if (outLeft.byteLength === 0 || (leftInputs[0]?.byteLength ?? 1) === 0) {
-        acquire();
-      }
-    };
-    return {
-      get leftInputs() {
-        reacquireIfDetached();
-        return leftInputs;
-      },
-      get rightInputs() {
-        reacquireIfDetached();
-        return rightInputs;
-      },
-      get outLeft() {
-        reacquireIfDetached();
-        return outLeft;
-      },
-      get outRight() {
-        reacquireIfDetached();
-        return outRight;
-      },
-      process: (numSamples = outLeft.length) => {
-        reacquireIfDetached();
-        this.mixer.processPreparedStereo(numSamples);
-      }
-    };
+  setSoloMute(laneIndex, solo, mute, renderFrame = -1) {
+    this.native.setSoloMute(laneIndex, solo, mute, renderFrame);
   }
-  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
-  stripCount() {
-    return this.mixer.stripCount();
+  setMidiClips(clips) {
+    this.native.setMidiClips(clips);
+  }
+  setBuiltinInstrument(config = {}, destinationId = config.destinationId ?? 0) {
+    this.native.setBuiltinInstrument(destinationId, config);
   }
   /**
-   * Schedule sample-accurate insert-parameter automation on a strip's insert.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param insertIndex - Index into the strip's combined insert sequence
-   *   (`[pre-inserts... post-inserts...]`)
-   * @param paramId - Processor-specific parameter id
-   * @param samplePos - Absolute samples from the start of processing (the mixer
-   *   advances an internal position from 0 on the first {@link processStereo}
-   *   call; recompiling resets it to 0)
-   * @param value - Target parameter value
-   * @param curve - Interpolation curve (default: `'linear'`)
-   * @throws If the strip index is out of range or the schedule call fails
-   *   (unknown curve, out-of-range insert index, or full event lane)
+   * Bind the patch-driven NativeSynth to a realtime MIDI destination. `patch`
+   * is a {@link SynthPatch} or a preset-name string (`'saw-lead'` /
+   * `'va:saw-lead'`; see {@link synthPresetNames}), resolving exactly like
+   * {@link Project.bounceWithSynthInstrument}. Live note/CC commands and
+   * scheduled MIDI clips routed to that destination render through the synth.
+   * Unknown preset names throw. An object patch's `destinationId` is a JS
+   * binding convenience, not part of the NativeSynth patch itself.
    */
-  scheduleInsertAutomation(stripIndex, insertIndex, paramId, samplePos, value, curve = "linear") {
-    this.mixer.scheduleInsertAutomation(
-      stripIndex,
-      insertIndex,
-      paramId,
-      samplePos,
-      value,
-      automationCurveCode(curve)
-    );
+  setSynthInstrument(patch = {}, destinationId = (typeof patch === "object" ? patch.destinationId : void 0) ?? 0) {
+    this.native.setSynthInstrument(destinationId, patch);
   }
   /**
-   * Resolve a strip's index in `[0, stripCount())` from its scene id, or `null`
-   * when no strip with that id exists (matches the Node binding's `number | null`).
+   * Load (parse) SoundFont 2 bytes into the engine so SF2 instruments can be
+   * bound with {@link setSf2Instrument}. The host fetches the `.sf2` and
+   * passes the raw bytes; they are copied into linear memory for the call and
+   * not referenced afterwards. Replaces any previously loaded SoundFont.
    */
-  stripById(id) {
-    const index = this.mixer.stripById(id);
-    return index < 0 ? null : index;
+  loadSoundFont(data) {
+    this.native.loadSoundFont(data);
   }
   /**
-   * Add a bus to the mixer topology. `role` is one of `'master'`, `'aux'`, or
-   * `'submix'` (defaults to `'aux'`). Marks the routing graph dirty; call
-   * {@link compile} (or {@link processStereo}) to rebuild.
+   * Bind a GS-compatible SoundFont player to a realtime MIDI destination, fed
+   * by the engine's loaded SoundFont ({@link loadSoundFont}). Live note/CC
+   * commands and scheduled MIDI clips routed to that destination render
+   * through the player (16 MIDI channels, channel 10 drums, GS NRPN part
+   * edits, GS/GM SysEx resets). Without a loaded SoundFont — or for programs
+   * the SoundFont does not cover — notes play through the built-in
+   * synthesizer GM fallback bank (the data-free floor).
    */
-  addBus(id, role = "aux") {
-    this.mixer.addBus(id, role);
+  setSf2Instrument(config = {}, destinationId = config.destinationId ?? 0) {
+    this.native.setSf2Instrument(destinationId, config);
   }
-  /** Remove a bus by id. Marks the routing graph dirty. */
-  removeBus(id) {
-    this.mixer.removeBus(id);
+  clearMidiInstrument(destinationId = 0) {
+    this.native.clearMidiInstrument(destinationId);
   }
-  /** Number of buses in the mixer topology. */
-  busCount() {
-    return this.mixer.busCount();
+  midiInstrumentCount() {
+    return this.native.midiInstrumentCount();
   }
   /**
-   * Add a VCA group with the given gain offset (dB). `members` is a list of
-   * strip ids governed by the group (may be empty).
+   * Bind a live MIDI CC to an engine automation parameter. The MIDI event still
+   * reaches the destination instrument; when bound, its 7-bit value is also
+   * mapped into [minValue, maxValue] for `paramId`.
    */
-  addVcaGroup(id, gainDb = 0, members = []) {
-    this.mixer.addVcaGroup(id, gainDb, members);
+  bindMidiCc(channel, controller, paramId, options = {}) {
+    this.native.bindMidiCc(
+      channel,
+      controller,
+      paramId,
+      options.minValue ?? 0,
+      options.maxValue ?? 1
+    );
   }
-  /** Set an existing VCA group's gain in dB. */
-  setVcaGroupGainDb(id, gainDb) {
-    this.mixer.setVcaGroupGainDb(id, gainDb);
+  clearMidiCcBindings() {
+    this.native.clearMidiCcBindings();
   }
-  /** Remove a VCA group by id. */
-  removeVcaGroup(id) {
-    this.mixer.removeVcaGroup(id);
+  midiCcBindingCount() {
+    return this.native.midiCcBindingCount();
   }
-  /** Number of VCA groups in the mixer topology. */
-  vcaGroupCount() {
-    return this.mixer.vcaGroupCount();
+  /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
+  setMidiFx(destinationId, configJson) {
+    this.native.setMidiFx(destinationId, configJson);
   }
-  /** Set the strip's input trim in dB. */
-  setInputTrimDb(stripIndex, db) {
-    this.mixer.setInputTrimDb(stripIndex, db);
+  clearMidiFx(destinationId = 0) {
+    this.native.clearMidiFx(destinationId);
   }
-  /** Set the strip's fader level in dB. */
-  setFaderDb(stripIndex, db) {
-    this.mixer.setFaderDb(stripIndex, db);
-  }
-  /**
-   * Set the strip's pan position.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param pan - Pan position in `[-1, 1]`
-   * @param panMode - Optional pan mode. When omitted the strip's current pan
-   *   mode is kept (passes `SONARE_PAN_MODE_KEEP`), so a plain pan nudge does
-   *   not reset a scene-defined `'stereoPan'` / `'dualPan'` mode back to
-   *   balance. Pass `'balance'` (or `0`) explicitly to force balance mode.
-   */
-  setPan(stripIndex, pan, panMode) {
-    const mode = panMode === void 0 ? -1 : panModeCode(panMode);
-    this.mixer.setPan(stripIndex, pan, mode);
+  /** Enable the engine-owned live MIDI input source for a destination. */
+  setMidiInputSource(destinationId = 0) {
+    this.native.setMidiInputSource(destinationId);
   }
-  /** Set the strip's stereo width. */
-  setWidth(stripIndex, width) {
-    this.mixer.setWidth(stripIndex, width);
+  clearMidiInputSource() {
+    this.native.clearMidiInputSource();
   }
-  /** Set the strip's mute state. */
-  setMuted(stripIndex, muted) {
-    this.mixer.setMuted(stripIndex, muted);
+  midiInputPendingCount() {
+    return this.native.midiInputPendingCount();
   }
   /**
-   * Set a strip's solo state. Takes effect on the next process without a
-   * graph recompile.
+   * Route a destination's (track lane's) MIDI to the external output queue
+   * instead of the internal instrument rack, so the track plays an external
+   * device. Clearing it restores internal-synth playback.
    */
-  setSoloed(stripIndex, soloed) {
-    this.mixer.setSoloed(stripIndex, soloed);
+  setMidiDestinationExternal(destinationId, external) {
+    this.native.setMidiDestinationExternal(destinationId, external);
   }
   /**
-   * Mark a strip solo-safe so it is never implied-muted by another strip's
-   * solo. Takes effect on the next process without a graph recompile.
+   * Enable/disable forwarding MIDI clock + transport (start/continue/stop) to
+   * the external output queue so external gear tracks the transport tempo.
    */
-  setSoloSafe(stripIndex, soloSafe) {
-    this.mixer.setSoloSafe(stripIndex, soloSafe);
-  }
-  /** Invert the polarity of the left and/or right channel of a strip. */
-  setPolarityInvert(stripIndex, invertLeft, invertRight) {
-    this.mixer.setPolarityInvert(stripIndex, invertLeft, invertRight);
+  setExternalMidiClockEnabled(enabled) {
+    this.native.setExternalMidiClockEnabled(enabled);
   }
-  /** Set the strip's pan law. */
-  setPanLaw(stripIndex, panLaw) {
-    this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
+  /** Count of external-MIDI events dropped because the output queue was full. */
+  externalMidiDroppedCount() {
+    return this.native.externalMidiDroppedCount();
   }
   /**
-   * Set a per-strip channel delay in samples. This changes the strip's reported
-   * latency; recompile to re-run latency compensation.
+   * Drain queued external-MIDI events, already lowered to MIDI 1.0 byte
+   * messages ready to write to a Web MIDI output port. Call once per audio
+   * block / animation frame. `maxRecords` caps the number of output events
+   * returned — the shared unit across every surface. Events past the cap stay
+   * queued for the next call (lossless); call again to drain the rest.
    */
-  setChannelDelaySamples(stripIndex, delaySamples) {
-    this.mixer.setChannelDelaySamples(stripIndex, delaySamples);
+  drainExternalMidi(maxRecords = 1024) {
+    return this.native.drainExternalMidi(maxRecords);
   }
-  /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
-  setVcaOffsetDb(stripIndex, offsetDb) {
-    this.mixer.setVcaOffsetDb(stripIndex, offsetDb);
+  pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples = 0) {
+    this.native.pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
   }
-  /** Set independent left/right pan positions (dual-pan mode). */
-  setDualPan(stripIndex, leftPan, rightPan) {
-    this.mixer.setDualPan(stripIndex, leftPan, rightPan);
+  pushMidiInputNoteOff(group, channel, note, velocity = 0, portTimeSamples = 0) {
+    this.native.pushMidiInputNoteOff(group, channel, note, velocity, portTimeSamples);
   }
-  /**
-   * Set the strip's surround pan position, used when it feeds a >2-channel bus.
-   * Stored on the scene; inert until the surround DSP path applies it.
-   */
-  setSurroundPan(stripIndex, pan) {
-    this.mixer.setSurroundPan(stripIndex, pan);
+  pushMidiInputCc(group, channel, controller, value, portTimeSamples = 0) {
+    this.native.pushMidiInputCc(group, channel, controller, value, portTimeSamples);
   }
-  /**
-   * Add a send to a strip after construction.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param id - Send id
-   * @param destinationBusId - Destination bus id
-   * @param sendDb - Initial send level in dB
-   * @param timing - `'preFader'` or `'postFader'` (default: `'postFader'`)
-   * @returns The new send's index
-   */
-  addSend(stripIndex, id, destinationBusId, sendDb = 0, timing = "postFader") {
-    return this.mixer.addSend(stripIndex, id, destinationBusId, sendDb, sendTimingCode(timing));
+  pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame = -1) {
+    this.native.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
   }
-  /** Set the send level (in dB) for an existing send by index. */
-  setSendDb(stripIndex, sendIndex, sendDb) {
-    this.mixer.setSendDb(stripIndex, sendIndex, sendDb);
+  pushMidiNoteOff(destinationId, group, channel, note, velocity = 0, renderFrame = -1) {
+    this.native.pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
   }
   /**
-   * Remove an existing send from a strip by index.
-   *
-   * Sends are addressed in add order. After removal, sends with a higher index
-   * than `sendIndex` shift down by one. Recompile (or process) before reading
-   * results so the routing graph rebuilds.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param sendIndex - Send index in add order
+   * Queue an immediate (live) MIDI control change to a MIDI destination
+   * (engine kMidiCcImmediate). `group`/`channel` are 0..15; `controller`/`value`
+   * are 7-bit (0..127). `renderFrame` is the frame to fire at, or -1 for
+   * immediate. Mirrors the Node/Python/C-ABI `pushMidiCc`.
    */
-  removeSend(stripIndex, sendIndex) {
-    this.mixer.removeSend(stripIndex, sendIndex);
+  pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
+    this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
   /**
-   * Read a strip's meter snapshot at the given tap point.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+   * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
+   * the full message including the leading 0xF0 and trailing 0xF7 (1..512
+   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Mirrors
+   * the Node/Python/C-ABI `pushMidiSysex`.
    */
-  meterTap(stripIndex, tap = "postFader") {
-    return this.mixer.meterTap(stripIndex, meterTapCode(tap));
+  pushMidiSysex(destinationId, data, renderFrame = -1) {
+    this.native.pushMidiSysex(destinationId, data, renderFrame);
   }
   /**
-   * Read a strip's meter snapshot.
-   *
-   * With no `tap` argument this reads the strip's own (post-fader) meter,
-   * matching the Node/Python tap-less `stripMeter` contract. Pass an optional
-   * `tap` (`'preFader'` / `'postFader'`) to read the tap-selectable snapshot
-   * instead — the same backing call as {@link meterTap}.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param tap - Optional tap point (`'preFader'` / `'postFader'`); when omitted
-   *   the tap-less post-fader strip meter is read.
+   * Queue a MIDI panic (all-notes-off) releasing every sounding note at
+   * `renderFrame` (-1 = immediate). Mirrors the C-ABI `pushMidiPanic`.
    */
-  stripMeter(stripIndex, tap) {
-    if (tap === void 0) {
-      return this.mixer.stripMeter(stripIndex);
-    }
-    return this.mixer.meterTap(stripIndex, meterTapCode(tap));
+  pushMidiPanic(renderFrame = -1) {
+    this.native.pushMidiPanic(renderFrame);
   }
   /**
-   * Schedule sample-accurate fader automation on a strip.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param samplePos - Absolute samples from the start of processing
-   * @param faderDb - Target fader level in dB
-   * @param curve - Interpolation curve (default: `'linear'`)
+   * Remove all registered parameters (and their automation lanes). Control-thread
+   * only; not realtime-safe. Mirrors the C-ABI `clearParameters`.
    */
-  scheduleFaderAutomation(stripIndex, samplePos, faderDb, curve = "linear") {
-    this.mixer.scheduleFaderAutomation(stripIndex, samplePos, faderDb, automationCurveCode(curve));
+  clearParameters() {
+    this.native.clearParameters();
   }
-  /**
-   * Schedule sample-accurate pan automation on a strip.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param samplePos - Absolute samples from the start of processing
-   * @param pan - Target pan position
-   * @param curve - Interpolation curve (default: `'linear'`)
-   */
-  schedulePanAutomation(stripIndex, samplePos, pan, curve = "linear") {
-    this.mixer.schedulePanAutomation(stripIndex, samplePos, pan, automationCurveCode(curve));
+  /** Read back the current transport state snapshot. */
+  getTransportState() {
+    return this.native.getTransportState();
   }
-  /**
-   * Schedule sample-accurate width automation on a strip.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param samplePos - Absolute samples from the start of processing
-   * @param width - Target stereo width
-   * @param curve - Interpolation curve (default: `'linear'`)
-   */
-  scheduleWidthAutomation(stripIndex, samplePos, width, curve = "linear") {
-    this.mixer.scheduleWidthAutomation(stripIndex, samplePos, width, automationCurveCode(curve));
+  play(renderFrame = -1) {
+    this.native.play(renderFrame);
   }
-  /**
-   * Schedule sample-accurate send-level automation on a strip's send.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param sendIndex - Send index in the strip's add order
-   * @param samplePos - Absolute samples from the start of processing
-   * @param db - Target send level in dB
-   * @param curve - Interpolation curve (default: `'linear'`)
-   */
-  scheduleSendAutomation(stripIndex, sendIndex, samplePos, db, curve = "linear") {
-    this.mixer.scheduleSendAutomation(
-      stripIndex,
-      sendIndex,
-      samplePos,
-      db,
-      automationCurveCode(curve)
-    );
+  stop(renderFrame = -1) {
+    this.native.stop(renderFrame);
+  }
+  seekSample(timelineSample, renderFrame = -1) {
+    this.native.seekSample(timelineSample, renderFrame);
   }
   /**
-   * Read up to `maxPoints` of a strip's most recent goniometer samples
-   * (oldest to newest).
+   * Snaps every in-flight parameter ramp (engine-level smoothed params, mixer
+   * lane fader/pan/gate, bus gains) to its target value. Offline renders call
+   * this after a priming process() block so the first audible block renders at
+   * settled values instead of ramping in from defaults.
    */
-  readGoniometerLatest(stripIndex, maxPoints) {
-    return this.mixer.readGoniometerLatest(stripIndex, maxPoints);
+  settleParameters() {
+    this.native.settleParameters();
   }
-  /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
-  toSceneJson() {
-    return this.mixer.toSceneJson();
+  seekPpq(ppq, renderFrame = -1) {
+    this.native.seekPpq(ppq, renderFrame);
   }
-  /**
-   * Longest audible serial processor-tail path to the master, in samples. Lazily
-   * compiles the routing graph if the topology is dirty.
-   */
-  tailSamples() {
-    return this.mixer.tailSamples();
+  setTempo(bpm) {
+    this.native.setTempo(bpm);
   }
-  /**
-   * Reported latency (samples) of the compiled mixer graph, for aligning
-   * dry/wet material. Lazily compiles the routing graph if the topology is dirty.
-   */
-  latencySamples() {
-    return this.mixer.latencySamples();
+  setTempoSegments(segments) {
+    this.native.setTempoSegments([...segments]);
   }
-  /**
-   * Drain delayed / tail audio by processing a zero-input block of `numSamples`
-   * frames after the host stops feeding strip inputs. Returns the mixed stereo
-   * master (`left`, `right`, `sampleRate`).
-   */
-  drainTailStereo(numSamples) {
-    return this.mixer.drainTailStereo(numSamples);
+  setTimeSignature(numerator, denominator) {
+    this.native.setTimeSignature(numerator, denominator);
   }
-  /** Release the underlying WASM object. Safe to call only once. */
-  delete() {
-    this.mixer.delete();
+  setTimeSignatureSegments(segments) {
+    this.native.setTimeSignatureSegments([...segments]);
   }
-  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
-  destroy() {
-    this.delete();
+  sampleAtPpq(ppq) {
+    return Number(this.native.sampleAtPpq(ppq));
   }
-};
-
-// src/realtime_voice_changer.ts
-var RealtimeVoiceChanger = class {
-  constructor(config = "neutral-monitor") {
-    const module2 = getSonareModule();
-    this.changer = module2.createRealtimeVoiceChanger(config);
+  setLoop(startPpq, endPpq, enabled = true) {
+    this.native.setLoop(startPpq, endPpq, enabled);
   }
-  prepare(sampleRate, maxBlockSize = 128, channels = 1) {
-    this.changer.prepare(sampleRate, maxBlockSize, channels);
+  addParameter(info) {
+    this.native.addParameter(info);
   }
-  reset() {
-    this.changer.reset();
+  parameterCount() {
+    return this.native.parameterCount();
   }
-  setConfig(config) {
-    this.changer.setConfig(config);
+  parameterInfoByIndex(index) {
+    return this.native.parameterInfoByIndex(index);
   }
-  configJson() {
-    return this.changer.configJson();
+  parameterInfo(id) {
+    return this.native.parameterInfo(id);
   }
-  latencySamples() {
-    return this.changer.latencySamples();
+  setAutomationLane(paramId, points) {
+    this.native.setAutomationLane(paramId, points);
   }
-  processMono(samples) {
-    return this.changer.processMono(samples);
+  automationLaneCount() {
+    return this.native.automationLaneCount();
   }
-  processMonoInto(samples, output) {
-    this.changer.processMonoInto(samples, output);
+  setMarkers(markers) {
+    this.native.setMarkers(markers);
   }
-  processInterleaved(samples, channels) {
-    return this.changer.processInterleaved(samples, channels);
+  markerCount() {
+    return this.native.markerCount();
   }
-  processInterleavedInto(samples, channels, output) {
-    this.changer.processInterleavedInto(samples, channels, output);
+  markerByIndex(index) {
+    return this.native.markerByIndex(index);
   }
-  /**
-   * Acquire a typed-memory view onto the WASM heap for mono input.
-   *
-   * Write your input samples into the returned `Float32Array` directly (e.g.
-   * via `input.set(source)`); no copy crosses the JS↔C++ bridge until
-   * {@link processPreparedMono} is called. The view is owned by this
-   * RealtimeVoiceChanger and becomes invalid after {@link delete}; it may
-   * also be invalidated if you later call this method with a larger
-   * `numSamples` value (the underlying buffer may be reallocated).
-   */
-  getMonoInputBuffer(numSamples) {
-    return this.changer.getMonoInputBuffer(numSamples);
+  marker(id) {
+    return this.native.marker(id);
   }
-  /** Mono output view counterpart to {@link getMonoInputBuffer}. */
-  getMonoOutputBuffer(numSamples) {
-    return this.changer.getMonoOutputBuffer(numSamples);
+  seekMarker(markerId, renderFrame = -1) {
+    this.native.seekMarker(markerId, renderFrame);
+  }
+  setLoopFromMarkers(startMarkerId, endMarkerId) {
+    this.native.setLoopFromMarkers(startMarkerId, endMarkerId);
+  }
+  setMetronome(config) {
+    this.native.setMetronome(config);
+  }
+  metronome() {
+    return this.native.metronome();
+  }
+  countInEndSample(startSample, bars) {
+    return Number(this.native.countInEndSample(startSample, bars));
+  }
+  setGraph(spec) {
+    this.native.setGraph(spec);
+  }
+  graphNodeCount() {
+    return this.native.graphNodeCount();
+  }
+  graphConnectionCount() {
+    return this.native.graphConnectionCount();
+  }
+  setClips(clips) {
+    this.native.setClips(
+      clips.map((clip) => ({
+        ...clip,
+        pageProvider: typeof clip.pageProvider === "object" && clip.pageProvider !== null ? clip.pageProvider.id : clip.pageProvider
+      }))
+    );
   }
   /**
-   * Process the previously-acquired mono input buffer in place. The output
-   * appears in the buffer returned by {@link getMonoOutputBuffer}. No JS↔C++
-   * sample-level crossings happen on this call — it just hands control to
-   * the underlying DSP on already-on-heap data.
+   * Returns the PCM generated for a tempo-sync clip by the control-thread
+   * setter, or `null` when the clip did not require a tempo-sync bake.
    */
-  processPreparedMono(numSamples) {
-    this.changer.processPreparedMono(numSamples);
+  prebakedClipChannels(clipId) {
+    return this.native.prebakedClipChannels(clipId);
   }
-  /** Interleaved input view (layout L0,R0,L1,R1,...). */
-  getInterleavedInputBuffer(numFrames, numChannels) {
-    return this.changer.getInterleavedInputBuffer(numFrames, numChannels);
+  clipCount() {
+    return this.native.clipCount();
   }
-  /** Interleaved output view counterpart. */
-  getInterleavedOutputBuffer(numFrames, numChannels) {
-    return this.changer.getInterleavedOutputBuffer(numFrames, numChannels);
+  setTrackLanes(lanes) {
+    this.native.setTrackLanes(
+      lanes.map((lane) => {
+        if (typeof lane === "number") {
+          return { trackId: lane };
+        }
+        if (!lane.sends) {
+          return lane;
+        }
+        return {
+          ...lane,
+          sends: lane.sends.map((send) => ({
+            ...send,
+            // Post-fader (0) is the default for an omitted sendTiming.
+            sendTiming: send.sendTiming === void 0 ? 0 : sendTimingCode(send.sendTiming)
+          }))
+        };
+      })
+    );
   }
   /**
-   * Process the previously-acquired interleaved buffer in place. Output
-   * appears in the buffer returned by {@link getInterleavedOutputBuffer}.
+   * Keys one insert of a lane strip from another lane's post-strip audio
+   * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
    */
-  processPreparedInterleaved(numFrames, numChannels) {
-    this.changer.processPreparedInterleaved(numFrames, numChannels);
+  setLaneSidechain(trackId, insertIndex, sourceTrackId) {
+    this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+  }
+  setTrackBuses(buses) {
+    this.native.setTrackBuses(buses);
+  }
+  setBusStripJson(busId, sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid bus strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setBusStripJson(busId, sceneJson);
+  }
+  setTrackStripJson(trackId, sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid track strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setTrackStripJson(trackId, sceneJson);
+  }
+  setTrackStripEqBand(trackId, bandIndex, band) {
+    this.native.setTrackStripEqBandJson(
+      trackId,
+      bandIndex,
+      typeof band === "string" ? band : JSON.stringify(band)
+    );
+  }
+  setTrackStripEqBandJson(trackId, bandIndex, bandJson) {
+    this.native.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+  }
+  setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass = false) {
+    this.native.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
+  }
+  setMasterStripJson(sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid master strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setMasterStripJson(sceneJson);
+  }
+  setMasterStripEqBand(bandIndex, band) {
+    this.native.setMasterStripEqBandJson(
+      bandIndex,
+      typeof band === "string" ? band : JSON.stringify(band)
+    );
+  }
+  setMasterStripEqBandJson(bandIndex, bandJson) {
+    this.native.setMasterStripEqBandJson(bandIndex, bandJson);
+  }
+  setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass = false) {
+    this.native.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
   }
   /**
-   * Planar-channel input/output view (one Float32Array per channel). Matches
-   * AudioWorklet's native layout; processing happens in place.
+   * Changes one track-strip insert parameter in realtime, addressed by the
+   * processor's JSON-key parameter name (see {@link masteringInsertParamInfo}).
+   * Applied at the next block head via the engine command queue; safe during
+   * playback. Throws if the track, insert, or name is unknown, the param is not
+   * realtime-safe, or the command queue is full.
    */
-  getPlanarChannelBuffer(channel, numFrames) {
-    return this.changer.getPlanarChannelBuffer(channel, numFrames);
+  setTrackStripInsertParamByName(trackId, insertIndex, paramName, value) {
+    this.native.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+  }
+  /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
+  setMasterStripInsertParamByName(insertIndex, paramName, value) {
+    this.native.setMasterStripInsertParamByName(insertIndex, paramName, value);
+  }
+  /** Bus-strip counterpart of {@link setTrackStripInsertParamByName}. */
+  setBusStripInsertParamByName(busId, insertIndex, paramName, value) {
+    this.native.setBusStripInsertParamByName(busId, insertIndex, paramName, value);
+  }
+  /** Bus-strip counterpart of {@link setTrackStripInsertBypassed}. */
+  setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass = false) {
+    this.native.setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass);
   }
   /**
-   * Process the previously-acquired planar channel buffers in place. Each
-   * channel must have been obtained from {@link getPlanarChannelBuffer}
-   * with the same `numFrames`. Output replaces input in the same buffers.
+   * Resolves a track-lane insert parameter (by its JSON-key name) to the
+   * reserved automation id usable with `setAutomationLane` / `setParameter`.
+   * Returns `-1` when the track, insert, or name is unknown. (The Python binding
+   * raises a `SonareError` for an unknown id where Node/WASM return the `-1`
+   * sentinel.)
    */
-  processPreparedPlanar(numFrames) {
-    this.changer.processPreparedPlanar(numFrames);
+  resolveTrackInsertAutomationId(trackId, insertIndex, paramName) {
+    return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
+  }
+  resolveMasterInsertAutomationId(insertIndex, paramName) {
+    return this.native.resolveMasterInsertAutomationId(insertIndex, paramName);
+  }
+  resolveBusInsertAutomationId(busId, insertIndex, paramName) {
+    return this.native.resolveBusInsertAutomationId(busId, insertIndex, paramName);
+  }
+  /** Sets a track lane strip's pan position in realtime (glitch-free). */
+  setTrackStripPan(trackId, pan) {
+    this.native.setTrackStripPan(trackId, pan);
+  }
+  /** Sets a track lane strip's pan law in realtime. */
+  setTrackStripPanLaw(trackId, panLaw) {
+    this.native.setTrackStripPanLaw(trackId, panLawCode(panLaw));
+  }
+  /** Sets a track lane strip's pan mode in realtime. */
+  setTrackStripPanMode(trackId, panMode) {
+    this.native.setTrackStripPanMode(trackId, panModeCode(panMode));
+  }
+  /** Sets a track lane strip's dual-pan left/right positions in realtime. */
+  setTrackStripDualPan(trackId, leftPan, rightPan) {
+    this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
   }
   /**
-   * Convenience factory for the mono zero-copy path: returns the input/output
-   * heap views plus a `process()` thunk wired to the same `numSamples`. The
-   * views are reused across calls and become invalid after {@link delete}.
+   * Sets a track lane strip's inter-channel alignment delay (whole samples).
+   * Adjusts strip latency, so PDC and reported graph latency are refreshed.
    */
-  createRealtimeMonoBuffer(numSamples) {
-    let input = this.getMonoInputBuffer(numSamples);
-    let output = this.getMonoOutputBuffer(numSamples);
-    const reacquireIfDetached = () => {
-      if (input.byteLength === 0 || output.byteLength === 0) {
-        input = this.getMonoInputBuffer(numSamples);
-        output = this.getMonoOutputBuffer(numSamples);
-      }
-    };
-    return {
-      get input() {
-        reacquireIfDetached();
-        return input;
-      },
-      get output() {
-        reacquireIfDetached();
-        return output;
-      },
-      process: () => {
-        reacquireIfDetached();
-        this.processPreparedMono(numSamples);
-      }
-    };
+  setTrackStripChannelDelaySamples(trackId, delaySamples) {
+    this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
   }
-  /** Same as {@link createRealtimeMonoBuffer} but for interleaved I/O. */
-  createRealtimeInterleavedBuffer(numFrames, numChannels) {
-    let input = this.getInterleavedInputBuffer(numFrames, numChannels);
-    let output = this.getInterleavedOutputBuffer(numFrames, numChannels);
-    const reacquireIfDetached = () => {
-      if (input.byteLength === 0 || output.byteLength === 0) {
-        input = this.getInterleavedInputBuffer(numFrames, numChannels);
-        output = this.getInterleavedOutputBuffer(numFrames, numChannels);
-      }
-    };
-    return {
-      get input() {
-        reacquireIfDetached();
-        return input;
-      },
-      get output() {
-        reacquireIfDetached();
-        return output;
-      },
-      channels: numChannels,
-      process: () => {
-        reacquireIfDetached();
-        this.processPreparedInterleaved(numFrames, numChannels);
-      }
-    };
+  createClipPageProvider(numChannels, numSamples, pageFrames) {
+    const id = this.native.createClipPageProvider(numChannels, numSamples, pageFrames);
+    return new ClipPageProvider(this, id);
   }
-  /**
-   * Convenience factory for the planar zero-copy path. Acquires one
-   * heap-backed Float32Array per channel and returns a `process()` thunk
-   * wired to the same `numFrames`. Buffers are reused across calls and
-   * become invalid after {@link delete}.
-   */
-  createRealtimePlanarBuffer(numFrames, numChannels) {
-    let channels = [];
-    const acquire = () => {
-      channels = [];
-      for (let ch = 0; ch < numChannels; ch++) {
-        channels.push(this.getPlanarChannelBuffer(ch, numFrames));
-      }
-    };
-    acquire();
-    const reacquireIfDetached = () => {
-      if ((channels[0]?.byteLength ?? 0) === 0) {
-        acquire();
-      }
-    };
-    return {
-      get channels() {
-        reacquireIfDetached();
-        return channels;
-      },
-      process: () => {
-        reacquireIfDetached();
-        this.processPreparedPlanar(numFrames);
-      }
-    };
+  supplyClipPage(providerId, pageIndex, channels) {
+    this.native.supplyClipPage(providerId, pageIndex, channels);
   }
-  delete() {
-    this.changer.delete();
+  clearClipPage(providerId, pageIndex) {
+    this.native.clearClipPage(providerId, pageIndex);
   }
-};
-
-// src/realtime_engine.ts
-var EXPECTED_ENGINE_ABI_VERSION = 3;
-function engineCapabilities() {
-  const abiVersion = getSonareModule().engineAbiVersion();
-  const sharedArrayBuffer = typeof globalThis.SharedArrayBuffer === "function";
-  const atomics = typeof globalThis.Atomics === "object";
-  const audioWorklet = typeof AudioWorkletNode !== "undefined" || typeof globalThis.AudioWorkletProcessor !== "undefined";
-  return {
-    engineAbiVersion: abiVersion,
-    expectedEngineAbiVersion: EXPECTED_ENGINE_ABI_VERSION,
-    abiCompatible: abiVersion === EXPECTED_ENGINE_ABI_VERSION,
-    sharedArrayBuffer,
-    atomics,
-    audioWorklet,
-    mode: sharedArrayBuffer && atomics ? "sab" : "postMessage"
-  };
-}
-var RealtimeEngine = class {
-  constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024) {
-    const module2 = getSonareModule();
-    const capabilities = engineCapabilities();
-    if (!capabilities.abiCompatible) {
-      throw new Error(
-        `Engine ABI mismatch: wasm=${capabilities.engineAbiVersion}, expected=${capabilities.expectedEngineAbiVersion}`
-      );
-    }
-    this.native = new module2.RealtimeEngine(
-      sampleRate,
-      maxBlockSize,
-      commandCapacity,
-      telemetryCapacity
-    );
+  destroyClipPageProvider(providerId) {
+    this.native.destroyClipPageProvider(providerId);
   }
-  prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024) {
-    this.native.prepare(sampleRate, maxBlockSize, commandCapacity, telemetryCapacity);
+  popClipPageRequest() {
+    return this.native.popClipPageRequest();
   }
-  /** Queue a sample-accurate parameter change (engine kSetParam). */
-  setParameter(paramId, value, renderFrame = -1) {
-    this.native.setParameter(paramId, value, renderFrame);
+  setCaptureBuffer(numChannels, capacityFrames) {
+    this.native.setCaptureBuffer(numChannels, capacityFrames);
   }
-  /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
-  setParameterSmoothed(paramId, value, renderFrame = -1) {
-    this.native.setParameterSmoothed(paramId, value, renderFrame);
+  armCapture(armed = true) {
+    this.native.armCapture(armed);
   }
-  /**
-   * Set the default ramp time (ms) for engine-level smoothed parameters —
-   * fader/pan glides, insert-parameter automation, and MIDI-CC mappings. The
-   * default is 20 ms; pass `0` for instant (un-ramped) changes.
-   */
-  setParamSmoothingMs(smoothingMs) {
-    this.native.setParamSmoothingMs(smoothingMs);
+  setCapturePunch(startSample, endSample, enabled = true) {
+    this.native.setCapturePunch(startSample, endSample, enabled);
   }
-  setSoloMute(laneIndex, solo, mute, renderFrame = -1) {
-    this.native.setSoloMute(laneIndex, solo, mute, renderFrame);
+  setCaptureSource(source) {
+    this.native.setCaptureSource(source);
   }
-  setMidiClips(clips) {
-    this.native.setMidiClips(clips);
+  setRecordOffsetSamples(offsetSamples) {
+    this.native.setRecordOffsetSamples(offsetSamples);
   }
-  setBuiltinInstrument(config = {}, destinationId = config.destinationId ?? 0) {
-    this.native.setBuiltinInstrument(destinationId, config);
+  setInputMonitor(enabled, gain = 1) {
+    this.native.setInputMonitor(enabled, gain);
   }
-  /**
-   * Bind the patch-driven NativeSynth to a realtime MIDI destination. `patch`
-   * is a {@link SynthPatch} or a preset-name string (`'saw-lead'` /
-   * `'va:saw-lead'`; see {@link synthPresetNames}), resolving exactly like
-   * {@link Project.bounceWithSynthInstrument}. Live note/CC commands and
-   * scheduled MIDI clips routed to that destination render through the synth.
-   * Unknown preset names throw. An object patch's `destinationId` is a JS
-   * binding convenience, not part of the NativeSynth patch itself.
-   */
-  setSynthInstrument(patch = {}, destinationId = (typeof patch === "object" ? patch.destinationId : void 0) ?? 0) {
-    this.native.setSynthInstrument(destinationId, patch);
+  resetCapture() {
+    this.native.resetCapture();
+  }
+  captureStatus() {
+    return this.native.captureStatus();
+  }
+  capturedAudio() {
+    return this.native.capturedAudio();
+  }
+  process(channels) {
+    return this.native.process(channels);
   }
   /**
-   * Load (parse) SoundFont 2 bytes into the engine so SF2 instruments can be
-   * bound with {@link setSf2Instrument}. The host fetches the `.sf2` and
-   * passes the raw bytes; they are copied into linear memory for the call and
-   * not referenced afterwards. Replaces any previously loaded SoundFont.
+   * Allocates persistent per-channel WASM-heap scratch for the zero-copy
+   * `getChannelBuffer` / `processPrepared` realtime path. Call once (off the
+   * audio thread) before driving `processPrepared` from an AudioWorklet so the
+   * render callback never allocates on the C++/JS heap.
    */
-  loadSoundFont(data) {
-    this.native.loadSoundFont(data);
+  prepareChannels(numChannels, maxFrames) {
+    this.native.prepareChannels(numChannels, maxFrames);
   }
   /**
-   * Bind a GS-compatible SoundFont player to a realtime MIDI destination, fed
-   * by the engine's loaded SoundFont ({@link loadSoundFont}). Live note/CC
-   * commands and scheduled MIDI clips routed to that destination render
-   * through the player (16 MIDI channels, channel 10 drums, GS NRPN part
-   * edits, GS/GM SysEx resets). Without a loaded SoundFont — or for programs
-   * the SoundFont does not cover — notes play through the built-in
-   * synthesizer GM fallback bank (the data-free floor).
+   * Returns a Float32Array view onto the persistent WASM-heap scratch for one
+   * channel (valid for up to `numFrames`). Fill it, call `processPrepared`, then
+   * read the same view back. Re-acquire after WASM memory growth.
    */
-  setSf2Instrument(config = {}, destinationId = config.destinationId ?? 0) {
-    this.native.setSf2Instrument(destinationId, config);
-  }
-  clearMidiInstrument(destinationId = 0) {
-    this.native.clearMidiInstrument(destinationId);
-  }
-  midiInstrumentCount() {
-    return this.native.midiInstrumentCount();
+  getChannelBuffer(channel, numFrames) {
+    return this.native.getChannelBuffer(channel, numFrames);
   }
   /**
-   * Bind a live MIDI CC to an engine automation parameter. The MIDI event still
-   * reaches the destination instrument; when bound, its 7-bit value is also
-   * mapped into [minValue, maxValue] for `paramId`.
+   * Runs the engine in place over the prepared per-channel scratch buffers.
+   * Allocation-free: safe to call on the AudioWorklet render thread after
+   * `prepareChannels`.
    */
-  bindMidiCc(channel, controller, paramId, options = {}) {
-    this.native.bindMidiCc(
-      channel,
-      controller,
-      paramId,
-      options.minValue ?? 0,
-      options.maxValue ?? 1
-    );
+  processPrepared(numFrames) {
+    this.native.processPrepared(numFrames);
   }
-  clearMidiCcBindings() {
-    this.native.clearMidiCcBindings();
+  processWithMonitor(channels) {
+    return this.native.processWithMonitor(channels);
   }
-  midiCcBindingCount() {
-    return this.native.midiCcBindingCount();
+  renderOffline(channels, blockSize = 128) {
+    return this.native.renderOffline(channels, blockSize);
   }
-  /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
-  setMidiFx(destinationId, configJson) {
-    this.native.setMidiFx(destinationId, configJson);
+  bounceOffline(options) {
+    return this.native.bounceOffline(options);
   }
-  clearMidiFx(destinationId = 0) {
-    this.native.clearMidiFx(destinationId);
+  freezeOffline(options) {
+    return this.native.freezeOffline(options);
   }
-  /** Enable the engine-owned live MIDI input source for a destination. */
-  setMidiInputSource(destinationId = 0) {
-    this.native.setMidiInputSource(destinationId);
+  drainTelemetry(maxRecords = 1024) {
+    return this.native.drainTelemetry(maxRecords);
   }
-  clearMidiInputSource() {
-    this.native.clearMidiInputSource();
-  }
-  midiInputPendingCount() {
-    return this.native.midiInputPendingCount();
+  drainMeterTelemetry(maxRecords = 1024) {
+    return this.native.drainMeterTelemetry(maxRecords);
   }
   /**
-   * Route a destination's (track lane's) MIDI to the external output queue
-   * instead of the internal instrument rack, so the track plays an external
-   * device. Clearing it restores internal-synth playback.
+   * Drains pending meter telemetry as per-plane (wide) records for a surround
+   * target. Use this for a surround mix target; {@link drainMeterTelemetry}
+   * stays the stereo fast path. The two share one queue — call only one per
+   * target. The live AudioWorklet path owns the queue via the stereo drain, so
+   * this wide drain is for an offline (non-worklet) engine instance; per-plane
+   * surround meters are not delivered over the live worklet meter ring.
    */
-  setMidiDestinationExternal(destinationId, external) {
-    this.native.setMidiDestinationExternal(destinationId, external);
+  drainMeterTelemetryWide(maxRecords = 1024) {
+    return this.native.drainMeterTelemetryWide(maxRecords);
   }
   /**
-   * Enable/disable forwarding MIDI clock + transport (start/continue/stop) to
-   * the external output queue so external gear tracks the transport tempo.
+   * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
+   * the minimum render-frame gap between snapshots (0 disables). @param bandCount
+   * is the FFT band resolution (1..64); changing it re-prepares the tap. Returns
+   * the band count actually applied.
    */
-  setExternalMidiClockEnabled(enabled) {
-    this.native.setExternalMidiClockEnabled(enabled);
+  configureScopeTelemetry(intervalFrames, bandCount) {
+    return this.native.configureScopeTelemetry(intervalFrames, bandCount);
   }
-  /** Count of external-MIDI events dropped because the output queue was full. */
-  externalMidiDroppedCount() {
-    return this.native.externalMidiDroppedCount();
+  /** Drains pending spectrum + vectorscope snapshots (per mix target). */
+  drainScopeTelemetry(maxRecords = 1024) {
+    return this.native.drainScopeTelemetry(maxRecords);
   }
-  /**
-   * Drain queued external-MIDI events, already lowered to MIDI 1.0 byte
-   * messages ready to write to a Web MIDI output port. Call once per audio
-   * block / animation frame. `maxRecords` caps the number of output events
-   * returned — the shared unit across every surface. Events past the cap stay
-   * queued for the next call (lossless); call again to drain the rest.
-   */
-  drainExternalMidi(maxRecords = 1024) {
-    return this.native.drainExternalMidi(maxRecords);
+  destroy() {
+    this.native.delete();
   }
-  pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples = 0) {
-    this.native.pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
+};
+var ClipPageProvider = class {
+  constructor(engine, id) {
+    this.engine = engine;
+    this.id = id;
+    this.disposed = false;
   }
-  pushMidiInputNoteOff(group, channel, note, velocity = 0, portTimeSamples = 0) {
-    this.native.pushMidiInputNoteOff(group, channel, note, velocity, portTimeSamples);
+  supply(pageIndex, channels) {
+    if (this.disposed) {
+      throw new Error("ClipPageProvider is destroyed");
+    }
+    this.engine.supplyClipPage(this.id, pageIndex, channels);
   }
-  pushMidiInputCc(group, channel, controller, value, portTimeSamples = 0) {
-    this.native.pushMidiInputCc(group, channel, controller, value, portTimeSamples);
+  clear(pageIndex) {
+    if (this.disposed) {
+      return;
+    }
+    this.engine.clearClipPage(this.id, pageIndex);
   }
-  pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame = -1) {
-    this.native.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
+  destroy() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.engine.destroyClipPageProvider(this.id);
   }
-  pushMidiNoteOff(destinationId, group, channel, note, velocity = 0, renderFrame = -1) {
-    this.native.pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
+};
+
+// src/mixer.ts
+var Mixer = class _Mixer {
+  constructor(mixer, blockSize) {
+    this.mixer = mixer;
+    this.blockSize = blockSize;
   }
   /**
-   * Queue an immediate (live) MIDI control change to a MIDI destination
-   * (engine kMidiCcImmediate). `group`/`channel` are 0..15; `controller`/`value`
-   * are 7-bit (0..127). `renderFrame` is the frame to fire at, or -1 for
-   * immediate. Mirrors the Node/Python/C-ABI `pushMidiCc`.
+   * Build a mixer from a scene JSON string.
+   *
+   * @param json - Scene JSON (strips, buses, sends, connections, inserts)
+   * @param sampleRate - Sample rate in Hz (default: 48000)
+   * @param blockSize - Maximum block size per {@link processStereo} call (default: 512)
    */
-  pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
-    this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
+  static fromSceneJson(json, sampleRate = 48e3, blockSize = 512) {
+    const module2 = getSonareModule();
+    return new _Mixer(module2.createMixerFromSceneJson(json, sampleRate, blockSize), blockSize);
+  }
+  /** Rebuild and compile the routing graph from the current scene topology. */
+  compile() {
+    this.mixer.compile();
   }
   /**
-   * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
-   * the full message including the leading 0xF0 and trailing 0xF7 (1..512
-   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Mirrors
-   * the Node/Python/C-ABI `pushMidiSysex`.
+   * Non-fatal warnings captured when this mixer was built from scene JSON: one
+   * entry per channel-strip insert that was handed param keys it does not read
+   * (a likely typo, or a key meant for a different processor). The scene still
+   * loaded; these keys simply took no effect. Empty when every key was consumed.
+   * Use {@link masteringInsertParamNames} to discover the keys an insert accepts.
    */
-  pushMidiSysex(destinationId, data, renderFrame = -1) {
-    this.native.pushMidiSysex(destinationId, data, renderFrame);
+  sceneWarnings() {
+    return this.mixer.sceneWarnings();
   }
   /**
-   * Queue a MIDI panic (all-notes-off) releasing every sounding note at
-   * `renderFrame` (-1 = immediate). Mirrors the C-ABI `pushMidiPanic`.
+   * Mix one block of per-strip stereo audio into the stereo master.
+   *
+   * @param leftChannels - `leftChannels[i]` is the left channel of strip `i`
+   * @param rightChannels - `rightChannels[i]` is the right channel of strip `i`
+   * @returns Mixed stereo master (`left`, `right`, `sampleRate`)
    */
-  pushMidiPanic(renderFrame = -1) {
-    this.native.pushMidiPanic(renderFrame);
+  processStereo(leftChannels, rightChannels) {
+    if (leftChannels.length !== rightChannels.length) {
+      throw new Error("leftChannels and rightChannels must have the same length.");
+    }
+    return this.mixer.processStereo(leftChannels, rightChannels);
   }
   /**
-   * Remove all registered parameters (and their automation lanes). Control-thread
-   * only; not realtime-safe. Mirrors the C-ABI `clearParameters`.
+   * Mix one block into caller-owned output arrays.
+   *
+   * This avoids allocating the result object and result `Float32Array`s. It is
+   * intended for realtime bridges such as AudioWorklet; the input channel count
+   * must match the scene strip count and all arrays must have the same length.
    */
-  clearParameters() {
-    this.native.clearParameters();
-  }
-  /** Read back the current transport state snapshot. */
-  getTransportState() {
-    return this.native.getTransportState();
-  }
-  play(renderFrame = -1) {
-    this.native.play(renderFrame);
-  }
-  stop(renderFrame = -1) {
-    this.native.stop(renderFrame);
-  }
-  seekSample(timelineSample, renderFrame = -1) {
-    this.native.seekSample(timelineSample, renderFrame);
+  processStereoInto(leftChannels, rightChannels, outLeft, outRight) {
+    if (leftChannels.length !== rightChannels.length) {
+      throw new Error("leftChannels and rightChannels must have the same length.");
+    }
+    if (outLeft.length !== outRight.length) {
+      throw new Error("outLeft and outRight must have the same length.");
+    }
+    this.mixer.processStereoInto(leftChannels, rightChannels, outLeft, outRight);
   }
   /**
-   * Snaps every in-flight parameter ramp (engine-level smoothed params, mixer
-   * lane fader/pan/gate, bus gains) to its target value. Offline renders call
-   * this after a priming process() block so the first audible block renders at
-   * settled values instead of ramping in from defaults.
+   * Create reusable WASM-heap input/output views for realtime-style processing.
+   *
+   * Fill `leftInputs[i]` / `rightInputs[i]`, call `process()`, then read
+   * `outLeft` / `outRight`. The views are owned by this mixer and become invalid
+   * after {@link delete}.
    */
-  settleParameters() {
-    this.native.settleParameters();
-  }
-  seekPpq(ppq, renderFrame = -1) {
-    this.native.seekPpq(ppq, renderFrame);
-  }
-  setTempo(bpm) {
-    this.native.setTempo(bpm);
-  }
-  setTempoSegments(segments) {
-    this.native.setTempoSegments([...segments]);
-  }
-  setTimeSignature(numerator, denominator) {
-    this.native.setTimeSignature(numerator, denominator);
-  }
-  setTimeSignatureSegments(segments) {
-    this.native.setTimeSignatureSegments([...segments]);
-  }
-  sampleAtPpq(ppq) {
-    return Number(this.native.sampleAtPpq(ppq));
-  }
-  setLoop(startPpq, endPpq, enabled = true) {
-    this.native.setLoop(startPpq, endPpq, enabled);
-  }
-  addParameter(info) {
-    this.native.addParameter(info);
-  }
-  parameterCount() {
-    return this.native.parameterCount();
-  }
-  parameterInfoByIndex(index) {
-    return this.native.parameterInfoByIndex(index);
-  }
-  parameterInfo(id) {
-    return this.native.parameterInfo(id);
-  }
-  setAutomationLane(paramId, points) {
-    this.native.setAutomationLane(paramId, points);
-  }
-  automationLaneCount() {
-    return this.native.automationLaneCount();
-  }
-  setMarkers(markers) {
-    this.native.setMarkers(markers);
-  }
-  markerCount() {
-    return this.native.markerCount();
-  }
-  markerByIndex(index) {
-    return this.native.markerByIndex(index);
+  createRealtimeBuffer() {
+    const stripCount = this.stripCount();
+    let leftInputs = [];
+    let rightInputs = [];
+    let outLeft = this.mixer.outputLeftView();
+    let outRight = this.mixer.outputRightView();
+    const acquire = () => {
+      leftInputs = [];
+      rightInputs = [];
+      for (let index = 0; index < stripCount; index++) {
+        leftInputs.push(this.mixer.inputLeftView(index));
+        rightInputs.push(this.mixer.inputRightView(index));
+      }
+      outLeft = this.mixer.outputLeftView();
+      outRight = this.mixer.outputRightView();
+    };
+    acquire();
+    const reacquireIfDetached = () => {
+      if (outLeft.byteLength === 0 || (leftInputs[0]?.byteLength ?? 1) === 0) {
+        acquire();
+      }
+    };
+    return {
+      get leftInputs() {
+        reacquireIfDetached();
+        return leftInputs;
+      },
+      get rightInputs() {
+        reacquireIfDetached();
+        return rightInputs;
+      },
+      get outLeft() {
+        reacquireIfDetached();
+        return outLeft;
+      },
+      get outRight() {
+        reacquireIfDetached();
+        return outRight;
+      },
+      process: (numSamples = outLeft.length) => {
+        reacquireIfDetached();
+        this.mixer.processPreparedStereo(numSamples);
+      }
+    };
   }
-  marker(id) {
-    return this.native.marker(id);
+  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
+  stripCount() {
+    return this.mixer.stripCount();
   }
-  seekMarker(markerId, renderFrame = -1) {
-    this.native.seekMarker(markerId, renderFrame);
+  /**
+   * Schedule sample-accurate insert-parameter automation on a strip's insert.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param insertIndex - Index into the strip's combined insert sequence
+   *   (`[pre-inserts... post-inserts...]`)
+   * @param paramId - Processor-specific parameter id
+   * @param samplePos - Absolute samples from the start of processing (the mixer
+   *   advances an internal position from 0 on the first {@link processStereo}
+   *   call; recompiling resets it to 0)
+   * @param value - Target parameter value
+   * @param curve - Interpolation curve (default: `'linear'`)
+   * @throws If the strip index is out of range or the schedule call fails
+   *   (unknown curve, out-of-range insert index, or full event lane)
+   */
+  scheduleInsertAutomation(stripIndex, insertIndex, paramId, samplePos, value, curve = "linear") {
+    this.mixer.scheduleInsertAutomation(
+      stripIndex,
+      insertIndex,
+      paramId,
+      samplePos,
+      value,
+      automationCurveCode(curve)
+    );
   }
-  setLoopFromMarkers(startMarkerId, endMarkerId) {
-    this.native.setLoopFromMarkers(startMarkerId, endMarkerId);
+  /**
+   * Resolve a strip's index in `[0, stripCount())` from its scene id, or `null`
+   * when no strip with that id exists (matches the Node binding's `number | null`).
+   */
+  stripById(id) {
+    const index = this.mixer.stripById(id);
+    return index < 0 ? null : index;
   }
-  setMetronome(config) {
-    this.native.setMetronome(config);
+  /**
+   * Add a bus to the mixer topology. `role` is one of `'master'`, `'aux'`, or
+   * `'submix'` (defaults to `'aux'`). Marks the routing graph dirty; call
+   * {@link compile} (or {@link processStereo}) to rebuild.
+   */
+  addBus(id, role = "aux") {
+    this.mixer.addBus(id, role);
   }
-  metronome() {
-    return this.native.metronome();
+  /** Remove a bus by id. Marks the routing graph dirty. */
+  removeBus(id) {
+    this.mixer.removeBus(id);
   }
-  countInEndSample(startSample, bars) {
-    return Number(this.native.countInEndSample(startSample, bars));
+  /** Number of buses in the mixer topology. */
+  busCount() {
+    return this.mixer.busCount();
   }
-  setGraph(spec) {
-    this.native.setGraph(spec);
+  /**
+   * Add a VCA group with the given gain offset (dB). `members` is a list of
+   * strip ids governed by the group (may be empty).
+   */
+  addVcaGroup(id, gainDb = 0, members = []) {
+    this.mixer.addVcaGroup(id, gainDb, members);
   }
-  graphNodeCount() {
-    return this.native.graphNodeCount();
+  /** Set an existing VCA group's gain in dB. */
+  setVcaGroupGainDb(id, gainDb) {
+    this.mixer.setVcaGroupGainDb(id, gainDb);
   }
-  graphConnectionCount() {
-    return this.native.graphConnectionCount();
+  /** Remove a VCA group by id. */
+  removeVcaGroup(id) {
+    this.mixer.removeVcaGroup(id);
   }
-  setClips(clips) {
-    this.native.setClips(
-      clips.map((clip) => ({
-        ...clip,
-        pageProvider: typeof clip.pageProvider === "object" && clip.pageProvider !== null ? clip.pageProvider.id : clip.pageProvider
-      }))
-    );
+  /** Number of VCA groups in the mixer topology. */
+  vcaGroupCount() {
+    return this.mixer.vcaGroupCount();
   }
-  clipCount() {
-    return this.native.clipCount();
+  /** Set the strip's input trim in dB. */
+  setInputTrimDb(stripIndex, db) {
+    this.mixer.setInputTrimDb(stripIndex, db);
   }
-  setTrackLanes(lanes) {
-    this.native.setTrackLanes(
-      lanes.map((lane) => {
-        if (typeof lane === "number") {
-          return { trackId: lane };
-        }
-        if (!lane.sends) {
-          return lane;
-        }
-        return {
-          ...lane,
-          sends: lane.sends.map((send) => ({
-            ...send,
-            // Post-fader (0) is the default for an omitted sendTiming.
-            sendTiming: send.sendTiming === void 0 ? 0 : sendTimingCode(send.sendTiming)
-          }))
-        };
-      })
-    );
+  /** Set the strip's fader level in dB. */
+  setFaderDb(stripIndex, db) {
+    this.mixer.setFaderDb(stripIndex, db);
   }
   /**
-   * Keys one insert of a lane strip from another lane's post-strip audio
-   * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+   * Set the strip's pan position.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param pan - Pan position in `[-1, 1]`
+   * @param panMode - Optional pan mode. When omitted the strip's current pan
+   *   mode is kept (passes `SONARE_PAN_MODE_KEEP`), so a plain pan nudge does
+   *   not reset a scene-defined `'stereoPan'` / `'dualPan'` mode back to
+   *   balance. Pass `'balance'` (or `0`) explicitly to force balance mode.
    */
-  setLaneSidechain(trackId, insertIndex, sourceTrackId) {
-    this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+  setPan(stripIndex, pan, panMode) {
+    const mode = panMode === void 0 ? -1 : panModeCode(panMode);
+    this.mixer.setPan(stripIndex, pan, mode);
   }
-  setTrackBuses(buses) {
-    this.native.setTrackBuses(buses);
+  /** Set the strip's stereo width. */
+  setWidth(stripIndex, width) {
+    this.mixer.setWidth(stripIndex, width);
   }
-  setBusStripJson(busId, sceneJson) {
-    try {
-      JSON.parse(sceneJson);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "invalid bus strip JSON";
-      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
-    }
-    this.native.setBusStripJson(busId, sceneJson);
+  /** Set the strip's mute state. */
+  setMuted(stripIndex, muted) {
+    this.mixer.setMuted(stripIndex, muted);
   }
-  setTrackStripJson(trackId, sceneJson) {
-    try {
-      JSON.parse(sceneJson);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "invalid track strip JSON";
-      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
-    }
-    this.native.setTrackStripJson(trackId, sceneJson);
+  /**
+   * Set a strip's solo state. Takes effect on the next process without a
+   * graph recompile.
+   */
+  setSoloed(stripIndex, soloed) {
+    this.mixer.setSoloed(stripIndex, soloed);
   }
-  setTrackStripEqBand(trackId, bandIndex, band) {
-    this.native.setTrackStripEqBandJson(
-      trackId,
-      bandIndex,
-      typeof band === "string" ? band : JSON.stringify(band)
-    );
+  /**
+   * Mark a strip solo-safe so it is never implied-muted by another strip's
+   * solo. Takes effect on the next process without a graph recompile.
+   */
+  setSoloSafe(stripIndex, soloSafe) {
+    this.mixer.setSoloSafe(stripIndex, soloSafe);
   }
-  setTrackStripEqBandJson(trackId, bandIndex, bandJson) {
-    this.native.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+  /** Invert the polarity of the left and/or right channel of a strip. */
+  setPolarityInvert(stripIndex, invertLeft, invertRight) {
+    this.mixer.setPolarityInvert(stripIndex, invertLeft, invertRight);
   }
-  setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass = false) {
-    this.native.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
+  /** Set the strip's pan law. */
+  setPanLaw(stripIndex, panLaw) {
+    this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
   }
-  setMasterStripJson(sceneJson) {
-    try {
-      JSON.parse(sceneJson);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "invalid master strip JSON";
-      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
-    }
-    this.native.setMasterStripJson(sceneJson);
+  /**
+   * Set a per-strip channel delay in samples. This changes the strip's reported
+   * latency; recompile to re-run latency compensation.
+   */
+  setChannelDelaySamples(stripIndex, delaySamples) {
+    this.mixer.setChannelDelaySamples(stripIndex, delaySamples);
   }
-  setMasterStripEqBand(bandIndex, band) {
-    this.native.setMasterStripEqBandJson(
-      bandIndex,
-      typeof band === "string" ? band : JSON.stringify(band)
-    );
+  /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
+  setVcaOffsetDb(stripIndex, offsetDb) {
+    this.mixer.setVcaOffsetDb(stripIndex, offsetDb);
   }
-  setMasterStripEqBandJson(bandIndex, bandJson) {
-    this.native.setMasterStripEqBandJson(bandIndex, bandJson);
+  /** Set independent left/right pan positions (dual-pan mode). */
+  setDualPan(stripIndex, leftPan, rightPan) {
+    this.mixer.setDualPan(stripIndex, leftPan, rightPan);
   }
-  setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass = false) {
-    this.native.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+  /**
+   * Set the strip's surround pan position, used when it feeds a >2-channel bus.
+   * Stored on the scene; inert until the surround DSP path applies it.
+   */
+  setSurroundPan(stripIndex, pan) {
+    this.mixer.setSurroundPan(stripIndex, pan);
   }
   /**
-   * Changes one track-strip insert parameter in realtime, addressed by the
-   * processor's JSON-key parameter name (see {@link masteringInsertParamInfo}).
-   * Applied at the next block head via the engine command queue; safe during
-   * playback. Throws if the track, insert, or name is unknown, the param is not
-   * realtime-safe, or the command queue is full.
+   * Add a send to a strip after construction.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param id - Send id
+   * @param destinationBusId - Destination bus id
+   * @param sendDb - Initial send level in dB
+   * @param timing - `'preFader'` or `'postFader'` (default: `'postFader'`)
+   * @returns The new send's index
    */
-  setTrackStripInsertParamByName(trackId, insertIndex, paramName, value) {
-    this.native.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+  addSend(stripIndex, id, destinationBusId, sendDb = 0, timing = "postFader") {
+    return this.mixer.addSend(stripIndex, id, destinationBusId, sendDb, sendTimingCode(timing));
   }
-  /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
-  setMasterStripInsertParamByName(insertIndex, paramName, value) {
-    this.native.setMasterStripInsertParamByName(insertIndex, paramName, value);
+  /** Set the send level (in dB) for an existing send by index. */
+  setSendDb(stripIndex, sendIndex, sendDb) {
+    this.mixer.setSendDb(stripIndex, sendIndex, sendDb);
   }
-  /** Bus-strip counterpart of {@link setTrackStripInsertParamByName}. */
-  setBusStripInsertParamByName(busId, insertIndex, paramName, value) {
-    this.native.setBusStripInsertParamByName(busId, insertIndex, paramName, value);
+  /**
+   * Remove an existing send from a strip by index.
+   *
+   * Sends are addressed in add order. After removal, sends with a higher index
+   * than `sendIndex` shift down by one. Recompile (or process) before reading
+   * results so the routing graph rebuilds.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param sendIndex - Send index in add order
+   */
+  removeSend(stripIndex, sendIndex) {
+    this.mixer.removeSend(stripIndex, sendIndex);
   }
-  /** Bus-strip counterpart of {@link setTrackStripInsertBypassed}. */
-  setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass = false) {
-    this.native.setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass);
+  /**
+   * Read a strip's meter snapshot at the given tap point.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+   */
+  meterTap(stripIndex, tap = "postFader") {
+    return this.mixer.meterTap(stripIndex, meterTapCode(tap));
   }
   /**
-   * Resolves a track-lane insert parameter (by its JSON-key name) to the
-   * reserved automation id usable with `setAutomationLane` / `setParameter`.
-   * Returns `-1` when the track, insert, or name is unknown. (The Python binding
-   * raises a `SonareError` for an unknown id where Node/WASM return the `-1`
-   * sentinel.)
+   * Read a strip's meter snapshot.
+   *
+   * With no `tap` argument this reads the strip's own (post-fader) meter,
+   * matching the Node/Python tap-less `stripMeter` contract. Pass an optional
+   * `tap` (`'preFader'` / `'postFader'`) to read the tap-selectable snapshot
+   * instead — the same backing call as {@link meterTap}.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param tap - Optional tap point (`'preFader'` / `'postFader'`); when omitted
+   *   the tap-less post-fader strip meter is read.
    */
-  resolveTrackInsertAutomationId(trackId, insertIndex, paramName) {
-    return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
+  stripMeter(stripIndex, tap) {
+    if (tap === void 0) {
+      return this.mixer.stripMeter(stripIndex);
+    }
+    return this.mixer.meterTap(stripIndex, meterTapCode(tap));
   }
-  resolveMasterInsertAutomationId(insertIndex, paramName) {
-    return this.native.resolveMasterInsertAutomationId(insertIndex, paramName);
+  /**
+   * Schedule sample-accurate fader automation on a strip.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param samplePos - Absolute samples from the start of processing
+   * @param faderDb - Target fader level in dB
+   * @param curve - Interpolation curve (default: `'linear'`)
+   */
+  scheduleFaderAutomation(stripIndex, samplePos, faderDb, curve = "linear") {
+    this.mixer.scheduleFaderAutomation(stripIndex, samplePos, faderDb, automationCurveCode(curve));
   }
-  resolveBusInsertAutomationId(busId, insertIndex, paramName) {
-    return this.native.resolveBusInsertAutomationId(busId, insertIndex, paramName);
+  /**
+   * Schedule sample-accurate pan automation on a strip.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param samplePos - Absolute samples from the start of processing
+   * @param pan - Target pan position
+   * @param curve - Interpolation curve (default: `'linear'`)
+   */
+  schedulePanAutomation(stripIndex, samplePos, pan, curve = "linear") {
+    this.mixer.schedulePanAutomation(stripIndex, samplePos, pan, automationCurveCode(curve));
   }
-  /** Sets a track lane strip's pan position in realtime (glitch-free). */
-  setTrackStripPan(trackId, pan) {
-    this.native.setTrackStripPan(trackId, pan);
+  /**
+   * Schedule sample-accurate width automation on a strip.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param samplePos - Absolute samples from the start of processing
+   * @param width - Target stereo width
+   * @param curve - Interpolation curve (default: `'linear'`)
+   */
+  scheduleWidthAutomation(stripIndex, samplePos, width, curve = "linear") {
+    this.mixer.scheduleWidthAutomation(stripIndex, samplePos, width, automationCurveCode(curve));
   }
-  /** Sets a track lane strip's pan law in realtime. */
-  setTrackStripPanLaw(trackId, panLaw) {
-    this.native.setTrackStripPanLaw(trackId, panLawCode(panLaw));
+  /**
+   * Schedule sample-accurate send-level automation on a strip's send.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param sendIndex - Send index in the strip's add order
+   * @param samplePos - Absolute samples from the start of processing
+   * @param db - Target send level in dB
+   * @param curve - Interpolation curve (default: `'linear'`)
+   */
+  scheduleSendAutomation(stripIndex, sendIndex, samplePos, db, curve = "linear") {
+    this.mixer.scheduleSendAutomation(
+      stripIndex,
+      sendIndex,
+      samplePos,
+      db,
+      automationCurveCode(curve)
+    );
   }
-  /** Sets a track lane strip's pan mode in realtime. */
-  setTrackStripPanMode(trackId, panMode) {
-    this.native.setTrackStripPanMode(trackId, panModeCode(panMode));
+  /**
+   * Read up to `maxPoints` of a strip's most recent goniometer samples
+   * (oldest to newest).
+   */
+  readGoniometerLatest(stripIndex, maxPoints) {
+    return this.mixer.readGoniometerLatest(stripIndex, maxPoints);
   }
-  /** Sets a track lane strip's dual-pan left/right positions in realtime. */
-  setTrackStripDualPan(trackId, leftPan, rightPan) {
-    this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
+  /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
+  toSceneJson() {
+    return this.mixer.toSceneJson();
   }
   /**
-   * Sets a track lane strip's inter-channel alignment delay (whole samples).
-   * Adjusts strip latency, so PDC and reported graph latency are refreshed.
+   * Longest audible serial processor-tail path to the master, in samples. Lazily
+   * compiles the routing graph if the topology is dirty.
    */
-  setTrackStripChannelDelaySamples(trackId, delaySamples) {
-    this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
-  }
-  createClipPageProvider(numChannels, numSamples, pageFrames) {
-    const id = this.native.createClipPageProvider(numChannels, numSamples, pageFrames);
-    return new ClipPageProvider(this, id);
+  tailSamples() {
+    return this.mixer.tailSamples();
   }
-  supplyClipPage(providerId, pageIndex, channels) {
-    this.native.supplyClipPage(providerId, pageIndex, channels);
+  /**
+   * Reported latency (samples) of the compiled mixer graph, for aligning
+   * dry/wet material. Lazily compiles the routing graph if the topology is dirty.
+   */
+  latencySamples() {
+    return this.mixer.latencySamples();
   }
-  clearClipPage(providerId, pageIndex) {
-    this.native.clearClipPage(providerId, pageIndex);
+  /**
+   * Drain delayed / tail audio by processing a zero-input block of `numSamples`
+   * frames after the host stops feeding strip inputs. Returns the mixed stereo
+   * master (`left`, `right`, `sampleRate`).
+   */
+  drainTailStereo(numSamples) {
+    if (!Number.isSafeInteger(numSamples) || numSamples <= 0 || numSamples > this.blockSize) {
+      throw new RangeError(
+        `Mixer.drainTailStereo: numSamples must be an integer in [1, ${this.blockSize}]`
+      );
+    }
+    return this.mixer.drainTailStereo(numSamples);
   }
-  destroyClipPageProvider(providerId) {
-    this.native.destroyClipPageProvider(providerId);
+  /** Release the underlying WASM object. Safe to call only once. */
+  delete() {
+    this.mixer.delete();
   }
-  popClipPageRequest() {
-    return this.native.popClipPageRequest();
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
   }
-  setCaptureBuffer(numChannels, capacityFrames) {
-    this.native.setCaptureBuffer(numChannels, capacityFrames);
+};
+
+// src/realtime_voice_changer.ts
+var RealtimeVoiceChanger = class {
+  constructor(config = "neutral-monitor") {
+    const module2 = getSonareModule();
+    this.changer = module2.createRealtimeVoiceChanger(config);
   }
-  armCapture(armed = true) {
-    this.native.armCapture(armed);
+  prepare(sampleRate, maxBlockSize = 128, channels = 1) {
+    this.changer.prepare(sampleRate, maxBlockSize, channels);
   }
-  setCapturePunch(startSample, endSample, enabled = true) {
-    this.native.setCapturePunch(startSample, endSample, enabled);
+  reset() {
+    this.changer.reset();
   }
-  setCaptureSource(source) {
-    this.native.setCaptureSource(source);
+  setConfig(config) {
+    this.changer.setConfig(config);
   }
-  setRecordOffsetSamples(offsetSamples) {
-    this.native.setRecordOffsetSamples(offsetSamples);
+  configJson() {
+    return this.changer.configJson();
   }
-  setInputMonitor(enabled, gain = 1) {
-    this.native.setInputMonitor(enabled, gain);
+  latencySamples() {
+    return this.changer.latencySamples();
   }
-  resetCapture() {
-    this.native.resetCapture();
+  processMono(samples) {
+    return this.changer.processMono(samples);
   }
-  captureStatus() {
-    return this.native.captureStatus();
+  processMonoInto(samples, output) {
+    this.changer.processMonoInto(samples, output);
   }
-  capturedAudio() {
-    return this.native.capturedAudio();
+  processInterleaved(samples, channels) {
+    return this.changer.processInterleaved(samples, channels);
   }
-  process(channels) {
-    return this.native.process(channels);
+  processInterleavedInto(samples, channels, output) {
+    this.changer.processInterleavedInto(samples, channels, output);
   }
   /**
-   * Allocates persistent per-channel WASM-heap scratch for the zero-copy
-   * `getChannelBuffer` / `processPrepared` realtime path. Call once (off the
-   * audio thread) before driving `processPrepared` from an AudioWorklet so the
-   * render callback never allocates on the C++/JS heap.
+   * Acquire a typed-memory view onto the WASM heap for mono input.
+   *
+   * Write your input samples into the returned `Float32Array` directly (e.g.
+   * via `input.set(source)`); no copy crosses the JS↔C++ bridge until
+   * {@link processPreparedMono} is called. The view is owned by this
+   * RealtimeVoiceChanger and becomes invalid after {@link delete}; it may
+   * also be invalidated if you later call this method with a larger
+   * `numSamples` value (the underlying buffer may be reallocated).
    */
-  prepareChannels(numChannels, maxFrames) {
-    this.native.prepareChannels(numChannels, maxFrames);
+  getMonoInputBuffer(numSamples) {
+    return this.changer.getMonoInputBuffer(numSamples);
   }
-  /**
-   * Returns a Float32Array view onto the persistent WASM-heap scratch for one
-   * channel (valid for up to `numFrames`). Fill it, call `processPrepared`, then
-   * read the same view back. Re-acquire after WASM memory growth.
-   */
-  getChannelBuffer(channel, numFrames) {
-    return this.native.getChannelBuffer(channel, numFrames);
+  /** Mono output view counterpart to {@link getMonoInputBuffer}. */
+  getMonoOutputBuffer(numSamples) {
+    return this.changer.getMonoOutputBuffer(numSamples);
   }
   /**
-   * Runs the engine in place over the prepared per-channel scratch buffers.
-   * Allocation-free: safe to call on the AudioWorklet render thread after
-   * `prepareChannels`.
+   * Process the previously-acquired mono input buffer in place. The output
+   * appears in the buffer returned by {@link getMonoOutputBuffer}. No JS↔C++
+   * sample-level crossings happen on this call — it just hands control to
+   * the underlying DSP on already-on-heap data.
    */
-  processPrepared(numFrames) {
-    this.native.processPrepared(numFrames);
-  }
-  processWithMonitor(channels) {
-    return this.native.processWithMonitor(channels);
-  }
-  renderOffline(channels, blockSize = 128) {
-    return this.native.renderOffline(channels, blockSize);
-  }
-  bounceOffline(options) {
-    return this.native.bounceOffline(options);
-  }
-  freezeOffline(options) {
-    return this.native.freezeOffline(options);
+  processPreparedMono(numSamples) {
+    this.changer.processPreparedMono(numSamples);
   }
-  drainTelemetry(maxRecords = 1024) {
-    return this.native.drainTelemetry(maxRecords);
+  /** Interleaved input view (layout L0,R0,L1,R1,...). */
+  getInterleavedInputBuffer(numFrames, numChannels) {
+    return this.changer.getInterleavedInputBuffer(numFrames, numChannels);
   }
-  drainMeterTelemetry(maxRecords = 1024) {
-    return this.native.drainMeterTelemetry(maxRecords);
+  /** Interleaved output view counterpart. */
+  getInterleavedOutputBuffer(numFrames, numChannels) {
+    return this.changer.getInterleavedOutputBuffer(numFrames, numChannels);
   }
   /**
-   * Drains pending meter telemetry as per-plane (wide) records for a surround
-   * target. Use this for a surround mix target; {@link drainMeterTelemetry}
-   * stays the stereo fast path. The two share one queue — call only one per
-   * target. The live AudioWorklet path owns the queue via the stereo drain, so
-   * this wide drain is for an offline (non-worklet) engine instance; per-plane
-   * surround meters are not delivered over the live worklet meter ring.
+   * Process the previously-acquired interleaved buffer in place. Output
+   * appears in the buffer returned by {@link getInterleavedOutputBuffer}.
    */
-  drainMeterTelemetryWide(maxRecords = 1024) {
-    return this.native.drainMeterTelemetryWide(maxRecords);
+  processPreparedInterleaved(numFrames, numChannels) {
+    this.changer.processPreparedInterleaved(numFrames, numChannels);
   }
   /**
-   * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
-   * the minimum render-frame gap between snapshots (0 disables). @param bandCount
-   * is the FFT band resolution (1..64); changing it re-prepares the tap. Returns
-   * the band count actually applied.
+   * Planar-channel input/output view (one Float32Array per channel). Matches
+   * AudioWorklet's native layout; processing happens in place.
    */
-  configureScopeTelemetry(intervalFrames, bandCount) {
-    return this.native.configureScopeTelemetry(intervalFrames, bandCount);
-  }
-  /** Drains pending spectrum + vectorscope snapshots (per mix target). */
-  drainScopeTelemetry(maxRecords = 1024) {
-    return this.native.drainScopeTelemetry(maxRecords);
+  getPlanarChannelBuffer(channel, numFrames) {
+    return this.changer.getPlanarChannelBuffer(channel, numFrames);
   }
-  destroy() {
-    this.native.delete();
+  /**
+   * Process the previously-acquired planar channel buffers in place. Each
+   * channel must have been obtained from {@link getPlanarChannelBuffer}
+   * with the same `numFrames`. Output replaces input in the same buffers.
+   */
+  processPreparedPlanar(numFrames) {
+    this.changer.processPreparedPlanar(numFrames);
   }
-};
-var ClipPageProvider = class {
-  constructor(engine, id) {
-    this.engine = engine;
-    this.id = id;
-    this.disposed = false;
+  /**
+   * Convenience factory for the mono zero-copy path: returns the input/output
+   * heap views plus a `process()` thunk wired to the same `numSamples`. The
+   * views are reused across calls and become invalid after {@link delete}.
+   */
+  createRealtimeMonoBuffer(numSamples) {
+    let input = this.getMonoInputBuffer(numSamples);
+    let output = this.getMonoOutputBuffer(numSamples);
+    const reacquireIfDetached = () => {
+      if (input.byteLength === 0 || output.byteLength === 0) {
+        input = this.getMonoInputBuffer(numSamples);
+        output = this.getMonoOutputBuffer(numSamples);
+      }
+    };
+    return {
+      get input() {
+        reacquireIfDetached();
+        return input;
+      },
+      get output() {
+        reacquireIfDetached();
+        return output;
+      },
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedMono(numSamples);
+      }
+    };
   }
-  supply(pageIndex, channels) {
-    if (this.disposed) {
-      throw new Error("ClipPageProvider is destroyed");
-    }
-    this.engine.supplyClipPage(this.id, pageIndex, channels);
+  /** Same as {@link createRealtimeMonoBuffer} but for interleaved I/O. */
+  createRealtimeInterleavedBuffer(numFrames, numChannels) {
+    let input = this.getInterleavedInputBuffer(numFrames, numChannels);
+    let output = this.getInterleavedOutputBuffer(numFrames, numChannels);
+    const reacquireIfDetached = () => {
+      if (input.byteLength === 0 || output.byteLength === 0) {
+        input = this.getInterleavedInputBuffer(numFrames, numChannels);
+        output = this.getInterleavedOutputBuffer(numFrames, numChannels);
+      }
+    };
+    return {
+      get input() {
+        reacquireIfDetached();
+        return input;
+      },
+      get output() {
+        reacquireIfDetached();
+        return output;
+      },
+      channels: numChannels,
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedInterleaved(numFrames, numChannels);
+      }
+    };
   }
-  clear(pageIndex) {
-    if (this.disposed) {
-      return;
-    }
-    this.engine.clearClipPage(this.id, pageIndex);
+  /**
+   * Convenience factory for the planar zero-copy path. Acquires one
+   * heap-backed Float32Array per channel and returns a `process()` thunk
+   * wired to the same `numFrames`. Buffers are reused across calls and
+   * become invalid after {@link delete}.
+   */
+  createRealtimePlanarBuffer(numFrames, numChannels) {
+    let channels = [];
+    const acquire = () => {
+      channels = [];
+      for (let ch = 0; ch < numChannels; ch++) {
+        channels.push(this.getPlanarChannelBuffer(ch, numFrames));
+      }
+    };
+    acquire();
+    const reacquireIfDetached = () => {
+      if ((channels[0]?.byteLength ?? 0) === 0) {
+        acquire();
+      }
+    };
+    return {
+      get channels() {
+        reacquireIfDetached();
+        return channels;
+      },
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedPlanar(numFrames);
+      }
+    };
   }
-  destroy() {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    this.engine.destroyClipPageProvider(this.id);
+  delete() {
+    this.changer.delete();
   }
 };
 
@@ -2128,6 +2141,8 @@ async function resetCapture(ctx) {
 }
 
 // src/worklet/engine-clips.ts
+var PREBAKED_CLIP_PAGE_THRESHOLD = 16384;
+var PREBAKED_CLIP_PAGE_FRAMES = 4096;
 function addClip(ctx, trackId, buffer, startPpq, opts = {}) {
   const id = opts.id ?? ctx.allocateClipId();
   const clip = {
@@ -2157,9 +2172,56 @@ function setMidiClips(ctx, clips) {
 function syncClipsDelta(ctx, upserts, removeIds) {
   const clips = Array.from(ctx.clips.values());
   ctx.offlineEngine.setClips(clips);
+  const preparedById = /* @__PURE__ */ new Map();
+  for (const clip of clips) {
+    if (clip.id === void 0) {
+      continue;
+    }
+    const bakedChannels = ctx.offlineEngine.prebakedClipChannels(clip.id);
+    preparedById.set(
+      clip.id,
+      bakedChannels === null ? clip : {
+        ...clip,
+        channels: bakedChannels,
+        clipOffsetSamples: 0,
+        lengthSamples: bakedChannels[0]?.length ?? 0,
+        loop: false,
+        warpMode: "off",
+        warpAnchors: void 0
+      }
+    );
+  }
+  const inlineUpserts = [];
+  for (const clip of upserts) {
+    const prepared = clip.id === void 0 ? clip : preparedById.get(clip.id) ?? clip;
+    const channels = prepared.channels;
+    if (prepared.id === void 0 || prepared.warpMode !== "off" || !channels || channels.length === 0 || channels[0].length <= PREBAKED_CLIP_PAGE_THRESHOLD) {
+      inlineUpserts.push(prepared);
+      continue;
+    }
+    const numSamples = channels[0].length;
+    ctx.postSync({
+      type: "syncClipPageProvider",
+      clipId: prepared.id,
+      clip: { ...prepared, channels: void 0, pageProvider: void 0 },
+      numChannels: channels.length,
+      numSamples,
+      pageFrames: PREBAKED_CLIP_PAGE_FRAMES
+    });
+    for (let start = 0, pageIndex = 0; start < numSamples; start += PREBAKED_CLIP_PAGE_FRAMES, pageIndex++) {
+      const page = channels.map(
+        (channel) => channel.slice(start, start + PREBAKED_CLIP_PAGE_FRAMES)
+      );
+      ctx.postSync(
+        { type: "syncClipPage", clipId: prepared.id, pageIndex, channels: page },
+        page.map((channel) => channel.buffer)
+      );
+    }
+    ctx.postSync({ type: "syncClipPageCommit", clipId: prepared.id });
+  }
   ctx.postSync({
     type: "syncClipsDelta",
-    upserts,
+    upserts: inlineUpserts,
     removeIds
   });
 }
@@ -2336,7 +2398,7 @@ function isEngineSyncMessage(value) {
   if (!isRecord(value) || typeof value.type !== "string") {
     return false;
   }
-  return value.type === "syncClips" || value.type === "syncClipsDelta" || value.type === "syncMidiClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation" || value.type === "syncTempo" || value.type === "syncMixer" || value.type === "syncCapture" || value.type === "syncTrackStripEqBand" || value.type === "syncMasterStripEqBand" || value.type === "syncTrackStripInsertBypassed" || value.type === "syncMasterStripInsertBypassed" || value.type === "syncTrackStripInsertParamByName" || value.type === "syncMasterStripInsertParamByName" || value.type === "syncBusStripInsertParamByName" || value.type === "syncTrackStripPan" || value.type === "syncTrackStripPanLaw" || value.type === "syncTrackStripPanMode" || value.type === "syncTrackStripDualPan" || value.type === "syncTrackStripChannelDelaySamples" || value.type === "syncBuiltinInstrument" || value.type === "syncSynthInstrument" || value.type === "syncSf2Instrument" || value.type === "syncLoadSoundFont" || value.type === "syncMidiFx" || value.type === "syncClearMidiFx" || value.type === "syncMidiNoteOn" || value.type === "syncMidiNoteOff" || value.type === "syncMidiCc" || value.type === "syncMidiSysex" || value.type === "syncMidiPanic" || value.type === "syncMidiDestinationExternal" || value.type === "syncExternalMidiClock";
+  return value.type === "syncClips" || value.type === "syncClipsDelta" || value.type === "syncClipPageProvider" || value.type === "syncClipPage" || value.type === "syncClipPageCommit" || value.type === "syncMidiClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation" || value.type === "syncTempo" || value.type === "syncMixer" || value.type === "syncCapture" || value.type === "syncTrackStripEqBand" || value.type === "syncMasterStripEqBand" || value.type === "syncTrackStripInsertBypassed" || value.type === "syncMasterStripInsertBypassed" || value.type === "syncTrackStripInsertParamByName" || value.type === "syncMasterStripInsertParamByName" || value.type === "syncBusStripInsertParamByName" || value.type === "syncTrackStripPan" || value.type === "syncTrackStripPanLaw" || value.type === "syncTrackStripPanMode" || value.type === "syncTrackStripDualPan" || value.type === "syncTrackStripChannelDelaySamples" || value.type === "syncBuiltinInstrument" || value.type === "syncSynthInstrument" || value.type === "syncSf2Instrument" || value.type === "syncLoadSoundFont" || value.type === "syncMidiFx" || value.type === "syncClearMidiFx" || value.type === "syncMidiNoteOn" || value.type === "syncMidiNoteOff" || value.type === "syncMidiCc" || value.type === "syncMidiSysex" || value.type === "syncMidiPanic" || value.type === "syncMidiDestinationExternal" || value.type === "syncExternalMidiClock";
 }
 function isEngineCaptureRequestMessage(value) {
   return isRecord(value) && value.type === "captureRequest" && typeof value.requestId === "number" && (value.op === "status" || value.op === "read" || value.op === "reset");
@@ -3502,11 +3564,15 @@ var SonareEngine = class _SonareEngine {
   // Posts an out-of-band control-sync message to the worklet engine processor.
   // Sync messages use a string `type` so the worklet's message handler routes
   // them to receiveSync() (numeric `type` is reserved for SonareEngineCommandRecord).
-  postSync(message) {
+  postSync(message, transfer) {
     if (this.destroyed) {
       return;
     }
-    this.realtimeNode.node.port.postMessage(message);
+    if (transfer && transfer.length > 0) {
+      this.realtimeNode.node.port.postMessage(message, transfer);
+    } else {
+      this.realtimeNode.node.port.postMessage(message);
+    }
   }
   // Collaborator surface handed to the mixer/routing free functions so they can
   // mutate the routing stores (held by reference), mirror into the offline
@@ -3624,7 +3690,7 @@ var SonareEngine = class _SonareEngine {
       clips: this.clips,
       midiClips: this.midiClips,
       allocateClipId: () => this.nextClipId++,
-      postSync: (message) => this.postSync(message),
+      postSync: (message, transfer) => this.postSync(message, transfer),
       ensureTrackLane: (target) => this.ensureTrackLane(target),
       resolveTargetId: (target) => this.resolveTargetId(target)
     };
@@ -3721,6 +3787,8 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     // SetMetronome command only toggles enabled state; the config arrives here.
     this.metronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
     this.liveClips = /* @__PURE__ */ new Map();
+    this.pagedClipProviders = /* @__PURE__ */ new Map();
+    this.pendingPagedClips = /* @__PURE__ */ new Map();
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
     this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
@@ -3818,11 +3886,10 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       this.applyCommand(command);
     }
   }
-  // Applies an out-of-band control-plane sync message. Runs on the AudioWorklet
-  // global scope but OUTSIDE process() (the message-port callback), so the
-  // bulk/allocating engine setters (setClips/setMarkers) are safe here — they
-  // never run on the realtime render path. This is the audio-thread equivalent
-  // of the engine's control-thread RtPublisher setters.
+  // Applies an out-of-band control-plane sync message on the AudioWorklet
+  // thread. These handlers must remain bounded: expensive clip transforms are
+  // performed on the main-thread mirror, and long pre-baked PCM arrives in
+  // small pages before the final lightweight clip schedule is committed.
   receiveSync(message) {
     if (this.closed) {
       return;
@@ -3848,6 +3915,33 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         }
         this.engine.setClips(Array.from(this.liveClips.values()));
         break;
+      case "syncClipPageProvider": {
+        const provider = this.engine.createClipPageProvider(
+          message.numChannels,
+          message.numSamples,
+          message.pageFrames
+        );
+        this.pagedClipProviders.set(message.clipId, provider.id);
+        this.pendingPagedClips.set(message.clipId, message.clip);
+        break;
+      }
+      case "syncClipPage": {
+        const providerId = this.pagedClipProviders.get(message.clipId);
+        if (providerId !== void 0) {
+          this.engine.supplyClipPage(providerId, message.pageIndex, message.channels);
+        }
+        break;
+      }
+      case "syncClipPageCommit": {
+        const providerId = this.pagedClipProviders.get(message.clipId);
+        const clip = this.pendingPagedClips.get(message.clipId);
+        if (providerId !== void 0 && clip) {
+          this.liveClips.set(message.clipId, { ...clip, pageProvider: providerId });
+          this.pendingPagedClips.delete(message.clipId);
+          this.engine.setClips(Array.from(this.liveClips.values()));
+        }
+        break;
+      }
       case "syncMidiClips":
         this.engine.setMidiClips(message.clips);
         break;