@libraz/libsonare 1.2.2 → 1.3.0

package/dist/worklet.js

@@ -1,5 +1,16 @@
-// src/index.ts
-var EXPECTED_ENGINE_ABI_VERSION = 2;
+// src/module_state.ts
+var wasmModule = null;
+function setSonareModule(module2) {
+  wasmModule = module2;
+}
+function getSonareModule() {
+  if (!wasmModule) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return wasmModule;
+}
+
+// src/codes.ts
 function automationCurveCode(curve) {
   switch (curve) {
     case "linear":
@@ -50,213 +61,396 @@ function meterTapCode(tap) {
 function sendTimingCode(timing) {
   return timing === "preFader" || timing === 0 ? 0 : 1;
 }
-var module = null;
-var initPromise = null;
-async function init(options) {
-  if (module) {
-    return;
+
+// src/mixer.ts
+var Mixer = class _Mixer {
+  constructor(mixer) {
+    this.mixer = mixer;
   }
-  if (initPromise) {
-    return initPromise;
+  /**
+   * 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) {
+    const module2 = getSonareModule();
+    return new _Mixer(module2.createMixerFromSceneJson(json, sampleRate, blockSize));
   }
-  initPromise = (async () => {
-    try {
-      const createModule = (await import("./sonare.js")).default;
-      module = await createModule(options);
-    } catch (error) {
-      initPromise = null;
-      throw error;
+  /** Rebuild and compile the routing graph from the current scene topology. */
+  compile() {
+    this.mixer.compile();
+  }
+  /**
+   * 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 initPromise;
-}
-function isInitialized() {
-  return module !== null;
-}
-function engineAbiVersion() {
-  if (!module) {
-    throw new Error("Module not initialized. Call init() first.");
+    return this.mixer.processStereo(leftChannels, rightChannels);
   }
-  return module.engineAbiVersion();
-}
-function engineCapabilities() {
-  const abiVersion = 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) {
-    if (!module) {
-      throw new Error("Module not initialized. Call init() first.");
+  /**
+   * 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.
+   */
+  processStereoInto(leftChannels, rightChannels, outLeft, outRight) {
+    if (leftChannels.length !== rightChannels.length) {
+      throw new Error("leftChannels and rightChannels must have the same length.");
     }
-    const capabilities = engineCapabilities();
-    if (!capabilities.abiCompatible) {
-      throw new Error(
-        `Engine ABI mismatch: wasm=${capabilities.engineAbiVersion}, expected=${capabilities.expectedEngineAbiVersion}`
-      );
+    if (outLeft.length !== outRight.length) {
+      throw new Error("outLeft and outRight must have the same length.");
     }
-    this.native = new module.RealtimeEngine(
-      sampleRate,
-      maxBlockSize,
-      commandCapacity,
-      telemetryCapacity
-    );
-  }
-  prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024) {
-    this.native.prepare(sampleRate, maxBlockSize, commandCapacity, telemetryCapacity);
-  }
-  /** Queue a sample-accurate parameter change (engine kSetParam). */
-  setParameter(paramId, value, renderFrame = -1) {
-    this.native.setParameter(paramId, value, renderFrame);
+    this.mixer.processStereoInto(leftChannels, rightChannels, outLeft, outRight);
   }
-  /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
-  setParameterSmoothed(paramId, value, renderFrame = -1) {
-    this.native.setParameterSmoothed(paramId, value, renderFrame);
+  /**
+   * 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);
+      }
+    };
   }
-  /** Read back the current transport state snapshot. */
-  getTransportState() {
-    return this.native.getTransportState();
+  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
+  stripCount() {
+    return this.mixer.stripCount();
   }
-  play(renderFrame = -1) {
-    this.native.play(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)
+    );
   }
-  stop(renderFrame = -1) {
-    this.native.stop(renderFrame);
+  /**
+   * 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;
   }
-  seekSample(timelineSample, renderFrame = -1) {
-    this.native.seekSample(timelineSample, renderFrame);
+  /**
+   * 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);
   }
-  seekPpq(ppq, renderFrame = -1) {
-    this.native.seekPpq(ppq, renderFrame);
+  /** Remove a bus by id. Marks the routing graph dirty. */
+  removeBus(id) {
+    this.mixer.removeBus(id);
   }
-  setTempo(bpm) {
-    this.native.setTempo(bpm);
+  /** Number of buses in the mixer topology. */
+  busCount() {
+    return this.mixer.busCount();
   }
-  setTimeSignature(numerator, denominator) {
-    this.native.setTimeSignature(numerator, denominator);
+  /**
+   * 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);
   }
-  setLoop(startPpq, endPpq, enabled = true) {
-    this.native.setLoop(startPpq, endPpq, enabled);
+  /** Set an existing VCA group's gain in dB. */
+  setVcaGroupGainDb(id, gainDb) {
+    this.mixer.setVcaGroupGainDb(id, gainDb);
   }
-  addParameter(info) {
-    this.native.addParameter(info);
+  /** Remove a VCA group by id. */
+  removeVcaGroup(id) {
+    this.mixer.removeVcaGroup(id);
   }
-  parameterCount() {
-    return this.native.parameterCount();
+  /** Number of VCA groups in the mixer topology. */
+  vcaGroupCount() {
+    return this.mixer.vcaGroupCount();
   }
-  parameterInfoByIndex(index) {
-    return this.native.parameterInfoByIndex(index);
+  /** Set the strip's input trim in dB. */
+  setInputTrimDb(stripIndex, db) {
+    this.mixer.setInputTrimDb(stripIndex, db);
   }
-  parameterInfo(id) {
-    return this.native.parameterInfo(id);
+  /** Set the strip's fader level in dB. */
+  setFaderDb(stripIndex, db) {
+    this.mixer.setFaderDb(stripIndex, db);
   }
-  setAutomationLane(paramId, points) {
-    this.native.setAutomationLane(paramId, points);
+  /**
+   * 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);
   }
-  automationLaneCount() {
-    return this.native.automationLaneCount();
+  /** Set the strip's stereo width. */
+  setWidth(stripIndex, width) {
+    this.mixer.setWidth(stripIndex, width);
   }
-  setMarkers(markers) {
-    this.native.setMarkers(markers);
+  /** Set the strip's mute state. */
+  setMuted(stripIndex, muted) {
+    this.mixer.setMuted(stripIndex, muted);
   }
-  markerCount() {
-    return this.native.markerCount();
+  /**
+   * Set a strip's solo state. Takes effect on the next process without a
+   * graph recompile.
+   */
+  setSoloed(stripIndex, soloed) {
+    this.mixer.setSoloed(stripIndex, soloed);
   }
-  markerByIndex(index) {
-    return this.native.markerByIndex(index);
+  /**
+   * 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);
   }
-  marker(id) {
-    return this.native.marker(id);
+  /** Invert the polarity of the left and/or right channel of a strip. */
+  setPolarityInvert(stripIndex, invertLeft, invertRight) {
+    this.mixer.setPolarityInvert(stripIndex, invertLeft, invertRight);
   }
-  seekMarker(markerId, renderFrame = -1) {
-    this.native.seekMarker(markerId, renderFrame);
+  /** Set the strip's pan law. */
+  setPanLaw(stripIndex, panLaw) {
+    this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
   }
-  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();
+  /**
+   * 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);
   }
-  graphConnectionCount() {
-    return this.native.graphConnectionCount();
+  /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
+  setVcaOffsetDb(stripIndex, offsetDb) {
+    this.mixer.setVcaOffsetDb(stripIndex, offsetDb);
   }
-  setClips(clips) {
-    this.native.setClips(clips);
+  /** Set independent left/right pan positions (dual-pan mode). */
+  setDualPan(stripIndex, leftPan, rightPan) {
+    this.mixer.setDualPan(stripIndex, leftPan, rightPan);
   }
-  clipCount() {
-    return this.native.clipCount();
+  /**
+   * 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));
   }
-  setCaptureBuffer(numChannels, capacityFrames) {
-    this.native.setCaptureBuffer(numChannels, capacityFrames);
+  /** Set the send level (in dB) for an existing send by index. */
+  setSendDb(stripIndex, sendIndex, sendDb) {
+    this.mixer.setSendDb(stripIndex, sendIndex, sendDb);
   }
-  armCapture(armed = true) {
-    this.native.armCapture(armed);
+  /**
+   * 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);
   }
-  setCapturePunch(startSample, endSample, enabled = true) {
-    this.native.setCapturePunch(startSample, endSample, enabled);
+  /**
+   * 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));
   }
-  resetCapture() {
-    this.native.resetCapture();
+  /**
+   * 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.
+   */
+  stripMeter(stripIndex, tap) {
+    if (tap === void 0) {
+      return this.mixer.stripMeter(stripIndex);
+    }
+    return this.mixer.meterTap(stripIndex, meterTapCode(tap));
   }
-  captureStatus() {
-    return this.native.captureStatus();
+  /**
+   * 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));
   }
-  capturedAudio() {
-    return this.native.capturedAudio();
+  /**
+   * 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));
   }
-  process(channels) {
-    return this.native.process(channels);
+  /**
+   * 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));
   }
-  processWithMonitor(channels) {
-    return this.native.processWithMonitor(channels);
+  /**
+   * 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)
+    );
   }
-  renderOffline(channels, blockSize = 128) {
-    return this.native.renderOffline(channels, blockSize);
+  /**
+   * Read up to `maxPoints` of a strip's most recent goniometer samples
+   * (oldest to newest).
+   */
+  readGoniometerLatest(stripIndex, maxPoints) {
+    return this.mixer.readGoniometerLatest(stripIndex, maxPoints);
   }
-  bounceOffline(options) {
-    return this.native.bounceOffline(options);
+  /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
+  toSceneJson() {
+    return this.mixer.toSceneJson();
   }
-  freezeOffline(options) {
-    return this.native.freezeOffline(options);
+  /**
+   * Maximum processor tail length (samples) in the compiled mixer graph. Lazily
+   * compiles the routing graph if the topology is dirty.
+   */
+  tailSamples() {
+    return this.mixer.tailSamples();
   }
-  drainTelemetry(maxRecords = 1024) {
-    return this.native.drainTelemetry(maxRecords);
+  /**
+   * 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);
   }
-  drainMeterTelemetry(maxRecords = 1024) {
-    return this.native.drainMeterTelemetry(maxRecords);
+  /** Release the underlying WASM object. Safe to call only once. */
+  delete() {
+    this.mixer.delete();
   }
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
   destroy() {
-    this.native.delete();
+    this.delete();
   }
 };
+
+// src/realtime_voice_changer.ts
 var RealtimeVoiceChanger = class {
   constructor(config = "neutral-monitor") {
-    if (!module) {
-      throw new Error("Module not initialized. Call init() first.");
-    }
-    this.changer = module.createRealtimeVoiceChanger(config);
+    const module2 = getSonareModule();
+    this.changer = module2.createRealtimeVoiceChanger(config);
   }
   prepare(sampleRate, maxBlockSize = 128, channels = 1) {
     this.changer.prepare(sampleRate, maxBlockSize, channels);
@@ -347,23 +541,53 @@ var RealtimeVoiceChanger = class {
    * views are reused across calls and become invalid after {@link delete}.
    */
   createRealtimeMonoBuffer(numSamples) {
-    const input = this.getMonoInputBuffer(numSamples);
-    const output = this.getMonoOutputBuffer(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 {
-      input,
-      output,
-      process: () => this.processPreparedMono(numSamples)
+      get input() {
+        reacquireIfDetached();
+        return input;
+      },
+      get output() {
+        reacquireIfDetached();
+        return output;
+      },
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedMono(numSamples);
+      }
     };
   }
   /** Same as {@link createRealtimeMonoBuffer} but for interleaved I/O. */
   createRealtimeInterleavedBuffer(numFrames, numChannels) {
-    const input = this.getInterleavedInputBuffer(numFrames, numChannels);
-    const output = this.getInterleavedOutputBuffer(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 {
-      input,
-      output,
+      get input() {
+        reacquireIfDetached();
+        return input;
+      },
+      get output() {
+        reacquireIfDetached();
+        return output;
+      },
       channels: numChannels,
-      process: () => this.processPreparedInterleaved(numFrames, numChannels)
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedInterleaved(numFrames, numChannels);
+      }
     };
   }
   /**
@@ -373,331 +597,451 @@ var RealtimeVoiceChanger = class {
    * become invalid after {@link delete}.
    */
   createRealtimePlanarBuffer(numFrames, numChannels) {
-    const channels = [];
-    for (let ch = 0; ch < numChannels; ch++) {
-      channels.push(this.getPlanarChannelBuffer(ch, numFrames));
-    }
+    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 {
-      channels,
-      process: () => this.processPreparedPlanar(numFrames)
+      get channels() {
+        reacquireIfDetached();
+        return channels;
+      },
+      process: () => {
+        reacquireIfDetached();
+        this.processPreparedPlanar(numFrames);
+      }
     };
   }
   delete() {
     this.changer.delete();
   }
 };
-var Mixer = class _Mixer {
-  constructor(mixer) {
-    this.mixer = mixer;
+
+// 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 {
+  nativeExt() {
+    return this.native;
   }
-  /**
-   * 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) {
-    if (!module) {
-      throw new Error("Module not initialized. Call init() first.");
+  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}`
+      );
     }
-    return new _Mixer(module.createMixerFromSceneJson(json, sampleRate, blockSize));
+    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);
+  }
+  /** Queue a sample-accurate parameter change (engine kSetParam). */
+  setParameter(paramId, value, renderFrame = -1) {
+    this.native.setParameter(paramId, value, renderFrame);
+  }
+  /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
+  setParameterSmoothed(paramId, value, renderFrame = -1) {
+    this.native.setParameterSmoothed(paramId, value, renderFrame);
+  }
+  setBuiltinInstrument(config = {}, destinationId = config.destinationId ?? 0) {
+    this.nativeExt().setBuiltinInstrument(destinationId, config);
   }
   /**
-   * 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`)
+   * 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.
    */
-  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);
+  setSynthInstrument(patch = {}, destinationId = (typeof patch === "object" ? patch.destinationId : void 0) ?? 0) {
+    this.nativeExt().setSynthInstrument(destinationId, patch);
   }
   /**
-   * 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.
+   * 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.
    */
-  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);
+  loadSoundFont(data) {
+    this.nativeExt().loadSoundFont(data);
   }
   /**
-   * 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}.
+   * 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).
    */
-  createRealtimeBuffer() {
-    const stripCount = this.stripCount();
-    const leftInputs = [];
-    const rightInputs = [];
-    for (let index = 0; index < stripCount; index++) {
-      leftInputs.push(this.mixer.inputLeftView(index));
-      rightInputs.push(this.mixer.inputRightView(index));
-    }
-    const outLeft = this.mixer.outputLeftView();
-    const outRight = this.mixer.outputRightView();
-    return {
-      leftInputs,
-      rightInputs,
-      outLeft,
-      outRight,
-      process: (numSamples = outLeft.length) => this.mixer.processPreparedStereo(numSamples)
-    };
+  setSf2Instrument(config = {}, destinationId = config.destinationId ?? 0) {
+    this.nativeExt().setSf2Instrument(destinationId, config);
   }
-  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
-  stripCount() {
-    return this.mixer.stripCount();
+  clearMidiInstrument(destinationId = 0) {
+    this.nativeExt().clearMidiInstrument(destinationId);
+  }
+  midiInstrumentCount() {
+    return this.nativeExt().midiInstrumentCount();
   }
   /**
-   * 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 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`.
    */
-  scheduleInsertAutomation(stripIndex, insertIndex, paramId, samplePos, value, curve = "linear") {
-    this.mixer.scheduleInsertAutomation(
-      stripIndex,
-      insertIndex,
+  bindMidiCc(channel, controller, paramId, options = {}) {
+    this.nativeExt().bindMidiCc(
+      channel,
+      controller,
       paramId,
-      samplePos,
-      value,
-      automationCurveCode(curve)
+      options.minValue ?? 0,
+      options.maxValue ?? 1
     );
   }
-  /**
-   * 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;
+  clearMidiCcBindings() {
+    this.nativeExt().clearMidiCcBindings();
   }
-  /**
-   * 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);
+  midiCcBindingCount() {
+    return this.nativeExt().midiCcBindingCount();
   }
-  /** Remove a bus by id. Marks the routing graph dirty. */
-  removeBus(id) {
-    this.mixer.removeBus(id);
+  /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
+  setMidiFx(destinationId, configJson) {
+    this.nativeExt().setMidiFx(destinationId, configJson);
   }
-  /** Number of buses in the mixer topology. */
-  busCount() {
-    return this.mixer.busCount();
+  clearMidiFx(destinationId = 0) {
+    this.nativeExt().clearMidiFx(destinationId);
   }
-  /**
-   * 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);
+  /** Enable the engine-owned live MIDI input source for a destination. */
+  setMidiInputSource(destinationId = 0) {
+    this.nativeExt().setMidiInputSource(destinationId);
   }
-  /** Remove a VCA group by id. */
-  removeVcaGroup(id) {
-    this.mixer.removeVcaGroup(id);
+  clearMidiInputSource() {
+    this.nativeExt().clearMidiInputSource();
   }
-  /** Number of VCA groups in the mixer topology. */
-  vcaGroupCount() {
-    return this.mixer.vcaGroupCount();
+  midiInputPendingCount() {
+    return this.nativeExt().midiInputPendingCount();
   }
-  /** Set the strip's input trim in dB. */
-  setInputTrimDb(stripIndex, db) {
-    this.mixer.setInputTrimDb(stripIndex, db);
+  pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples = 0) {
+    this.nativeExt().pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
   }
-  /** Set the strip's fader level in dB. */
-  setFaderDb(stripIndex, db) {
-    this.mixer.setFaderDb(stripIndex, db);
+  pushMidiInputNoteOff(group, channel, note, velocity = 0, portTimeSamples = 0) {
+    this.nativeExt().pushMidiInputNoteOff(group, channel, note, velocity, portTimeSamples);
   }
-  /** Set the strip's pan position. */
-  setPan(stripIndex, pan, panMode = 0) {
-    this.mixer.setPan(stripIndex, pan, panModeCode(panMode));
+  pushMidiInputCc(group, channel, controller, value, portTimeSamples = 0) {
+    this.nativeExt().pushMidiInputCc(group, channel, controller, value, portTimeSamples);
   }
-  /** Set the strip's stereo width. */
-  setWidth(stripIndex, width) {
-    this.mixer.setWidth(stripIndex, width);
+  pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame = -1) {
+    this.nativeExt().pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
   }
-  /** Set the strip's mute state. */
-  setMuted(stripIndex, muted) {
-    this.mixer.setMuted(stripIndex, muted);
+  pushMidiNoteOff(destinationId, group, channel, note, velocity = 0, renderFrame = -1) {
+    this.nativeExt().pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
   }
   /**
-   * Set a strip's solo state. Takes effect on the next process without a
-   * graph recompile.
+   * 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`.
    */
-  setSoloed(stripIndex, soloed) {
-    this.mixer.setSoloed(stripIndex, soloed);
+  pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
+    this.nativeExt().pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
   /**
-   * 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.
+   * Queue a MIDI panic (all-notes-off) releasing every sounding note at
+   * `renderFrame` (-1 = immediate). Mirrors the C-ABI `pushMidiPanic`.
    */
-  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);
-  }
-  /** Set the strip's pan law. */
-  setPanLaw(stripIndex, panLaw) {
-    this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
+  pushMidiPanic(renderFrame = -1) {
+    this.nativeExt().pushMidiPanic(renderFrame);
   }
   /**
-   * Set a per-strip channel delay in samples. This changes the strip's reported
-   * latency; recompile to re-run latency compensation.
+   * Remove all registered parameters (and their automation lanes). Control-thread
+   * only; not realtime-safe. Mirrors the C-ABI `clearParameters`.
    */
-  setChannelDelaySamples(stripIndex, delaySamples) {
-    this.mixer.setChannelDelaySamples(stripIndex, delaySamples);
+  clearParameters() {
+    this.nativeExt().clearParameters();
   }
-  /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
-  setVcaOffsetDb(stripIndex, offsetDb) {
-    this.mixer.setVcaOffsetDb(stripIndex, offsetDb);
+  /** Read back the current transport state snapshot. */
+  getTransportState() {
+    return this.native.getTransportState();
   }
-  /** Set independent left/right pan positions (dual-pan mode). */
-  setDualPan(stripIndex, leftPan, rightPan) {
-    this.mixer.setDualPan(stripIndex, leftPan, rightPan);
+  play(renderFrame = -1) {
+    this.native.play(renderFrame);
   }
-  /**
-   * 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, timing = "postFader") {
-    return this.mixer.addSend(stripIndex, id, destinationBusId, sendDb, sendTimingCode(timing));
+  stop(renderFrame = -1) {
+    this.native.stop(renderFrame);
+  }
+  seekSample(timelineSample, renderFrame = -1) {
+    this.native.seekSample(timelineSample, renderFrame);
+  }
+  seekPpq(ppq, renderFrame = -1) {
+    this.native.seekPpq(ppq, renderFrame);
+  }
+  setTempo(bpm) {
+    this.native.setTempo(bpm);
+  }
+  setTimeSignature(numerator, denominator) {
+    this.native.setTimeSignature(numerator, denominator);
+  }
+  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);
+  }
+  marker(id) {
+    return this.native.marker(id);
+  }
+  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
+      }))
+    );
+  }
+  clipCount() {
+    return this.native.clipCount();
+  }
+  createClipPageProvider(numChannels, numSamples, pageFrames) {
+    const id = this.nativeExt().createClipPageProvider(numChannels, numSamples, pageFrames);
+    return new ClipPageProvider(this, id);
+  }
+  supplyClipPage(providerId, pageIndex, channels) {
+    this.nativeExt().supplyClipPage(providerId, pageIndex, channels);
+  }
+  clearClipPage(providerId, pageIndex) {
+    this.nativeExt().clearClipPage(providerId, pageIndex);
+  }
+  destroyClipPageProvider(providerId) {
+    this.nativeExt().destroyClipPageProvider(providerId);
+  }
+  popClipPageRequest() {
+    return this.nativeExt().popClipPageRequest();
+  }
+  setCaptureBuffer(numChannels, capacityFrames) {
+    this.native.setCaptureBuffer(numChannels, capacityFrames);
+  }
+  armCapture(armed = true) {
+    this.native.armCapture(armed);
+  }
+  setCapturePunch(startSample, endSample, enabled = true) {
+    this.native.setCapturePunch(startSample, endSample, enabled);
+  }
+  setCaptureSource(source) {
+    this.native.setCaptureSource(source);
+  }
+  setRecordOffsetSamples(offsetSamples) {
+    this.native.setRecordOffsetSamples(offsetSamples);
+  }
+  setInputMonitor(enabled, gain = 1) {
+    this.native.setInputMonitor(enabled, gain);
+  }
+  resetCapture() {
+    this.native.resetCapture();
+  }
+  captureStatus() {
+    return this.native.captureStatus();
   }
-  /** Set the send level (in dB) for an existing send by index. */
-  setSendDb(stripIndex, sendIndex, sendDb) {
-    this.mixer.setSendDb(stripIndex, sendIndex, sendDb);
+  capturedAudio() {
+    return this.native.capturedAudio();
   }
-  /**
-   * 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));
+  process(channels) {
+    return this.native.process(channels);
   }
   /**
-   * Read a strip's meter snapshot. Alias of {@link meterTap}, provided for
-   * cross-binding (Node/Python) parity.
-   *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+   * 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.
    */
-  stripMeter(stripIndex, tap = "postFader") {
-    return this.mixer.stripMeter(stripIndex, meterTapCode(tap));
+  prepareChannels(numChannels, maxFrames) {
+    this.native.prepareChannels(numChannels, maxFrames);
   }
   /**
-   * 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'`)
+   * 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.
    */
-  scheduleFaderAutomation(stripIndex, samplePos, faderDb, curve = "linear") {
-    this.mixer.scheduleFaderAutomation(stripIndex, samplePos, faderDb, automationCurveCode(curve));
+  getChannelBuffer(channel, numFrames) {
+    return this.native.getChannelBuffer(channel, numFrames);
   }
   /**
-   * 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'`)
+   * Runs the engine in place over the prepared per-channel scratch buffers.
+   * Allocation-free: safe to call on the AudioWorklet render thread after
+   * `prepareChannels`.
    */
-  schedulePanAutomation(stripIndex, samplePos, pan, curve = "linear") {
-    this.mixer.schedulePanAutomation(stripIndex, samplePos, pan, automationCurveCode(curve));
+  processPrepared(numFrames) {
+    this.native.processPrepared(numFrames);
   }
-  /**
-   * 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));
+  processWithMonitor(channels) {
+    return this.native.processWithMonitor(channels);
   }
-  /**
-   * 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)
-    );
+  renderOffline(channels, blockSize = 128) {
+    return this.native.renderOffline(channels, blockSize);
   }
-  /**
-   * Read up to `maxPoints` of a strip's most recent goniometer samples
-   * (oldest to newest).
-   */
-  readGoniometerLatest(stripIndex, maxPoints) {
-    return this.mixer.readGoniometerLatest(stripIndex, maxPoints);
+  bounceOffline(options) {
+    return this.native.bounceOffline(options);
   }
-  /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
-  toSceneJson() {
-    return this.mixer.toSceneJson();
+  freezeOffline(options) {
+    return this.native.freezeOffline(options);
   }
-  /** Release the underlying WASM object. Safe to call only once. */
-  delete() {
-    this.mixer.delete();
+  drainTelemetry(maxRecords = 1024) {
+    return this.native.drainTelemetry(maxRecords);
+  }
+  drainMeterTelemetry(maxRecords = 1024) {
+    return this.native.drainMeterTelemetry(maxRecords);
   }
-  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
   destroy() {
-    this.delete();
+    this.native.delete();
+  }
+};
+var ClipPageProvider = class {
+  constructor(engine, id) {
+    this.engine = engine;
+    this.id = id;
+    this.disposed = false;
+  }
+  supply(pageIndex, channels) {
+    if (this.disposed) {
+      throw new Error("ClipPageProvider is destroyed");
+    }
+    this.engine.supplyClipPage(this.id, pageIndex, channels);
+  }
+  clear(pageIndex) {
+    if (this.disposed) {
+      return;
+    }
+    this.engine.clearClipPage(this.id, pageIndex);
+  }
+  destroy() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.engine.destroyClipPageProvider(this.id);
   }
 };
 
+// src/index.ts
+var module = null;
+var initPromise = null;
+async function init(options) {
+  if (module) {
+    return;
+  }
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    try {
+      const createModule = (await import("./sonare.js")).default;
+      module = await createModule(options);
+      setSonareModule(module);
+    } catch (error) {
+      initPromise = null;
+      throw error;
+    }
+  })();
+  return initPromise;
+}
+function isInitialized() {
+  return module !== null;
+}
+
 // src/worklet.ts
 var SONARE_METER_RING_HEADER_INTS = 4;
-var SONARE_METER_RING_RECORD_FLOATS = 6;
+var SONARE_METER_RING_RECORD_FLOATS = 7;
 var SONARE_SPECTRUM_RING_HEADER_INTS = 5;
+var SONARE_FRAME_LANE_BASE = 16777216;
+function encodeFrameLo(frame) {
+  const f = Math.max(0, Math.floor(frame));
+  return f % SONARE_FRAME_LANE_BASE;
+}
+function encodeFrameHi(frame) {
+  const f = Math.max(0, Math.floor(frame));
+  return Math.floor(f / SONARE_FRAME_LANE_BASE);
+}
+function decodeFrame(lo, hi) {
+  return hi * SONARE_FRAME_LANE_BASE + lo;
+}
 var SONARE_ENGINE_RING_HEADER_INTS = 5;
 var SONARE_ENGINE_COMMAND_RECORD_BYTES = 32;
 var SONARE_ENGINE_TELEMETRY_RECORD_BYTES = 48;
@@ -744,6 +1088,18 @@ var SonareEngineTelemetryError = /* @__PURE__ */ ((SonareEngineTelemetryError2)
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["SmoothedParameterCapacity"] = 13] = "SmoothedParameterCapacity";
   return SonareEngineTelemetryError2;
 })(SonareEngineTelemetryError || {});
+var DEFAULT_METRONOME_CONFIG = {
+  beatGain: 0.35,
+  accentGain: 0.7,
+  clickSamples: 96
+};
+function resolveMetronomeConfig(config) {
+  return {
+    beatGain: config.beatGain ?? DEFAULT_METRONOME_CONFIG.beatGain,
+    accentGain: config.accentGain ?? DEFAULT_METRONOME_CONFIG.accentGain,
+    clickSamples: config.clickSamples ?? DEFAULT_METRONOME_CONFIG.clickSamples
+  };
+}
 function toDb(value) {
   return value > 0 ? 20 * Math.log10(value) : Number.NEGATIVE_INFINITY;
 }
@@ -759,6 +1115,12 @@ function isWorkletMessage(value) {
 function isEngineCommandRecord(value) {
   return isRecord(value) && typeof value.type === "number";
 }
+function isEngineSyncMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  return value.type === "syncClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation";
+}
 function isRealtimeVoiceChangerMessage(value) {
   if (!isRecord(value) || typeof value.type !== "string") {
     return false;
@@ -794,7 +1156,7 @@ function readSonareMeterRingBuffer(ring, readIndex = 0) {
     const offset = index % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
     meters.push({
       type: "meter",
-      frame: ring.records[offset],
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 6]),
       peakDbL: ring.records[offset + 1],
       peakDbR: ring.records[offset + 2],
       rmsDbL: ring.records[offset + 3],
@@ -807,7 +1169,7 @@ function readSonareMeterRingBuffer(ring, readIndex = 0) {
 function sonareSpectrumRingBufferByteLength(capacity, bands = 16) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   const clampedBands = Math.max(1, Math.floor(bands));
-  return SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * (2 + clampedBands) * Float32Array.BYTES_PER_ELEMENT;
+  return SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * (3 + clampedBands) * Float32Array.BYTES_PER_ELEMENT;
 }
 function createSonareSpectrumRingBuffer(capacity = 128, bands = 16) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
@@ -831,7 +1193,7 @@ function createSonareSpectrumRingBuffer(capacity = 128, bands = 16) {
 }
 function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
   const writeIndex = Atomics.load(ring.header, 0);
-  const recordFloats = Atomics.load(ring.header, 2) || 2 + ring.bands;
+  const recordFloats = Atomics.load(ring.header, 2) || 3 + ring.bands;
   const bands = Atomics.load(ring.header, 3) || ring.bands;
   const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
   const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
@@ -839,8 +1201,12 @@ function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
   for (let index = firstReadable; index < writeIndex; index++) {
     const offset = index % ring.capacity * recordFloats;
     const values = new Float32Array(bands);
-    values.set(ring.records.subarray(offset + 2, offset + 2 + bands));
-    spectra.push({ type: "spectrum", frame: ring.records[offset], bands: values });
+    values.set(ring.records.subarray(offset + 3, offset + 3 + bands));
+    spectra.push({
+      type: "spectrum",
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 1]),
+      bands: values
+    });
   }
   return { nextReadIndex: writeIndex, spectra };
 }
@@ -959,7 +1325,7 @@ function spectrumRingFromSharedBuffer(sharedBuffer, fallbackCapacity, fallbackBa
   const existingBands = Atomics.load(header, 3);
   const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
   const bands = Math.max(1, Math.floor(existingBands || fallbackBands || 16));
-  const recordFloats = 2 + bands;
+  const recordFloats = 3 + bands;
   const minBytes = sonareSpectrumRingBufferByteLength(capacity, bands);
   if (sharedBuffer.byteLength < minBytes) {
     throw new Error("spectrumSharedBuffer is too small for the requested ring capacity.");
@@ -1008,8 +1374,7 @@ function writeEngineCommandRecord(view, offset, command) {
   view.setUint32(offset, command.type, true);
   view.setUint32(offset + 4, command.targetId ?? 0, true);
   view.setBigInt64(offset + 8, toBigInt64(command.sampleTime, -1n), true);
-  view.setFloat32(offset + 16, command.argFloat ?? 0, true);
-  view.setUint32(offset + 20, 0, true);
+  view.setFloat64(offset + 16, command.argFloat ?? 0, true);
   view.setBigInt64(offset + 24, toBigInt64(command.argInt, 0n), true);
 }
 function readEngineCommandRecord(view, offset) {
@@ -1017,7 +1382,7 @@ function readEngineCommandRecord(view, offset) {
     type: view.getUint32(offset, true),
     targetId: view.getUint32(offset + 4, true),
     sampleTime: Number(view.getBigInt64(offset + 8, true)),
-    argFloat: view.getFloat32(offset + 16, true),
+    argFloat: view.getFloat64(offset + 16, true),
     argInt: Number(view.getBigInt64(offset + 24, true))
   };
 }
@@ -1110,35 +1475,48 @@ var SonareWorkletProcessor = class {
       return true;
     }
     const frames = leftOut.length;
-    if (frames !== this.blockSize) {
-      return false;
-    }
+    const usable = Math.min(frames, this.blockSize);
     for (let strip = 0; strip < this.realtime.leftInputs.length; strip++) {
       const input = inputs[strip];
       const left = input?.[0];
       const right = input?.[1];
       const leftTarget = this.realtime.leftInputs[strip];
       const rightTarget = this.realtime.rightInputs[strip];
-      if (left && left.length === frames) {
-        leftTarget.set(left);
-        if (right && right.length === frames) {
-          rightTarget.set(right);
+      if (left && left.length >= usable) {
+        leftTarget.set(left.subarray(0, usable));
+        if (right && right.length >= usable) {
+          rightTarget.set(right.subarray(0, usable));
         } else {
-          rightTarget.set(left);
+          rightTarget.set(left.subarray(0, usable));
         }
       } else {
         leftTarget.fill(0);
         rightTarget.fill(0);
       }
     }
-    this.realtime.process(frames);
-    leftOut.set(this.realtime.outLeft);
-    if (rightOut) {
-      rightOut.set(this.realtime.outRight);
+    this.realtime.process(usable);
+    if (usable === frames) {
+      leftOut.set(this.realtime.outLeft.subarray(0, usable));
+      if (rightOut) {
+        rightOut.set(this.realtime.outRight.subarray(0, usable));
+      }
+    } else {
+      leftOut.fill(0);
+      leftOut.set(this.realtime.outLeft.subarray(0, usable));
+      if (rightOut) {
+        rightOut.fill(0);
+        rightOut.set(this.realtime.outRight.subarray(0, usable));
+      }
     }
-    this.processedFrames += frames;
-    this.publishMeter(this.realtime.outLeft, this.realtime.outRight);
-    this.publishSpectrum(this.realtime.outLeft, this.realtime.outRight);
+    this.processedFrames += usable;
+    this.publishMeter(
+      this.realtime.outLeft.subarray(0, usable),
+      this.realtime.outRight.subarray(0, usable)
+    );
+    this.publishSpectrum(
+      this.realtime.outLeft.subarray(0, usable),
+      this.realtime.outRight.subarray(0, usable)
+    );
     return true;
   }
   receiveMessage(message) {
@@ -1224,16 +1602,14 @@ var SonareWorkletProcessor = class {
     }
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
-    ring.records[offset] = meter.frame;
+    ring.records[offset] = encodeFrameLo(meter.frame);
     ring.records[offset + 1] = meter.peakDbL;
     ring.records[offset + 2] = meter.peakDbR;
     ring.records[offset + 3] = meter.rmsDbL;
     ring.records[offset + 4] = meter.rmsDbR;
     ring.records[offset + 5] = meter.correlation;
+    ring.records[offset + 6] = encodeFrameHi(meter.frame);
     Atomics.store(ring.header, 0, writeIndex + 1);
-    if (writeIndex + 1 > ring.capacity) {
-      Atomics.store(ring.header, 3, writeIndex + 1 - ring.capacity);
-    }
   }
   publishSpectrum(left, right) {
     if (this.spectrumIntervalFrames <= 0) {
@@ -1258,7 +1634,12 @@ var SonareWorkletProcessor = class {
   }
   computeSpectrum(left, right) {
     const n = Math.max(1, Math.min(left.length, right.length));
+    const maxBand = Math.floor(n / 2);
     for (let band = 0; band < this.spectrumBands.length; band++) {
+      if (band >= maxBand) {
+        this.spectrumBands[band] = magnitudeToDb(0);
+        continue;
+      }
       const bin = band + 1;
       let real = 0;
       let imag = 0;
@@ -1278,19 +1659,20 @@ var SonareWorkletProcessor = class {
     }
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = writeIndex % ring.capacity * ring.recordFloats;
-    ring.records[offset] = frame;
-    ring.records[offset + 1] = bands.length;
-    ring.records.set(bands.subarray(0, ring.bands), offset + 2);
+    ring.records[offset] = encodeFrameLo(frame);
+    ring.records[offset + 1] = encodeFrameHi(frame);
+    ring.records[offset + 2] = bands.length;
+    ring.records.set(bands.subarray(0, ring.bands), offset + 3);
     Atomics.store(ring.header, 0, writeIndex + 1);
-    if (writeIndex + 1 > ring.capacity) {
-      Atomics.store(ring.header, 4, writeIndex + 1 - ring.capacity);
-    }
   }
 };
 var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletProcessor {
   constructor(options = {}, transport) {
     this.closed = false;
     this.lastMeterFrame = Number.NEGATIVE_INFINITY;
+    // Latest metronome gains/click length pushed via 'syncMetronome'. The
+    // SetMetronome command only toggles enabled state; the config arrives here.
+    this.metronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
     this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
@@ -1307,12 +1689,12 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       options.telemetrySharedBuffer,
       options.telemetryRingCapacity
     ) : void 0;
+    this.meterRing = options.meterSharedBuffer ? meterRingFromSharedBuffer(options.meterSharedBuffer, options.meterRingCapacity) : void 0;
     this.engine = new RealtimeEngine(this.sampleRate, this.blockSize);
-    this.channelScratch = new Array(this.channelCount);
-    this.channelScratchViews = new Array(this.channelCount);
+    this.engine.prepareChannels(this.channelCount, this.blockSize);
+    this.channelBuffers = new Array(this.channelCount);
     for (let ch = 0; ch < this.channelCount; ch++) {
-      this.channelScratch[ch] = new Float32Array(this.blockSize);
-      this.channelScratchViews[ch] = this.channelScratch[ch];
+      this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
     }
   }
   process(inputs, outputs) {
@@ -1333,34 +1715,38 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       return true;
     }
     this.drainCommands();
-    const scratchCapacity = this.channelScratch[0]?.length ?? 0;
     let usableFrames = frames;
-    if (usableFrames > scratchCapacity) {
+    if (usableFrames > this.blockSize) {
       if (!_SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow) {
         _SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow = true;
         console.warn(
-          `SonareRealtimeEngineWorkletProcessor: requested ${usableFrames} frames exceeds pre-allocated capacity ${scratchCapacity}; clamping.`
+          `SonareRealtimeEngineWorkletProcessor: requested ${usableFrames} frames exceeds pre-allocated capacity ${this.blockSize}; clamping.`
         );
       }
-      usableFrames = scratchCapacity;
+      usableFrames = this.blockSize;
+    }
+    if ((this.channelBuffers[0]?.byteLength ?? 0) === 0) {
+      this.reacquireChannelBuffers();
     }
     const input = inputs[0];
     for (let ch = 0; ch < this.channelCount; ch++) {
-      const scratch = this.channelScratch[ch];
+      const dst = this.channelBuffers[ch];
       const source = input?.[ch];
       if (source && source.length === usableFrames) {
-        scratch.set(source, 0);
+        dst.set(source.subarray(0, usableFrames));
       } else {
-        scratch.fill(0, 0, usableFrames);
+        dst.fill(0, 0, usableFrames);
       }
-      this.channelScratchViews[ch] = scratch.subarray(0, usableFrames);
     }
-    const processed = this.engine.process(this.channelScratchViews);
+    this.engine.processPrepared(usableFrames);
     for (let ch = 0; ch < output.length; ch++) {
       const target = output[ch];
-      const source = processed[ch] ?? processed[0];
+      const source = this.channelBuffers[ch] ?? this.channelBuffers[0];
       if (source) {
-        target.set(source.subarray(0, target.length));
+        target.set(source.subarray(0, Math.min(target.length, usableFrames)));
+        if (target.length > usableFrames) {
+          target.fill(0, usableFrames);
+        }
       } else {
         target.fill(0);
       }
@@ -1369,11 +1755,41 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     this.publishMeters();
     return true;
   }
+  reacquireChannelBuffers() {
+    for (let ch = 0; ch < this.channelCount; ch++) {
+      this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
+    }
+  }
   receiveCommand(command) {
     if (!this.closed) {
       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.
+  receiveSync(message) {
+    if (this.closed) {
+      return;
+    }
+    switch (message.type) {
+      case "syncClips":
+        this.engine.setClips(message.clips);
+        break;
+      case "syncMarkers":
+        this.engine.setMarkers(message.markers);
+        break;
+      case "syncMetronome":
+        this.metronomeConfig = resolveMetronomeConfig(message.config);
+        this.engine.setMetronome(message.config);
+        break;
+      case "syncAutomation":
+        this.engine.setAutomationLane(message.paramId, message.points);
+        break;
+    }
+  }
   destroy() {
     if (!this.closed) {
       this.engine.destroy();
@@ -1395,6 +1811,20 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
   applyCommand(command) {
     const sampleTime = Number(command.sampleTime ?? -1);
     switch (command.type) {
+      case 0 /* SetParam */:
+        this.engine.setParameter(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Number(command.argFloat ?? 0),
+          sampleTime
+        );
+        break;
+      case 1 /* SetParamSmoothed */:
+        this.engine.setParameterSmoothed(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Number(command.argFloat ?? 0),
+          sampleTime
+        );
+        break;
       case 2 /* TransportPlay */:
         this.engine.play(sampleTime);
         break;
@@ -1423,18 +1853,21 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       case 14 /* Punch */:
         this.engine.setCapturePunch(
           Number(command.argInt ?? 0),
-          Math.max(0, Math.round(Number(command.argFloat ?? 0) * this.sampleRate)),
+          Math.max(0, Math.round(Number(command.argFloat ?? 0))),
           true
         );
         break;
       case 15 /* SetMetronome */:
         this.engine.setMetronome({
           enabled: Boolean(command.argInt),
-          beatGain: 0.25,
-          accentGain: 0.75,
-          clickSamples: 64
+          beatGain: this.metronomeConfig.beatGain,
+          accentGain: this.metronomeConfig.accentGain,
+          clickSamples: this.metronomeConfig.clickSamples
         });
         break;
+      case 17 /* SeekMarker */:
+        this.engine.seekMarker(Math.trunc(Number(command.targetId ?? 0)), sampleTime);
+        break;
       default:
         this.publishTelemetryRecord({
           type: 1 /* Error */,
@@ -1461,7 +1894,7 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     this.transport?.postMessage?.(record);
   }
   publishMeters() {
-    if (!this.transport || this.meterIntervalFrames <= 0) {
+    if (this.meterIntervalFrames <= 0 || !this.transport && !this.meterRing) {
       return;
     }
     for (const item of this.engine.drainMeterTelemetry(64)) {
@@ -1470,9 +1903,29 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         continue;
       }
       this.lastMeterFrame = meter.frame;
-      this.transport.onMeter?.(meter);
-      this.transport.postMessage?.(meter);
+      if (this.meterRing) {
+        this.writeMeterRing(meter);
+      } else {
+        this.transport?.onMeter?.(meter);
+        this.transport?.postMessage?.(meter);
+      }
+    }
+  }
+  writeMeterRing(meter) {
+    const ring = this.meterRing;
+    if (!ring) {
+      return;
     }
+    const writeIndex = Atomics.load(ring.header, 0);
+    const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
+    ring.records[offset] = encodeFrameLo(meter.frame);
+    ring.records[offset + 1] = meter.peakDbL;
+    ring.records[offset + 2] = meter.peakDbR;
+    ring.records[offset + 3] = meter.rmsDbL;
+    ring.records[offset + 4] = meter.rmsDbR;
+    ring.records[offset + 5] = meter.correlation;
+    ring.records[offset + 6] = encodeFrameHi(meter.frame);
+    Atomics.store(ring.header, 0, writeIndex + 1);
   }
   commandRingFromSharedBuffer(sharedBuffer, fallbackCapacity) {
     const ring = engineRingFromSharedBuffer(
@@ -1495,6 +1948,7 @@ _SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow = false;
 var SonareRealtimeEngineWorkletProcessor = _SonareRealtimeEngineWorkletProcessor;
 var SonareRtRealtimeEngineRuntime = class {
   constructor(options) {
+    this.metronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
     this.closed = false;
     this.module = options.module;
     this.memory = options.memory;
@@ -1576,6 +2030,49 @@ var SonareRtRealtimeEngineRuntime = class {
     this.publishTelemetry();
     return true;
   }
+  receiveCommand(command) {
+    if (!this.closed) {
+      this.applyCommand(command);
+    }
+  }
+  // Out-of-band control sync for the sonare-rt runtime. The sonare-rt C ABI
+  // (src/wasm/rt_bindings.cpp) exposes set_metronome_enabled and seek_marker but
+  // NOT set_clips / set_markers, so clip/marker mutations cannot be applied to a
+  // live sonare-rt engine. We honor the metronome config and surface a clear
+  // telemetry error for the unsupported clip/marker paths instead of silently
+  // dropping them. The default 'embind' runtime wires all three fully.
+  receiveSync(message) {
+    if (this.closed) {
+      return;
+    }
+    switch (message.type) {
+      case "syncMetronome":
+        this.metronomeConfig = resolveMetronomeConfig(message.config);
+        this.module._sonare_rt_engine_set_metronome_enabled(
+          this.engine,
+          message.config.enabled ? 1 : 0,
+          this.metronomeConfig.beatGain,
+          this.metronomeConfig.accentGain,
+          this.metronomeConfig.clickSamples
+        );
+        break;
+      case "syncClips":
+      case "syncMarkers":
+      case "syncAutomation":
+        if (this.telemetryRing) {
+          writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
+            type: 1 /* Error */,
+            error: 7 /* UnknownTarget */,
+            renderFrame: 0,
+            timelineSample: 0,
+            audibleTimelineSample: 0,
+            graphLatencySamplesQ8: 0,
+            value: 0
+          });
+        }
+        break;
+    }
+  }
   destroy() {
     if (this.closed) {
       return;
@@ -1611,6 +2108,20 @@ var SonareRtRealtimeEngineRuntime = class {
   applyCommand(command) {
     const sampleTime = toBigInt64(command.sampleTime, -1n);
     switch (command.type) {
+      case 0 /* SetParam */:
+      case 1 /* SetParamSmoothed */:
+        if (this.telemetryRing) {
+          writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
+            type: 1 /* Error */,
+            error: 7 /* UnknownTarget */,
+            renderFrame: 0,
+            timelineSample: 0,
+            audibleTimelineSample: 0,
+            graphLatencySamplesQ8: 0,
+            value: Number(command.type)
+          });
+        }
+        break;
       case 2 /* TransportPlay */:
         this.module._sonare_rt_engine_play(this.engine, sampleTime);
         break;
@@ -1649,7 +2160,7 @@ var SonareRtRealtimeEngineRuntime = class {
         this.module._sonare_rt_engine_set_capture_punch(
           this.engine,
           toBigInt64(command.argInt, 0n),
-          BigInt(Math.trunc(Number(command.argFloat ?? 0) * this.sampleRate)),
+          BigInt(Math.max(0, Math.round(Number(command.argFloat ?? 0)))),
           1
         );
         break;
@@ -1657,9 +2168,9 @@ var SonareRtRealtimeEngineRuntime = class {
         this.module._sonare_rt_engine_set_metronome_enabled(
           this.engine,
           command.argInt ? 1 : 0,
-          0.25,
-          0.75,
-          64
+          this.metronomeConfig.beatGain,
+          this.metronomeConfig.accentGain,
+          this.metronomeConfig.clickSamples
         );
         break;
       case 17 /* SeekMarker */:
@@ -1734,8 +2245,9 @@ var SonareRtRealtimeEngineRuntime = class {
   }
 };
 var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
-  constructor(node, capabilities, commandRing, telemetryRing) {
+  constructor(node, capabilities, commandRing, telemetryRing, meterRing) {
     this.telemetryReadIndex = 0;
+    this.meterReadIndex = 0;
     this.telemetryListeners = /* @__PURE__ */ new Set();
     this.meterListeners = /* @__PURE__ */ new Set();
     this.destroyed = false;
@@ -1743,6 +2255,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.capabilities = capabilities;
     this.commandRing = commandRing;
     this.telemetryRing = telemetryRing;
+    this.meterRing = meterRing;
     this.ready = new Promise((resolve, reject) => {
       this.resolveReady = resolve;
       this.rejectReady = reject;
@@ -1791,6 +2304,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     }
     const commandRing = mode === "sab" ? createSonareEngineCommandRingBuffer(options.commandRingCapacity ?? 128) : void 0;
     const telemetryRing = mode === "sab" ? createSonareEngineTelemetryRingBuffer(options.telemetryRingCapacity ?? 128) : void 0;
+    const meterRing = mode === "sab" && runtimeTarget === "embind" ? createSonareMeterRingBuffer(options.meterRingCapacity ?? 128) : void 0;
     const channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
     const processorOptions = {
       runtimeTarget,
@@ -1802,7 +2316,9 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       commandSharedBuffer: commandRing?.sharedBuffer,
       commandRingCapacity: commandRing?.capacity,
       telemetrySharedBuffer: telemetryRing?.sharedBuffer,
-      telemetryRingCapacity: telemetryRing?.capacity
+      telemetryRingCapacity: telemetryRing?.capacity,
+      meterSharedBuffer: meterRing?.sharedBuffer,
+      meterRingCapacity: meterRing?.capacity
     };
     const factory = options.nodeFactory ?? ((ctx, name, nodeOptions) => new AudioWorkletNode(ctx, name, nodeOptions));
     const node = factory(context, processorName, {
@@ -1825,7 +2341,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         degradedReason
       },
       commandRing,
-      telemetryRing
+      telemetryRing,
+      meterRing
     );
   }
   play(sampleTime = -1) {
@@ -1869,6 +2386,20 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     }
     return read.telemetry;
   }
+  // Drains any meters published into the SAB meter ring (embind SAB mode) and
+  // forwards them to onMeter listeners. In postMessage mode meters arrive via
+  // node.port.onmessage instead, so this is a no-op then.
+  pollMeters() {
+    if (!this.meterRing) {
+      return [];
+    }
+    const read = readSonareMeterRingBuffer(this.meterRing, this.meterReadIndex);
+    this.meterReadIndex = read.nextReadIndex;
+    for (const meter of read.meters) {
+      this.emitMeter(meter);
+    }
+    return read.meters;
+  }
   onTelemetry(callback) {
     this.telemetryListeners.add(callback);
     return () => {
@@ -1983,10 +2514,14 @@ var SonareEngine = class _SonareEngine {
     });
   }
   setParam(nodeId, param, value) {
-    void nodeId;
-    void param;
-    void value;
-    return false;
+    const paramId = this.resolveParamId(nodeId, param);
+    this.offlineEngine.setParameter(paramId, value);
+    return this.realtimeNode.sendCommand({
+      type: 0 /* SetParam */,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: value
+    });
   }
   scheduleParam(nodeId, param, ppq, value, curve = "linear") {
     const paramId = this.resolveParamId(nodeId, param);
@@ -1995,6 +2530,7 @@ var SonareEngine = class _SonareEngine {
     lane.sort((a, b) => a.ppq - b.ppq);
     this.automationLanes.set(paramId, lane);
     this.offlineEngine.setAutomationLane(paramId, lane);
+    this.postSync({ type: "syncAutomation", paramId, points: lane });
   }
   addAutomationPoint(laneId, ppq, value, curve = "linear") {
     this.scheduleParam("", laneId, ppq, value, curve);
@@ -2010,7 +2546,9 @@ var SonareEngine = class _SonareEngine {
     void target;
     void solo;
     void mute;
-    return false;
+    throw new Error(
+      "SonareEngine.setSoloMute is not supported: solo/mute is a Mixer feature; use Mixer.setSoloed(stripIndex, ...) / Mixer.setMuted(stripIndex, ...) instead."
+    );
   }
   addClip(trackId, buffer, startPpq, opts = {}) {
     const id = opts.id ?? this.nextClipId++;
@@ -2046,11 +2584,12 @@ var SonareEngine = class _SonareEngine {
       type: 14 /* Punch */,
       sampleTime: -1,
       argInt: inSample,
-      argFloat: outPpq
+      argFloat: outSample
     });
   }
   setMetronome(opts) {
     this.offlineEngine.setMetronome(opts);
+    this.postSync({ type: "syncMetronome", config: opts });
     this.realtimeNode.sendCommand({
       type: 15 /* SetMetronome */,
       sampleTime: -1,
@@ -2065,7 +2604,11 @@ var SonareEngine = class _SonareEngine {
   }
   seekMarker(markerId) {
     this.offlineEngine.seekMarker(markerId);
-    return false;
+    return this.realtimeNode.sendCommand({
+      type: 17 /* SeekMarker */,
+      targetId: markerId,
+      sampleTime: -1
+    });
   }
   async renderOffline(totalFrames) {
     const frames = Math.max(0, Math.floor(totalFrames));
@@ -2084,6 +2627,9 @@ var SonareEngine = class _SonareEngine {
   pollTelemetry() {
     return this.realtimeNode.pollTelemetry();
   }
+  pollMeters() {
+    return this.realtimeNode.pollMeters();
+  }
   destroy() {
     if (this.destroyed) {
       return;
@@ -2095,10 +2641,23 @@ var SonareEngine = class _SonareEngine {
     this.offlineEngine.destroy();
   }
   syncClips() {
-    this.offlineEngine.setClips(Array.from(this.clips.values()));
+    const clips = Array.from(this.clips.values());
+    this.offlineEngine.setClips(clips);
+    this.postSync({ type: "syncClips", clips });
   }
   syncMarkers() {
-    this.offlineEngine.setMarkers(Array.from(this.markers.values()).sort((a, b) => a.ppq - b.ppq));
+    const markers = Array.from(this.markers.values()).sort((a, b) => a.ppq - b.ppq);
+    this.offlineEngine.setMarkers(markers);
+    this.postSync({ type: "syncMarkers", markers });
+  }
+  // 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) {
+    if (this.destroyed) {
+      return;
+    }
+    this.realtimeNode.node.port.postMessage(message);
   }
   resolveParamId(nodeId, param) {
     if (typeof param === "number") {
@@ -2169,6 +2728,9 @@ var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChan
     if (this.destroyed || !output || output.length === 0) {
       return !this.destroyed;
     }
+    if (this.monoInput.byteLength === 0) {
+      this.reacquireBuffers();
+    }
     const input = inputs[0];
     const requestedFrames = output[0]?.length ?? 0;
     const requestedChannels = Math.min(this.channelCount, output.length);
@@ -2220,6 +2782,19 @@ var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChan
     this.destroyed = true;
     this.changer.delete();
   }
+  // Re-acquires the cached WASM-heap views after a memory-growth detachment.
+  // The underlying C++ vectors are pre-warmed (ensure_*_capacity ran at prepare
+  // time), so getMono*/getPlanar* return fresh views onto the SAME storage
+  // without reallocating it.
+  reacquireBuffers() {
+    this.monoInput = this.changer.getMonoInputBuffer(this.blockSize);
+    this.monoOutput = this.changer.getMonoOutputBuffer(this.blockSize);
+    if (this.channelCount > 1) {
+      for (let ch = 0; ch < this.channelCount; ch++) {
+        this.planarChannels[ch] = this.changer.getPlanarChannelBuffer(ch, this.blockSize);
+      }
+    }
+  }
   /**
    * Returns the number of frames we can actually process given the
    * pre-allocated capacity. If the host requests more frames than the
@@ -2343,6 +2918,10 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
       const onMessage = (event) => {
         if (isEngineCommandRecord(event.data)) {
           this.bridge?.receiveCommand(event.data);
+          this.rtBridge?.receiveCommand(event.data);
+        } else if (isEngineSyncMessage(event.data)) {
+          this.bridge?.receiveSync(event.data);
+          this.rtBridge?.receiveSync(event.data);
         }
       };
       if (port?.addEventListener) {
@@ -2421,6 +3000,9 @@ export {
   createSonareEngineTelemetryRingBuffer,
   createSonareMeterRingBuffer,
   createSonareSpectrumRingBuffer,
+  decodeFrame,
+  encodeFrameHi,
+  encodeFrameLo,
   init,
   isInitialized,
   popSonareEngineCommandRingBuffer,