@libraz/libsonare 1.3.1 → 1.3.3

package/dist/worklet.js

@@ -1,13 +1,153 @@
+// src/errors.ts
+var SonareError = class extends Error {
+  constructor(code, codeName, message) {
+    super(message);
+    this.name = "SonareError";
+    this.code = code;
+    this.codeName = codeName;
+  }
+};
+
 // src/module_state.ts
-var wasmModule = null;
+var wrappedModule = null;
+function nativeExceptionPtr(error) {
+  if (typeof error === "number") {
+    return error;
+  }
+  if (error !== null && typeof error === "object") {
+    const ptr = error.excPtr;
+    if (typeof ptr === "number") {
+      return ptr;
+    }
+  }
+  return null;
+}
+function makeSonareError(raw, thrown) {
+  let code = 99 /* Unknown */;
+  let codeName = "Unknown";
+  let message = `libsonare native exception (${thrown})`;
+  try {
+    const info = raw.sonareExceptionInfo?.(thrown);
+    if (info) {
+      code = info.code ?? code;
+      codeName = info.codeName ?? codeName;
+      message = info.message || message;
+    }
+  } catch {
+  }
+  return new SonareError(code, codeName, message);
+}
+function wrapModuleErrors(raw) {
+  const cache = /* @__PURE__ */ new Map();
+  const objectCache = /* @__PURE__ */ new WeakMap();
+  const convert = (error) => {
+    const ptr = nativeExceptionPtr(error);
+    if (ptr !== null) {
+      throw makeSonareError(raw, ptr);
+    }
+    throw error;
+  };
+  const wrapNativeObject = (value) => {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
+      return value;
+    }
+    const objectValue = value;
+    const cached = objectCache.get(objectValue);
+    if (cached) {
+      return cached;
+    }
+    const methodCache = /* @__PURE__ */ new Map();
+    const wrapped = new Proxy(objectValue, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== "function") {
+          return member;
+        }
+        const cachedMethod = methodCache.get(prop);
+        if (cachedMethod) {
+          return cachedMethod;
+        }
+        const method = member;
+        const wrappedMethod = (...args) => {
+          try {
+            return wrapNativeObject(Reflect.apply(method, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        methodCache.set(prop, wrappedMethod);
+        return wrappedMethod;
+      }
+    });
+    objectCache.set(objectValue, wrapped);
+    return wrapped;
+  };
+  const wrapFunction = (value) => {
+    const fnCache = /* @__PURE__ */ new Map();
+    return new Proxy(value, {
+      get(target, prop, receiver) {
+        const member = Reflect.get(target, prop, receiver);
+        if (typeof member !== "function") {
+          return member;
+        }
+        const cachedMember = fnCache.get(prop);
+        if (cachedMember) {
+          return cachedMember;
+        }
+        const fn = member;
+        const wrappedMember = (...args) => {
+          try {
+            return wrapNativeObject(Reflect.apply(fn, target, args));
+          } catch (error) {
+            return convert(error);
+          }
+        };
+        fnCache.set(prop, wrappedMember);
+        return wrappedMember;
+      },
+      apply(t, thisArg, args) {
+        try {
+          return wrapNativeObject(Reflect.apply(t, thisArg, args));
+        } catch (error) {
+          return convert(error);
+        }
+      },
+      construct(t, args, newTarget) {
+        try {
+          return wrapNativeObject(Reflect.construct(t, args, newTarget));
+        } catch (error) {
+          return convert(error);
+        }
+      }
+    });
+  };
+  return new Proxy(raw, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const cached = cache.get(prop);
+      if (cached) {
+        return cached;
+      }
+      const wrapped = wrapFunction(value);
+      cache.set(prop, wrapped);
+      return wrapped;
+    }
+  });
+}
 function setSonareModule(module2) {
-  wasmModule = module2;
+  wrappedModule = wrapModuleErrors(module2);
 }
 function getSonareModule() {
-  if (!wasmModule) {
+  if (!wrappedModule) {
     throw new Error("Module not initialized. Call init() first.");
   }
-  return wasmModule;
+  return wrappedModule;
 }
 
 // src/codes.ts
@@ -82,6 +222,16 @@ var Mixer = class _Mixer {
   compile() {
     this.mixer.compile();
   }
+  /**
+   * 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();
+  }
   /**
    * Mix one block of per-strip stereo audio into the stereo master.
    *
@@ -644,9 +794,6 @@ function engineCapabilities() {
   };
 }
 var RealtimeEngine = class {
-  nativeExt() {
-    return this.native;
-  }
   constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024) {
     const module2 = getSonareModule();
     const capabilities = engineCapabilities();
@@ -673,8 +820,14 @@ var RealtimeEngine = class {
   setParameterSmoothed(paramId, value, renderFrame = -1) {
     this.native.setParameterSmoothed(paramId, value, renderFrame);
   }
+  setSoloMute(laneIndex, solo, mute, renderFrame = -1) {
+    this.native.setSoloMute(laneIndex, solo, mute, renderFrame);
+  }
+  setMidiClips(clips) {
+    this.native.setMidiClips(clips);
+  }
   setBuiltinInstrument(config = {}, destinationId = config.destinationId ?? 0) {
-    this.nativeExt().setBuiltinInstrument(destinationId, config);
+    this.native.setBuiltinInstrument(destinationId, config);
   }
   /**
    * Bind the patch-driven NativeSynth to a realtime MIDI destination. `patch`
@@ -686,7 +839,7 @@ var RealtimeEngine = class {
    * binding convenience, not part of the NativeSynth patch itself.
    */
   setSynthInstrument(patch = {}, destinationId = (typeof patch === "object" ? patch.destinationId : void 0) ?? 0) {
-    this.nativeExt().setSynthInstrument(destinationId, patch);
+    this.native.setSynthInstrument(destinationId, patch);
   }
   /**
    * Load (parse) SoundFont 2 bytes into the engine so SF2 instruments can be
@@ -695,7 +848,7 @@ var RealtimeEngine = class {
    * not referenced afterwards. Replaces any previously loaded SoundFont.
    */
   loadSoundFont(data) {
-    this.nativeExt().loadSoundFont(data);
+    this.native.loadSoundFont(data);
   }
   /**
    * Bind a GS-compatible SoundFont player to a realtime MIDI destination, fed
@@ -707,13 +860,13 @@ var RealtimeEngine = class {
    * synthesizer GM fallback bank (the data-free floor).
    */
   setSf2Instrument(config = {}, destinationId = config.destinationId ?? 0) {
-    this.nativeExt().setSf2Instrument(destinationId, config);
+    this.native.setSf2Instrument(destinationId, config);
   }
   clearMidiInstrument(destinationId = 0) {
-    this.nativeExt().clearMidiInstrument(destinationId);
+    this.native.clearMidiInstrument(destinationId);
   }
   midiInstrumentCount() {
-    return this.nativeExt().midiInstrumentCount();
+    return this.native.midiInstrumentCount();
   }
   /**
    * Bind a live MIDI CC to an engine automation parameter. The MIDI event still
@@ -721,7 +874,7 @@ var RealtimeEngine = class {
    * mapped into [minValue, maxValue] for `paramId`.
    */
   bindMidiCc(channel, controller, paramId, options = {}) {
-    this.nativeExt().bindMidiCc(
+    this.native.bindMidiCc(
       channel,
       controller,
       paramId,
@@ -730,42 +883,42 @@ var RealtimeEngine = class {
     );
   }
   clearMidiCcBindings() {
-    this.nativeExt().clearMidiCcBindings();
+    this.native.clearMidiCcBindings();
   }
   midiCcBindingCount() {
-    return this.nativeExt().midiCcBindingCount();
+    return this.native.midiCcBindingCount();
   }
   /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
   setMidiFx(destinationId, configJson) {
-    this.nativeExt().setMidiFx(destinationId, configJson);
+    this.native.setMidiFx(destinationId, configJson);
   }
   clearMidiFx(destinationId = 0) {
-    this.nativeExt().clearMidiFx(destinationId);
+    this.native.clearMidiFx(destinationId);
   }
   /** Enable the engine-owned live MIDI input source for a destination. */
   setMidiInputSource(destinationId = 0) {
-    this.nativeExt().setMidiInputSource(destinationId);
+    this.native.setMidiInputSource(destinationId);
   }
   clearMidiInputSource() {
-    this.nativeExt().clearMidiInputSource();
+    this.native.clearMidiInputSource();
   }
   midiInputPendingCount() {
-    return this.nativeExt().midiInputPendingCount();
+    return this.native.midiInputPendingCount();
   }
   pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples = 0) {
-    this.nativeExt().pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
+    this.native.pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
   }
   pushMidiInputNoteOff(group, channel, note, velocity = 0, portTimeSamples = 0) {
-    this.nativeExt().pushMidiInputNoteOff(group, channel, note, velocity, portTimeSamples);
+    this.native.pushMidiInputNoteOff(group, channel, note, velocity, portTimeSamples);
   }
   pushMidiInputCc(group, channel, controller, value, portTimeSamples = 0) {
-    this.nativeExt().pushMidiInputCc(group, channel, controller, value, portTimeSamples);
+    this.native.pushMidiInputCc(group, channel, controller, value, portTimeSamples);
   }
   pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame = -1) {
-    this.nativeExt().pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
+    this.native.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
   }
   pushMidiNoteOff(destinationId, group, channel, note, velocity = 0, renderFrame = -1) {
-    this.nativeExt().pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
+    this.native.pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
   }
   /**
    * Queue an immediate (live) MIDI control change to a MIDI destination
@@ -774,21 +927,21 @@ var RealtimeEngine = class {
    * immediate. Mirrors the Node/Python/C-ABI `pushMidiCc`.
    */
   pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
-    this.nativeExt().pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
+    this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
   /**
    * Queue a MIDI panic (all-notes-off) releasing every sounding note at
    * `renderFrame` (-1 = immediate). Mirrors the C-ABI `pushMidiPanic`.
    */
   pushMidiPanic(renderFrame = -1) {
-    this.nativeExt().pushMidiPanic(renderFrame);
+    this.native.pushMidiPanic(renderFrame);
   }
   /**
    * Remove all registered parameters (and their automation lanes). Control-thread
    * only; not realtime-safe. Mirrors the C-ABI `clearParameters`.
    */
   clearParameters() {
-    this.nativeExt().clearParameters();
+    this.native.clearParameters();
   }
   /** Read back the current transport state snapshot. */
   getTransportState() {
@@ -809,9 +962,18 @@ var RealtimeEngine = class {
   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);
   }
@@ -880,21 +1042,81 @@ var RealtimeEngine = class {
   clipCount() {
     return this.native.clipCount();
   }
+  setTrackLanes(lanes) {
+    this.native.setTrackLanes(
+      lanes.map((lane) => typeof lane === "number" ? { trackId: lane } : lane)
+    );
+  }
+  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);
+  }
   createClipPageProvider(numChannels, numSamples, pageFrames) {
-    const id = this.nativeExt().createClipPageProvider(numChannels, numSamples, pageFrames);
+    const id = this.native.createClipPageProvider(numChannels, numSamples, pageFrames);
     return new ClipPageProvider(this, id);
   }
   supplyClipPage(providerId, pageIndex, channels) {
-    this.nativeExt().supplyClipPage(providerId, pageIndex, channels);
+    this.native.supplyClipPage(providerId, pageIndex, channels);
   }
   clearClipPage(providerId, pageIndex) {
-    this.nativeExt().clearClipPage(providerId, pageIndex);
+    this.native.clearClipPage(providerId, pageIndex);
   }
   destroyClipPageProvider(providerId) {
-    this.nativeExt().destroyClipPageProvider(providerId);
+    this.native.destroyClipPageProvider(providerId);
   }
   popClipPageRequest() {
-    return this.nativeExt().popClipPageRequest();
+    return this.native.popClipPageRequest();
   }
   setCaptureBuffer(numChannels, capacityFrames) {
     this.native.setCaptureBuffer(numChannels, capacityFrames);
@@ -1012,7 +1234,7 @@ async function init(options) {
   }
   initPromise = (async () => {
     try {
-      const createModule = (await import("./sonare.js")).default;
+      const createModule = options?.moduleFactory ?? (await import("./sonare.js")).default;
       module = await createModule(options);
       setSonareModule(module);
     } catch (error) {
@@ -1027,8 +1249,20 @@ function isInitialized() {
 }
 
 // src/worklet.ts
+var ENGINE_MIXER_TARGET_BASE = 1297612800;
+var ENGINE_MIXER_PARAM_FADER_DB = 1;
+var ENGINE_MIXER_PARAM_PAN = 2;
+function engineMixerLaneTarget(laneIndex, paramKind) {
+  return ENGINE_MIXER_TARGET_BASE | (laneIndex & 255) << 8 | paramKind & 255;
+}
+function engineMixerBusTarget(busIndex, paramKind) {
+  return ENGINE_MIXER_TARGET_BASE | (254 - busIndex & 255) << 8 | paramKind & 255;
+}
+function engineMixerMasterTarget(paramKind) {
+  return ENGINE_MIXER_TARGET_BASE | 255 << 8 | paramKind & 255;
+}
 var SONARE_METER_RING_HEADER_INTS = 4;
-var SONARE_METER_RING_RECORD_FLOATS = 7;
+var SONARE_METER_RING_RECORD_FLOATS = 14;
 var SONARE_SPECTRUM_RING_HEADER_INTS = 5;
 var SONARE_FRAME_LANE_BASE = 16777216;
 function encodeFrameLo(frame) {
@@ -1119,7 +1353,19 @@ 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";
+  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 === "syncBuiltinInstrument" || value.type === "syncSynthInstrument" || value.type === "syncSf2Instrument" || value.type === "syncLoadSoundFont" || value.type === "syncMidiNoteOn" || value.type === "syncMidiNoteOff" || value.type === "syncMidiCc" || value.type === "syncMidiPanic";
+}
+function isEngineCaptureRequestMessage(value) {
+  return isRecord(value) && value.type === "captureRequest" && typeof value.requestId === "number" && (value.op === "status" || value.op === "read" || value.op === "reset");
+}
+function isEngineCaptureResponseMessage(value) {
+  return isRecord(value) && value.type === "captureResponse" && typeof value.requestId === "number" && typeof value.ok === "boolean";
+}
+function isEngineTransportRequestMessage(value) {
+  return isRecord(value) && value.type === "transportRequest" && typeof value.requestId === "number" && value.op === "state";
+}
+function isEngineTransportResponseMessage(value) {
+  return isRecord(value) && value.type === "transportResponse" && typeof value.requestId === "number" && typeof value.ok === "boolean";
 }
 function isRealtimeVoiceChangerMessage(value) {
   if (!isRecord(value) || typeof value.type !== "string") {
@@ -1131,7 +1377,7 @@ function isEngineTelemetryRecord(value) {
   return isRecord(value) && typeof value.type === "number" && typeof value.error === "number" && typeof value.renderFrame === "number" && typeof value.timelineSample === "number" && typeof value.audibleTimelineSample === "number" && typeof value.graphLatencySamplesQ8 === "number" && typeof value.value === "number";
 }
 function isMeterSnapshot(value) {
-  return isRecord(value) && value.type === "meter" && typeof value.frame === "number" && typeof value.peakDbL === "number" && typeof value.peakDbR === "number" && typeof value.rmsDbL === "number" && typeof value.rmsDbR === "number" && typeof value.correlation === "number";
+  return isRecord(value) && value.type === "meter" && typeof value.frame === "number" && typeof value.peakDbL === "number" && typeof value.peakDbR === "number" && typeof value.rmsDbL === "number" && typeof value.rmsDbR === "number" && typeof value.correlation === "number" && (typeof value.targetId === "number" || value.targetId === void 0);
 }
 function sonareMeterRingBufferByteLength(capacity) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
@@ -1149,19 +1395,27 @@ function createSonareMeterRingBuffer(capacity = 128) {
 }
 function readSonareMeterRingBuffer(ring, readIndex = 0) {
   const writeIndex = Atomics.load(ring.header, 0);
+  const recordFloats = Atomics.load(ring.header, 2) || SONARE_METER_RING_RECORD_FLOATS;
   const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
   const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
   const meters = [];
   for (let index = firstReadable; index < writeIndex; index++) {
-    const offset = index % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
+    const offset = index % ring.capacity * recordFloats;
     meters.push({
       type: "meter",
-      frame: decodeFrame(ring.records[offset], ring.records[offset + 6]),
-      peakDbL: ring.records[offset + 1],
-      peakDbR: ring.records[offset + 2],
-      rmsDbL: ring.records[offset + 3],
-      rmsDbR: ring.records[offset + 4],
-      correlation: ring.records[offset + 5]
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 1]),
+      targetId: ring.records[offset + 2],
+      peakDbL: ring.records[offset + 3],
+      peakDbR: ring.records[offset + 4],
+      rmsDbL: ring.records[offset + 5],
+      rmsDbR: ring.records[offset + 6],
+      correlation: ring.records[offset + 7],
+      truePeakDbL: ring.records[offset + 8],
+      truePeakDbR: ring.records[offset + 9],
+      momentaryLufs: ring.records[offset + 10],
+      shortTermLufs: ring.records[offset + 11],
+      integratedLufs: ring.records[offset + 12],
+      gainReductionDb: ring.records[offset + 13]
     });
   }
   return { nextReadIndex: writeIndex, meters };
@@ -1421,12 +1675,19 @@ function telemetryFromEngine(telemetry) {
 function meterFromEngine(meter) {
   return {
     type: "meter",
+    targetId: meter.targetId,
     frame: meter.renderFrame,
     peakDbL: meter.peakDbL,
     peakDbR: meter.peakDbR,
     rmsDbL: meter.rmsDbL,
     rmsDbR: meter.rmsDbR,
-    correlation: meter.correlation
+    correlation: meter.correlation,
+    truePeakDbL: meter.truePeakDbL,
+    truePeakDbR: meter.truePeakDbR,
+    momentaryLufs: meter.momentaryLufs,
+    shortTermLufs: meter.shortTermLufs,
+    integratedLufs: meter.integratedLufs,
+    gainReductionDb: meter.gainReductionDb
   };
 }
 function magnitudeToDb(value) {
@@ -1581,12 +1842,19 @@ var SonareWorkletProcessor = class {
     const denominator = Math.sqrt(sumL * sumR);
     const meter = {
       type: "meter",
+      targetId: 0,
       frame: this.processedFrames,
       peakDbL: toDb(peakL),
       peakDbR: toDb(peakR),
       rmsDbL: toDb(rmsL),
       rmsDbR: toDb(rmsR),
-      correlation: denominator > 0 ? sumLR / denominator : 0
+      correlation: denominator > 0 ? sumLR / denominator : 0,
+      truePeakDbL: toDb(peakL),
+      truePeakDbR: toDb(peakR),
+      momentaryLufs: Number.NaN,
+      shortTermLufs: Number.NaN,
+      integratedLufs: Number.NaN,
+      gainReductionDb: Number.NaN
     };
     this.transport.onMeter?.(meter);
     if (this.meterRing) {
@@ -1603,12 +1871,19 @@ var SonareWorkletProcessor = class {
     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);
+    ring.records[offset + 1] = encodeFrameHi(meter.frame);
+    ring.records[offset + 2] = meter.targetId;
+    ring.records[offset + 3] = meter.peakDbL;
+    ring.records[offset + 4] = meter.peakDbR;
+    ring.records[offset + 5] = meter.rmsDbL;
+    ring.records[offset + 6] = meter.rmsDbR;
+    ring.records[offset + 7] = meter.correlation;
+    ring.records[offset + 8] = meter.truePeakDbL;
+    ring.records[offset + 9] = meter.truePeakDbR;
+    ring.records[offset + 10] = meter.momentaryLufs;
+    ring.records[offset + 11] = meter.shortTermLufs;
+    ring.records[offset + 12] = meter.integratedLufs;
+    ring.records[offset + 13] = meter.gainReductionDb;
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
   publishSpectrum(left, right) {
@@ -1673,6 +1948,7 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     // 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.liveClips = /* @__PURE__ */ new Map();
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
     this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
@@ -1776,8 +2052,28 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     }
     switch (message.type) {
       case "syncClips":
+        this.liveClips.clear();
+        for (const clip of message.clips) {
+          if (clip.id !== void 0) {
+            this.liveClips.set(clip.id, clip);
+          }
+        }
         this.engine.setClips(message.clips);
         break;
+      case "syncClipsDelta":
+        for (const clipId of message.removeIds) {
+          this.liveClips.delete(clipId);
+        }
+        for (const clip of message.upserts) {
+          if (clip.id !== void 0) {
+            this.liveClips.set(clip.id, clip);
+          }
+        }
+        this.engine.setClips(Array.from(this.liveClips.values()));
+        break;
+      case "syncMidiClips":
+        this.engine.setMidiClips(message.clips);
+        break;
       case "syncMarkers":
         this.engine.setMarkers(message.markers);
         break;
@@ -1788,6 +2084,184 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       case "syncAutomation":
         this.engine.setAutomationLane(message.paramId, message.points);
         break;
+      case "syncTempo":
+        if (message.tempoSegments) {
+          this.engine.setTempoSegments(message.tempoSegments);
+        } else {
+          this.engine.setTempo(message.bpm);
+        }
+        if (message.timeSignatureSegments) {
+          this.engine.setTimeSignatureSegments(message.timeSignatureSegments);
+        } else {
+          this.engine.setTimeSignature(
+            message.timeSignature.numerator,
+            message.timeSignature.denominator
+          );
+        }
+        break;
+      case "syncMixer":
+        if (message.buses) {
+          this.engine.setTrackBuses(message.buses);
+        }
+        this.engine.setTrackLanes(message.lanes);
+        for (const strip of message.trackStrips ?? []) {
+          this.engine.setTrackStripJson(strip.trackId, strip.sceneJson);
+        }
+        for (const strip of message.busStrips ?? []) {
+          this.engine.setBusStripJson(strip.busId, strip.sceneJson);
+        }
+        if (message.masterStripJson) {
+          this.engine.setMasterStripJson(message.masterStripJson);
+        }
+        break;
+      case "syncCapture":
+        this.engine.setCaptureBuffer(message.channels, message.bufferFrames);
+        this.engine.setCaptureSource(message.source);
+        this.engine.setRecordOffsetSamples(message.recordOffsetSamples);
+        this.engine.setInputMonitor(message.inputMonitor.enabled, message.inputMonitor.gain);
+        break;
+      case "syncTrackStripEqBand":
+        this.engine.setTrackStripEqBandJson(message.trackId, message.bandIndex, message.bandJson);
+        break;
+      case "syncMasterStripEqBand":
+        this.engine.setMasterStripEqBandJson(message.bandIndex, message.bandJson);
+        break;
+      case "syncTrackStripInsertBypassed":
+        this.engine.setTrackStripInsertBypassed(
+          message.trackId,
+          message.insertIndex,
+          message.bypassed,
+          message.resetOnBypass
+        );
+        break;
+      case "syncMasterStripInsertBypassed":
+        this.engine.setMasterStripInsertBypassed(
+          message.insertIndex,
+          message.bypassed,
+          message.resetOnBypass
+        );
+        break;
+      case "syncBuiltinInstrument":
+        this.engine.setBuiltinInstrument(message.config, message.destinationId);
+        break;
+      case "syncSynthInstrument":
+        this.engine.setSynthInstrument(message.patch, message.destinationId);
+        break;
+      case "syncLoadSoundFont":
+        this.engine.loadSoundFont(message.data);
+        break;
+      case "syncSf2Instrument":
+        this.engine.setSf2Instrument(message.config, message.destinationId);
+        break;
+      case "syncMidiNoteOn":
+        this.engine.pushMidiNoteOn(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.note,
+          message.velocity,
+          message.renderFrame
+        );
+        break;
+      case "syncMidiNoteOff":
+        this.engine.pushMidiNoteOff(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.note,
+          message.velocity,
+          message.renderFrame
+        );
+        break;
+      case "syncMidiCc":
+        this.engine.pushMidiCc(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.controller,
+          message.value,
+          message.renderFrame
+        );
+        break;
+      case "syncMidiPanic":
+        this.engine.pushMidiPanic(message.renderFrame);
+        break;
+    }
+  }
+  receiveCaptureRequest(message) {
+    if (this.closed) {
+      return;
+    }
+    try {
+      if (message.op === "status") {
+        const status = this.engine.captureStatus();
+        this.transport?.postMessage?.({
+          type: "captureResponse",
+          requestId: message.requestId,
+          ok: true,
+          status: {
+            capturedFrames: status.capturedFrames,
+            overflowCount: status.overflowCount,
+            armed: status.armed,
+            punchEnabled: status.punchEnabled,
+            source: status.source,
+            recordOffsetSamples: status.recordOffsetSamples
+          }
+        });
+        return;
+      }
+      if (message.op === "read") {
+        const captured = this.engine.capturedAudio();
+        const channels = [];
+        for (let ch = 0; ch < captured.length; ch++) {
+          const source = captured[ch];
+          const copy = [];
+          for (let i = 0; i < source.length; i++) {
+            copy.push(Number(source[i]));
+          }
+          channels.push(copy);
+        }
+        this.transport?.postMessage?.({
+          type: "captureResponse",
+          requestId: message.requestId,
+          ok: true,
+          channels
+        });
+        return;
+      }
+      this.engine.resetCapture();
+      this.transport?.postMessage?.({
+        type: "captureResponse",
+        requestId: message.requestId,
+        ok: true
+      });
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: "captureResponse",
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  receiveTransportRequest(message) {
+    if (this.closed) {
+      return;
+    }
+    try {
+      this.transport?.postMessage?.({
+        type: "transportResponse",
+        requestId: message.requestId,
+        ok: true,
+        state: this.engine.getTransportState()
+      });
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: "transportResponse",
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   destroy() {
@@ -1868,6 +2342,14 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       case 17 /* SeekMarker */:
         this.engine.seekMarker(Math.trunc(Number(command.targetId ?? 0)), sampleTime);
         break;
+      case 10 /* SetSoloMute */:
+        this.engine.setSoloMute(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Boolean((Number(command.argInt ?? 0) & 2) !== 0),
+          Boolean((Number(command.argInt ?? 0) & 1) !== 0),
+          sampleTime
+        );
+        break;
       default:
         this.publishTelemetryRecord({
           type: 1 /* Error */,
@@ -1899,10 +2381,12 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     }
     for (const item of this.engine.drainMeterTelemetry(64)) {
       const meter = meterFromEngine(item);
-      if (meter.frame - this.lastMeterFrame < this.meterIntervalFrames) {
+      if (meter.frame !== this.lastMeterFrame && meter.frame - this.lastMeterFrame < this.meterIntervalFrames) {
         continue;
       }
-      this.lastMeterFrame = meter.frame;
+      if (meter.frame !== this.lastMeterFrame) {
+        this.lastMeterFrame = meter.frame;
+      }
       if (this.meterRing) {
         this.writeMeterRing(meter);
       } else {
@@ -1919,12 +2403,19 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     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);
+    ring.records[offset + 1] = encodeFrameHi(meter.frame);
+    ring.records[offset + 2] = meter.targetId;
+    ring.records[offset + 3] = meter.peakDbL;
+    ring.records[offset + 4] = meter.peakDbR;
+    ring.records[offset + 5] = meter.rmsDbL;
+    ring.records[offset + 6] = meter.rmsDbR;
+    ring.records[offset + 7] = meter.correlation;
+    ring.records[offset + 8] = meter.truePeakDbL;
+    ring.records[offset + 9] = meter.truePeakDbR;
+    ring.records[offset + 10] = meter.momentaryLufs;
+    ring.records[offset + 11] = meter.shortTermLufs;
+    ring.records[offset + 12] = meter.integratedLufs;
+    ring.records[offset + 13] = meter.gainReductionDb;
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
   commandRingFromSharedBuffer(sharedBuffer, fallbackCapacity) {
@@ -2056,9 +2547,28 @@ var SonareRtRealtimeEngineRuntime = class {
           this.metronomeConfig.clickSamples
         );
         break;
+      case "syncTempo":
+        this.module._sonare_rt_engine_set_tempo(this.engine, message.bpm);
+        break;
       case "syncClips":
+      case "syncClipsDelta":
+      case "syncMidiClips":
       case "syncMarkers":
       case "syncAutomation":
+      case "syncMixer":
+      case "syncCapture":
+      case "syncTrackStripEqBand":
+      case "syncMasterStripEqBand":
+      case "syncTrackStripInsertBypassed":
+      case "syncMasterStripInsertBypassed":
+      case "syncBuiltinInstrument":
+      case "syncSynthInstrument":
+      case "syncSf2Instrument":
+      case "syncLoadSoundFont":
+      case "syncMidiNoteOn":
+      case "syncMidiNoteOff":
+      case "syncMidiCc":
+      case "syncMidiPanic":
         if (this.telemetryRing) {
           writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
             type: 1 /* Error */,
@@ -2073,6 +2583,28 @@ var SonareRtRealtimeEngineRuntime = class {
         break;
     }
   }
+  receiveCaptureRequest(message, port) {
+    if (this.closed) {
+      return;
+    }
+    port?.postMessage?.({
+      type: "captureResponse",
+      requestId: message.requestId,
+      ok: false,
+      error: "Capture read-back is not supported by the sonare-rt runtime."
+    });
+  }
+  receiveTransportRequest(message, port) {
+    if (this.closed) {
+      return;
+    }
+    port?.postMessage?.({
+      type: "transportResponse",
+      requestId: message.requestId,
+      ok: false,
+      error: "Transport state read-back is not supported by the sonare-rt runtime."
+    });
+  }
   destroy() {
     if (this.closed) {
       return;
@@ -2250,6 +2782,10 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.meterReadIndex = 0;
     this.telemetryListeners = /* @__PURE__ */ new Set();
     this.meterListeners = /* @__PURE__ */ new Set();
+    this.captureRequestId = 1;
+    this.captureRequests = /* @__PURE__ */ new Map();
+    this.transportRequestId = 1;
+    this.transportRequests = /* @__PURE__ */ new Map();
     this.destroyed = false;
     this.node = node;
     this.capabilities = capabilities;
@@ -2260,11 +2796,31 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       this.resolveReady = resolve;
       this.rejectReady = reject;
     });
-    if (capabilities.runtimeTarget !== "sonare-rt") {
+    if (!capabilities.readyMessage) {
       this.resolveReady();
     }
     this.node.port.onmessage = (event) => {
-      if (isEngineTelemetryRecord(event.data)) {
+      if (isEngineCaptureResponseMessage(event.data)) {
+        const pending = this.captureRequests.get(event.data.requestId);
+        if (pending) {
+          this.captureRequests.delete(event.data.requestId);
+          if (event.data.ok) {
+            pending.resolve(event.data);
+          } else {
+            pending.reject(new Error(event.data.error ?? "Capture request failed"));
+          }
+        }
+      } else if (isEngineTransportResponseMessage(event.data)) {
+        const pending = this.transportRequests.get(event.data.requestId);
+        if (pending) {
+          this.transportRequests.delete(event.data.requestId);
+          if (event.data.ok) {
+            pending.resolve(event.data);
+          } else {
+            pending.reject(new Error(event.data.error ?? "Transport request failed"));
+          }
+        }
+      } else if (isEngineTelemetryRecord(event.data)) {
         this.emitTelemetry(event.data);
       } else if (isMeterSnapshot(event.data)) {
         this.emitMeter(event.data);
@@ -2318,7 +2874,10 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       telemetrySharedBuffer: telemetryRing?.sharedBuffer,
       telemetryRingCapacity: telemetryRing?.capacity,
       meterSharedBuffer: meterRing?.sharedBuffer,
-      meterRingCapacity: meterRing?.capacity
+      meterRingCapacity: meterRing?.capacity,
+      wasmBinary: options.wasmBinary,
+      initialSyncMessages: options.initialSyncMessages,
+      initialCommands: options.initialCommands
     };
     const factory = options.nodeFactory ?? ((ctx, name, nodeOptions) => new AudioWorkletNode(ctx, name, nodeOptions));
     const node = factory(context, processorName, {
@@ -2338,7 +2897,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         engineAbiVersion: detectedCapabilities?.engineAbiVersion,
         expectedEngineAbiVersion: detectedCapabilities?.expectedEngineAbiVersion,
         abiCompatible: detectedCapabilities?.abiCompatible,
-        degradedReason
+        degradedReason,
+        readyMessage: runtimeTarget === "sonare-rt" || runtimeTarget === "embind" && moduleUrl !== void 0 && !options.nodeFactory
       },
       commandRing,
       telemetryRing,
@@ -2375,6 +2935,32 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.node.port.postMessage(command);
     return true;
   }
+  requestCaptureStatus() {
+    return this.sendCaptureRequest("status").then((response) => {
+      if (!response.status) {
+        throw new Error("Capture status response is missing status.");
+      }
+      return response.status;
+    });
+  }
+  requestCapturedAudio() {
+    return this.sendCaptureRequest("read").then(
+      (response) => (response.channels ?? []).map(
+        (channel) => channel instanceof Float32Array ? channel : new Float32Array(channel)
+      )
+    );
+  }
+  requestCaptureReset() {
+    return this.sendCaptureRequest("reset").then(() => void 0);
+  }
+  requestTransportState() {
+    return this.sendTransportRequest().then((response) => {
+      if (!response.state) {
+        throw new Error("Transport state response is missing state.");
+      }
+      return response.state;
+    });
+  }
   pollTelemetry() {
     if (!this.telemetryRing) {
       return [];
@@ -2419,6 +3005,14 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.destroyed = true;
     this.node.port.postMessage({ type: 3 /* TransportStop */, sampleTime: -1 });
     this.node.disconnect();
+    for (const pending of this.captureRequests.values()) {
+      pending.reject(new Error("Realtime engine node is destroyed."));
+    }
+    this.captureRequests.clear();
+    for (const pending of this.transportRequests.values()) {
+      pending.reject(new Error("Realtime engine node is destroyed."));
+    }
+    this.transportRequests.clear();
     this.telemetryListeners.clear();
     this.meterListeners.clear();
   }
@@ -2432,14 +3026,50 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       listener(meter);
     }
   }
+  sendCaptureRequest(op) {
+    if (this.destroyed) {
+      return Promise.reject(new Error("Realtime engine node is destroyed."));
+    }
+    const requestId = this.captureRequestId++;
+    const promise = new Promise((resolve, reject) => {
+      this.captureRequests.set(requestId, { resolve, reject });
+    });
+    this.node.port.postMessage({ type: "captureRequest", requestId, op });
+    return promise;
+  }
+  sendTransportRequest() {
+    if (this.destroyed) {
+      return Promise.reject(new Error("Realtime engine node is destroyed."));
+    }
+    const requestId = this.transportRequestId++;
+    const promise = new Promise((resolve, reject) => {
+      this.transportRequests.set(requestId, { resolve, reject });
+    });
+    this.node.port.postMessage({ type: "transportRequest", requestId, op: "state" });
+    return promise;
+  }
 };
 var SonareEngine = class _SonareEngine {
   constructor(context, realtimeNode, offlineEngine, sampleRate, offlineBlockSize, offlineChannelCount) {
     this.automationLanes = /* @__PURE__ */ new Map();
     this.clips = /* @__PURE__ */ new Map();
+    this.midiClips = /* @__PURE__ */ new Map();
     this.markers = /* @__PURE__ */ new Map();
+    this.trackLaneIds = [];
+    this.trackSends = /* @__PURE__ */ new Map();
+    this.buses = [];
+    this.trackStripJson = /* @__PURE__ */ new Map();
+    this.busStripJson = /* @__PURE__ */ new Map();
+    this.tempoBpm = 120;
+    this.timeSignature = { numerator: 4, denominator: 4 };
+    this.tempoSegments = [{ startPpq: 0, bpm: 120 }];
+    this.timeSignatureSegments = [
+      { startPpq: 0, numerator: 4, denominator: 4 }
+    ];
     this.nextClipId = 1;
     this.nextMarkerId = 1;
+    this.transportPlaying = false;
+    this.pendingInstrumentSync = [];
     this.destroyed = false;
     this.context = context;
     this.realtimeNode = realtimeNode;
@@ -2450,8 +3080,21 @@ var SonareEngine = class _SonareEngine {
     this.offlineBlockSize = offlineBlockSize;
     this.offlineChannelCount = offlineChannelCount;
     this.transport = {
-      play: (sampleTime = -1) => this.realtimeNode.play(sampleTime),
-      stop: (sampleTime = -1) => this.realtimeNode.stop(sampleTime),
+      play: (sampleTime = -1) => {
+        const ok = this.realtimeNode.play(sampleTime);
+        if (ok) {
+          this.transportPlaying = true;
+        }
+        return ok;
+      },
+      stop: (sampleTime = -1) => {
+        const ok = this.realtimeNode.stop(sampleTime);
+        if (ok) {
+          this.transportPlaying = false;
+          this.flushPendingInstrumentSync();
+        }
+        return ok;
+      },
       seekPpq: (ppq, sampleTime = -1) => {
         this.offlineEngine.seekPpq(ppq, sampleTime);
         return this.realtimeNode.seekPpq(ppq, sampleTime);
@@ -2462,6 +3105,7 @@ var SonareEngine = class _SonareEngine {
         return this.realtimeNode.seekSample(timelineSample, sampleTime);
       },
       setTempo: (bpm) => this.setTempo(bpm),
+      setTempoSegments: (segments) => this.setTempoSegments(segments),
       setLoop: (startPpq, endPpq, enabled = true) => this.setLoop(startPpq, endPpq, enabled)
     };
   }
@@ -2496,13 +3140,37 @@ var SonareEngine = class _SonareEngine {
     await this.context.resume?.();
   }
   setTempo(bpm) {
+    this.tempoBpm = bpm;
+    this.tempoSegments = [{ startPpq: 0, bpm }];
     this.offlineEngine.setTempo(bpm);
+    this.postTempoSync();
     this.realtimeNode.sendCommand({
       type: 6 /* SetTempoMap */,
       sampleTime: -1,
       argFloat: bpm
     });
   }
+  setTempoSegments(segments) {
+    this.tempoSegments = segments.map((segment) => ({ ...segment }));
+    this.tempoBpm = this.tempoSegments[0]?.bpm ?? this.tempoBpm;
+    this.offlineEngine.setTempoSegments(this.tempoSegments);
+    this.postTempoSync();
+  }
+  setTimeSignature(numerator, denominator) {
+    this.timeSignature = { numerator, denominator };
+    this.timeSignatureSegments = [{ startPpq: 0, numerator, denominator }];
+    this.offlineEngine.setTimeSignature(numerator, denominator);
+    this.postTempoSync();
+  }
+  setTimeSignatureSegments(segments) {
+    this.timeSignatureSegments = segments.map((segment) => ({ ...segment }));
+    const first = this.timeSignatureSegments[0];
+    if (first) {
+      this.timeSignature = { numerator: first.numerator, denominator: first.denominator };
+    }
+    this.offlineEngine.setTimeSignatureSegments(this.timeSignatureSegments);
+    this.postTempoSync();
+  }
   setLoop(startPpq, endPpq, enabled = true) {
     this.offlineEngine.setLoop(startPpq, endPpq, enabled);
     return this.realtimeNode.sendCommand({
@@ -2513,6 +3181,17 @@ var SonareEngine = class _SonareEngine {
       argInt: Math.round(endPpq * 1e6)
     });
   }
+  countInEndSample(startSample, bars) {
+    return this.offlineEngine.countInEndSample(startSample, bars);
+  }
+  async getTransportState() {
+    const state = await this.realtimeNode.requestTransportState();
+    this.latestTransportState = state;
+    return state;
+  }
+  cachedTransportState() {
+    return this.latestTransportState;
+  }
   setParam(nodeId, param, value) {
     const paramId = this.resolveParamId(nodeId, param);
     this.offlineEngine.setParameter(paramId, value);
@@ -2543,12 +3222,198 @@ var SonareEngine = class _SonareEngine {
     return parameters;
   }
   setSoloMute(target, solo, mute) {
-    void target;
-    void solo;
-    void mute;
-    throw new Error(
-      "SonareEngine.setSoloMute is not supported: solo/mute is a Mixer feature; use Mixer.setSoloed(stripIndex, ...) / Mixer.setMuted(stripIndex, ...) instead."
+    const laneIndex = this.ensureTrackLane(target);
+    this.offlineEngine.setSoloMute(laneIndex, solo, mute);
+    return this.realtimeNode.sendCommand({
+      type: 10 /* SetSoloMute */,
+      targetId: laneIndex,
+      sampleTime: -1,
+      argInt: (mute ? 1 : 0) | (solo ? 2 : 0)
+    });
+  }
+  setStripGain(target, db) {
+    if (target === "master") {
+      const paramId2 = engineMixerMasterTarget(ENGINE_MIXER_PARAM_FADER_DB);
+      this.offlineEngine.setParameter(paramId2, db);
+      return this.realtimeNode.sendCommand({
+        type: 1 /* SetParamSmoothed */,
+        targetId: paramId2,
+        sampleTime: -1,
+        argFloat: db
+      });
+    }
+    const laneIndex = this.ensureTrackLane(target);
+    const paramId = engineMixerLaneTarget(laneIndex, ENGINE_MIXER_PARAM_FADER_DB);
+    this.offlineEngine.setParameter(paramId, db);
+    return this.realtimeNode.sendCommand({
+      type: 1 /* SetParamSmoothed */,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: db
+    });
+  }
+  setStripPan(target, pan) {
+    if (target === "master") {
+      const paramId2 = engineMixerMasterTarget(ENGINE_MIXER_PARAM_PAN);
+      this.offlineEngine.setParameter(paramId2, pan);
+      return this.realtimeNode.sendCommand({
+        type: 1 /* SetParamSmoothed */,
+        targetId: paramId2,
+        sampleTime: -1,
+        argFloat: pan
+      });
+    }
+    const laneIndex = this.ensureTrackLane(target);
+    const paramId = engineMixerLaneTarget(laneIndex, ENGINE_MIXER_PARAM_PAN);
+    this.offlineEngine.setParameter(paramId, pan);
+    return this.realtimeNode.sendCommand({
+      type: 1 /* SetParamSmoothed */,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: pan
+    });
+  }
+  /**
+   * Declares the mixer track lanes in an explicit order.
+   *
+   * Lane indices are append-only: once a track id occupies a lane, its index
+   * stays fixed for the engine's lifetime. The given list must therefore start
+   * with the already-declared lane ids in their current order and may only
+   * append new track ids after them. Entries carrying `sends` replace that
+   * track's send list; entries without `sends` leave existing sends untouched.
+   *
+   * @param lanes Track ids or lane descriptors in the desired lane order.
+   */
+  setTrackLanes(lanes) {
+    const entries = lanes.map((lane) => typeof lane === "number" ? { trackId: lane } : lane);
+    const ids = [];
+    for (const entry of entries) {
+      if (!Number.isInteger(entry.trackId) || entry.trackId <= 0) {
+        throw new Error(`Invalid track id for mixer lane: ${String(entry.trackId)}`);
+      }
+      ids.push(entry.trackId);
+    }
+    if (new Set(ids).size !== ids.length) {
+      throw new Error("Duplicate track id in mixer lane list");
+    }
+    for (let index = 0; index < this.trackLaneIds.length; index++) {
+      if (ids[index] !== this.trackLaneIds[index]) {
+        throw new Error(
+          "Mixer lanes are append-only: keep existing lanes in order and only append new track ids"
+        );
+      }
+    }
+    for (const entry of entries) {
+      if (entry.sends) {
+        this.trackSends.set(
+          entry.trackId,
+          entry.sends.map((send) => ({ ...send }))
+        );
+      }
+    }
+    this.trackLaneIds.splice(0, this.trackLaneIds.length, ...ids);
+    this.syncMixer();
+  }
+  setSends(target, sends) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.trackSends.set(
+      trackId,
+      sends.map((send) => ({ ...send }))
     );
+    this.syncMixer();
+  }
+  setTrackBuses(buses) {
+    this.buses.splice(0, this.buses.length, ...buses.map((bus) => ({ ...bus })));
+    this.syncMixer();
+  }
+  setBusGain(busId, db) {
+    const busIndex = this.ensureBus(busId);
+    this.buses[busIndex] = { ...this.buses[busIndex], busId, gainDb: db };
+    this.offlineEngine.setTrackBuses(this.buses);
+    const paramId = engineMixerBusTarget(busIndex, ENGINE_MIXER_PARAM_FADER_DB);
+    this.offlineEngine.setParameter(paramId, db);
+    return this.realtimeNode.sendCommand({
+      type: 1 /* SetParamSmoothed */,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: db
+    });
+  }
+  setTrackStripJson(target, sceneJson) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripJson(trackId, sceneJson);
+    this.trackStripJson.set(trackId, sceneJson);
+    this.syncMixer();
+  }
+  setTrackStripEqBand(target, bandIndex, band) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    const bandJson = typeof band === "string" ? band : JSON.stringify(band);
+    this.offlineEngine.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+    this.postSync({ type: "syncTrackStripEqBand", trackId, bandIndex, bandJson });
+  }
+  setTrackStripInsertBypassed(target, insertIndex, bypassed, resetOnBypass = false) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
+    this.postSync({
+      type: "syncTrackStripInsertBypassed",
+      trackId,
+      insertIndex,
+      bypassed,
+      resetOnBypass
+    });
+  }
+  setStripEq(target, bandIndex, band) {
+    if (target === "master") {
+      this.setMasterStripEqBand(bandIndex, band);
+      return;
+    }
+    this.setTrackStripEqBand(target, bandIndex, band);
+  }
+  setStripInsertBypassed(target, insertIndex, bypassed, resetOnBypass = false) {
+    if (target === "master") {
+      this.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+      return;
+    }
+    this.setTrackStripInsertBypassed(target, insertIndex, bypassed, resetOnBypass);
+  }
+  setStripInserts(target, sceneJson) {
+    if (target === "master") {
+      this.setMasterStripJson(sceneJson);
+      return;
+    }
+    this.setTrackStripJson(target, sceneJson);
+  }
+  setBusStripJson(busId, sceneJson) {
+    this.ensureBus(busId);
+    this.offlineEngine.setBusStripJson(busId, sceneJson);
+    this.busStripJson.set(busId, sceneJson);
+    this.syncMixer();
+  }
+  setMasterStripJson(sceneJson) {
+    this.offlineEngine.setMasterStripJson(sceneJson);
+    this.masterStripJson = sceneJson;
+    this.syncMixer();
+  }
+  setMasterStripEqBand(bandIndex, band) {
+    const bandJson = typeof band === "string" ? band : JSON.stringify(band);
+    this.offlineEngine.setMasterStripEqBandJson(bandIndex, bandJson);
+    this.postSync({ type: "syncMasterStripEqBand", bandIndex, bandJson });
+  }
+  setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass = false) {
+    this.offlineEngine.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+    this.postSync({
+      type: "syncMasterStripInsertBypassed",
+      insertIndex,
+      bypassed,
+      resetOnBypass
+    });
+  }
+  setMasterChain(sceneJson) {
+    this.setMasterStripJson(sceneJson);
   }
   addClip(trackId, buffer, startPpq, opts = {}) {
     const id = opts.id ?? this.nextClipId++;
@@ -2556,18 +3421,108 @@ var SonareEngine = class _SonareEngine {
       ...opts,
       id,
       channels: buffer,
-      startPpq
+      startPpq,
+      trackId: this.resolveTargetId(trackId)
     };
+    this.ensureTrackLane(trackId);
     this.clips.set(id, clip);
-    this.syncClips();
-    void trackId;
+    this.syncClipsDelta([clip], []);
     return id;
   }
   removeClip(clipId) {
     this.clips.delete(clipId);
-    this.syncClips();
+    this.syncClipsDelta([], [clipId]);
+  }
+  setMidiClips(clips) {
+    this.midiClips.clear();
+    for (const clip of clips) {
+      const id = clip.id ?? this.nextClipId++;
+      this.midiClips.set(id, { ...clip, id, events: clip.events.map((event) => ({ ...event })) });
+    }
+    this.syncMidiClips();
+  }
+  setBuiltinInstrument(trackId, config = {}) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setBuiltinInstrument(config, destinationId);
+    this.postInstrumentSync({ type: "syncBuiltinInstrument", destinationId, config });
+  }
+  setSynthInstrument(trackId, patch = {}) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setSynthInstrument(patch, destinationId);
+    this.postInstrumentSync({ type: "syncSynthInstrument", destinationId, patch });
+  }
+  loadSoundFont(data) {
+    this.offlineEngine.loadSoundFont(data);
+    this.postInstrumentSync({ type: "syncLoadSoundFont", data });
+  }
+  setSf2Instrument(trackId, config = {}) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setSf2Instrument(config, destinationId);
+    this.postInstrumentSync({ type: "syncSf2Instrument", destinationId, config });
+  }
+  pushMidiNoteOn(trackId, group, channel, note, velocity, renderFrame = -1) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
+    this.postSync({
+      type: "syncMidiNoteOn",
+      destinationId,
+      group,
+      channel,
+      note,
+      velocity,
+      renderFrame
+    });
+  }
+  pushMidiNoteOff(trackId, group, channel, note, velocity = 0, renderFrame = -1) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
+    this.postSync({
+      type: "syncMidiNoteOff",
+      destinationId,
+      group,
+      channel,
+      note,
+      velocity,
+      renderFrame
+    });
+  }
+  pushMidiCc(trackId, group, channel, controller, value, renderFrame = -1) {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
+    this.postSync({
+      type: "syncMidiCc",
+      destinationId,
+      group,
+      channel,
+      controller,
+      value,
+      renderFrame
+    });
+  }
+  pushMidiPanic(renderFrame = -1) {
+    this.offlineEngine.pushMidiPanic(renderFrame);
+    this.postSync({ type: "syncMidiPanic", renderFrame });
+  }
+  configureCapture(options) {
+    const bufferFrames = Math.trunc(options.bufferFrames);
+    const channels = Math.trunc(options.channels ?? this.offlineChannelCount);
+    const source = options.source ?? "output";
+    const recordOffsetSamples = Math.trunc(options.recordOffsetSamples ?? 0);
+    const inputMonitor = {
+      enabled: Boolean(options.inputMonitor?.enabled),
+      gain: options.inputMonitor?.gain ?? 1
+    };
+    this.offlineEngine.setCaptureBuffer(channels, bufferFrames);
+    this.offlineEngine.setCaptureSource(source);
+    this.offlineEngine.setRecordOffsetSamples(recordOffsetSamples);
+    this.offlineEngine.setInputMonitor(inputMonitor.enabled, inputMonitor.gain);
+    this.captureConfig = { bufferFrames, channels, source, recordOffsetSamples, inputMonitor };
+    this.postSync({ type: "syncCapture", ...this.captureConfig });
   }
   armRecord(trackId, enabled) {
+    if (enabled && !this.captureConfig) {
+      throw new Error("Capture buffer is not configured");
+    }
     this.offlineEngine.armCapture(enabled);
     return this.realtimeNode.sendCommand({
       type: 13 /* ArmRecord */,
@@ -2577,8 +3532,8 @@ var SonareEngine = class _SonareEngine {
     });
   }
   punch(inPpq, outPpq) {
-    const inSample = this.ppqToApproxSample(inPpq);
-    const outSample = this.ppqToApproxSample(outPpq);
+    const inSample = this.offlineEngine.sampleAtPpq(inPpq);
+    const outSample = this.offlineEngine.sampleAtPpq(outPpq);
     this.offlineEngine.setCapturePunch(inSample, outSample, true);
     return this.realtimeNode.sendCommand({
       type: 14 /* Punch */,
@@ -2587,6 +3542,16 @@ var SonareEngine = class _SonareEngine {
       argFloat: outSample
     });
   }
+  captureStatus() {
+    return this.realtimeNode.requestCaptureStatus();
+  }
+  capturedAudio() {
+    return this.realtimeNode.requestCapturedAudio();
+  }
+  async resetCapture() {
+    this.offlineEngine.resetCapture();
+    await this.realtimeNode.requestCaptureReset();
+  }
   setMetronome(opts) {
     this.offlineEngine.setMetronome(opts);
     this.postSync({ type: "syncMetronome", config: opts });
@@ -2602,6 +3567,55 @@ var SonareEngine = class _SonareEngine {
     this.syncMarkers();
     return id;
   }
+  /**
+   * Replaces the whole marker set in one call.
+   *
+   * Entries without an `id` are assigned fresh ids; entries carrying an `id`
+   * keep it (ids must be positive and unique within the list). Returns the
+   * resolved markers in the order given, so a caller can map its own marker
+   * identities to the engine ids used by `seekMarker`/`setLoopFromMarkers`.
+   *
+   * @param markers The full marker list (an empty list clears all markers).
+   * @returns The markers with their resolved engine ids.
+   */
+  setMarkers(markers) {
+    const resolved = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const marker of markers) {
+      if (!Number.isFinite(marker.ppq)) {
+        throw new Error(`Invalid marker ppq: ${String(marker.ppq)}`);
+      }
+      if (marker.id !== void 0) {
+        if (!Number.isInteger(marker.id) || marker.id <= 0) {
+          throw new Error(`Invalid marker id: ${String(marker.id)}`);
+        }
+        if (seen.has(marker.id)) {
+          throw new Error(`Duplicate marker id: ${marker.id}`);
+        }
+      }
+      const id = marker.id ?? this.nextMarkerId++;
+      seen.add(id);
+      if (id >= this.nextMarkerId) {
+        this.nextMarkerId = id + 1;
+      }
+      resolved.push({ id, ppq: marker.ppq, name: marker.name ?? "" });
+    }
+    this.markers.clear();
+    for (const marker of resolved) {
+      this.markers.set(marker.id, marker);
+    }
+    this.syncMarkers();
+    return resolved.map((marker) => ({ ...marker }));
+  }
+  markerCount() {
+    return this.offlineEngine.markerCount();
+  }
+  markerByIndex(index) {
+    return this.offlineEngine.markerByIndex(index);
+  }
+  marker(markerId) {
+    return this.offlineEngine.marker(markerId);
+  }
   seekMarker(markerId) {
     this.offlineEngine.seekMarker(markerId);
     return this.realtimeNode.sendCommand({
@@ -2610,6 +3624,12 @@ var SonareEngine = class _SonareEngine {
       sampleTime: -1
     });
   }
+  setLoopFromMarkers(startMarkerId, endMarkerId) {
+    this.offlineEngine.setLoopFromMarkers(startMarkerId, endMarkerId);
+    const start = this.offlineEngine.marker(startMarkerId);
+    const end = this.offlineEngine.marker(endMarkerId);
+    return this.setLoop(start.ppq, end.ppq, true);
+  }
   async renderOffline(totalFrames) {
     const frames = Math.max(0, Math.floor(totalFrames));
     const inputs = [];
@@ -2640,16 +3660,80 @@ var SonareEngine = class _SonareEngine {
     this.realtimeNode.destroy();
     this.offlineEngine.destroy();
   }
-  syncClips() {
+  syncClipsDelta(upserts, removeIds) {
     const clips = Array.from(this.clips.values());
     this.offlineEngine.setClips(clips);
-    this.postSync({ type: "syncClips", clips });
+    this.postSync({
+      type: "syncClipsDelta",
+      upserts,
+      removeIds
+    });
+  }
+  syncMidiClips() {
+    const clips = Array.from(this.midiClips.values());
+    this.offlineEngine.setMidiClips(clips);
+    this.postSync({ type: "syncMidiClips", clips });
+  }
+  syncMixer() {
+    const lanes = this.trackLaneIds.map((trackId) => {
+      const sends = this.trackSends.get(trackId);
+      return sends && sends.length > 0 ? { trackId, sends: sends.map((send) => ({ ...send })) } : { trackId };
+    });
+    const buses = this.buses.map((bus) => ({ ...bus }));
+    this.offlineEngine.setTrackBuses(buses);
+    if (lanes.length > 0) {
+      this.offlineEngine.setTrackLanes(lanes);
+    }
+    const trackStrips = Array.from(this.trackStripJson, ([trackId, sceneJson]) => ({
+      trackId,
+      sceneJson
+    }));
+    const busStrips = Array.from(this.busStripJson, ([busId, sceneJson]) => ({
+      busId,
+      sceneJson
+    }));
+    this.postSync({
+      type: "syncMixer",
+      lanes,
+      buses,
+      trackStrips,
+      busStrips,
+      masterStripJson: this.masterStripJson
+    });
   }
   syncMarkers() {
     const markers = Array.from(this.markers.values()).sort((a, b) => a.ppq - b.ppq);
     this.offlineEngine.setMarkers(markers);
     this.postSync({ type: "syncMarkers", markers });
   }
+  postInstrumentSync(message) {
+    if (this.destroyed) {
+      return;
+    }
+    if (this.transportPlaying) {
+      this.pendingInstrumentSync.push(message);
+      return;
+    }
+    this.postSync(message);
+  }
+  flushPendingInstrumentSync() {
+    if (this.destroyed || this.pendingInstrumentSync.length === 0) {
+      return;
+    }
+    const pending = this.pendingInstrumentSync.splice(0);
+    for (const message of pending) {
+      this.postSync(message);
+    }
+  }
+  postTempoSync() {
+    this.postSync({
+      type: "syncTempo",
+      bpm: this.tempoBpm,
+      timeSignature: { ...this.timeSignature },
+      tempoSegments: this.tempoSegments.map((segment) => ({ ...segment })),
+      timeSignatureSegments: this.timeSignatureSegments.map((segment) => ({ ...segment }))
+    });
+  }
   // 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).
@@ -2676,15 +3760,38 @@ var SonareEngine = class _SonareEngine {
     const parsed = Number.parseInt(target, 10);
     return Number.isFinite(parsed) ? parsed : 0;
   }
+  ensureTrackLane(target) {
+    const trackId = this.resolveTargetId(target);
+    if (!Number.isInteger(trackId) || trackId <= 0) {
+      throw new Error(`Invalid track id for mixer lane: ${String(target)}`);
+    }
+    const existing = this.trackLaneIds.indexOf(trackId);
+    if (existing >= 0) {
+      return existing;
+    }
+    this.trackLaneIds.push(trackId);
+    this.syncMixer();
+    return this.trackLaneIds.length - 1;
+  }
+  ensureBus(busId) {
+    const resolved = Math.trunc(busId);
+    if (!Number.isInteger(resolved) || resolved <= 0) {
+      throw new Error(`Invalid bus id for mixer bus: ${String(busId)}`);
+    }
+    const existing = this.buses.findIndex((bus) => bus.busId === resolved);
+    if (existing >= 0) {
+      return existing;
+    }
+    this.buses.push({ busId: resolved });
+    this.syncMixer();
+    return this.buses.length - 1;
+  }
   curveCode(curve) {
     if (typeof curve === "number") {
       return curve;
     }
     return curve === "exponential" ? 1 : 0;
   }
-  ppqToApproxSample(ppq) {
-    return Math.max(0, Math.round(ppq * 60 / 120 * this.sampleRate));
-  }
 };
 var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChangerWorkletProcessor {
   constructor(options = {}) {
@@ -2905,23 +4012,33 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
   class RegisteredSonareRealtimeEngineWorkletProcessor extends Base {
     constructor(options) {
       super();
+      this.pendingMessages = [];
       const port = this.port;
       const processorOptions = options?.processorOptions ?? {};
       if (processorOptions.runtimeTarget === "sonare-rt") {
         void this.initializeSonareRt(processorOptions, port);
       } else {
-        this.bridge = new SonareRealtimeEngineWorkletProcessor(processorOptions, {
-          postMessage: (message) => port?.postMessage?.(message),
-          onMeter: (meter) => port?.postMessage?.(meter)
-        });
+        void this.initializeEmbind(processorOptions, port);
       }
       const onMessage = (event) => {
+        if (!this.bridge && !this.rtBridge) {
+          if (this.pendingMessages.length < 1024) {
+            this.pendingMessages.push(event.data);
+          }
+          return;
+        }
         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);
+        } else if (isEngineCaptureRequestMessage(event.data)) {
+          this.bridge?.receiveCaptureRequest(event.data);
+          this.rtBridge?.receiveCaptureRequest(event.data, port);
+        } else if (isEngineTransportRequestMessage(event.data)) {
+          this.bridge?.receiveTransportRequest(event.data);
+          this.rtBridge?.receiveTransportRequest(event.data, port);
         }
       };
       if (port?.addEventListener) {
@@ -2944,6 +4061,60 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
       }
       return true;
     }
+    replayPendingMessages(port) {
+      const messages = this.pendingMessages.splice(0);
+      for (const data of messages) {
+        if (isEngineCommandRecord(data)) {
+          this.bridge?.receiveCommand(data);
+          this.rtBridge?.receiveCommand(data);
+        } else if (isEngineSyncMessage(data)) {
+          this.bridge?.receiveSync(data);
+          this.rtBridge?.receiveSync(data);
+        } else if (isEngineCaptureRequestMessage(data)) {
+          this.bridge?.receiveCaptureRequest(data);
+          this.rtBridge?.receiveCaptureRequest(data, port);
+        } else if (isEngineTransportRequestMessage(data)) {
+          this.bridge?.receiveTransportRequest(data);
+          this.rtBridge?.receiveTransportRequest(data, port);
+        }
+      }
+    }
+    async initializeEmbind(options, port) {
+      try {
+        const initPromise2 = globalThis.SonareEmbindInitPromise;
+        if (initPromise2) {
+          await initPromise2;
+        }
+        if (!isInitialized()) {
+          const moduleFactory = globalThis.SonareEmbindModuleFactory;
+          if (!moduleFactory) {
+            throw new Error("embind realtime engine module is not initialized.");
+          }
+          await init({
+            locateFile: (path) => path,
+            wasmBinary: options.wasmBinary,
+            moduleFactory
+          });
+        }
+        this.bridge = new SonareRealtimeEngineWorkletProcessor(options, {
+          postMessage: (message) => port?.postMessage?.(message),
+          onMeter: (meter) => port?.postMessage?.(meter)
+        });
+        for (const message of options.initialSyncMessages ?? []) {
+          this.bridge.receiveSync(message);
+        }
+        for (const command of options.initialCommands ?? []) {
+          this.bridge.receiveCommand(command);
+        }
+        this.replayPendingMessages(port);
+        port?.postMessage?.({ type: "ready", runtimeTarget: "embind" });
+      } catch (error) {
+        port?.postMessage?.({
+          type: "error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
     async initializeSonareRt(options, port) {
       try {
         if (!options.rtModuleUrl) {
@@ -2969,6 +4140,7 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
           telemetrySharedBuffer: options.telemetrySharedBuffer,
           telemetryRingCapacity: options.telemetryRingCapacity
         });
+        this.replayPendingMessages(port);
         port?.postMessage?.({ type: "ready", runtimeTarget: "sonare-rt" });
       } catch (error) {
         port?.postMessage?.({