@libraz/libsonare 1.3.2 → 1.4.0

package/dist/worklet.js

@@ -1,3 +1,58 @@
+// src/codes.ts
+function automationCurveCode(curve) {
+  switch (curve) {
+    case "linear":
+      return 0;
+    case "exponential":
+      return 1;
+    case "hold":
+      return 2;
+    case "s-curve":
+      return 3;
+    default:
+      throw new Error(`Invalid automation curve: ${curve}`);
+  }
+}
+function panLawCode(panLaw) {
+  if (typeof panLaw === "number") {
+    return panLaw;
+  }
+  switch (panLaw) {
+    case "const4.5dB":
+      return 1;
+    case "const6dB":
+      return 2;
+    case "linear0dB":
+      return 3;
+    default:
+      return 0;
+  }
+}
+function panModeCode(panMode) {
+  if (typeof panMode === "number") {
+    return panMode;
+  }
+  switch (panMode) {
+    case "stereoPan":
+    case "stereo-pan":
+      return 1;
+    case "dualPan":
+    case "dual-pan":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function meterTapCode(tap) {
+  return tap === "preFader" || tap === 0 ? 0 : 1;
+}
+function sendTimingCode(timing) {
+  if (typeof timing === "number") {
+    return timing;
+  }
+  return timing === "preFader" ? 1 : 0;
+}
+
 // src/errors.ts
 var SonareError = class extends Error {
   constructor(code, codeName, message) {
@@ -39,6 +94,7 @@ function makeSonareError(raw, thrown) {
 }
 function wrapModuleErrors(raw) {
   const cache = /* @__PURE__ */ new Map();
+  const objectCache = /* @__PURE__ */ new WeakMap();
   const convert = (error) => {
     const ptr = nativeExceptionPtr(error);
     if (ptr !== null) {
@@ -46,6 +102,83 @@ function wrapModuleErrors(raw) {
     }
     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);
@@ -56,23 +189,7 @@ function wrapModuleErrors(raw) {
       if (cached) {
         return cached;
       }
-      const fn = value;
-      const wrapped = new Proxy(fn, {
-        apply(t, thisArg, args) {
-          try {
-            return Reflect.apply(t, thisArg, args);
-          } catch (error) {
-            return convert(error);
-          }
-        },
-        construct(t, args, newTarget) {
-          try {
-            return Reflect.construct(t, args, newTarget);
-          } catch (error) {
-            return convert(error);
-          }
-        }
-      });
+      const wrapped = wrapFunction(value);
       cache.set(prop, wrapped);
       return wrapped;
     }
@@ -88,58 +205,6 @@ function getSonareModule() {
   return wrappedModule;
 }
 
-// src/codes.ts
-function automationCurveCode(curve) {
-  switch (curve) {
-    case "linear":
-      return 0;
-    case "exponential":
-      return 1;
-    case "hold":
-      return 2;
-    case "s-curve":
-      return 3;
-    default:
-      throw new Error(`Invalid automation curve: ${curve}`);
-  }
-}
-function panLawCode(panLaw) {
-  if (typeof panLaw === "number") {
-    return panLaw;
-  }
-  switch (panLaw) {
-    case "const4.5dB":
-      return 1;
-    case "const6dB":
-      return 2;
-    case "linear0dB":
-      return 3;
-    default:
-      return 0;
-  }
-}
-function panModeCode(panMode) {
-  if (typeof panMode === "number") {
-    return panMode;
-  }
-  switch (panMode) {
-    case "stereoPan":
-    case "stereo-pan":
-      return 1;
-    case "dualPan":
-    case "dual-pan":
-      return 2;
-    default:
-      return 0;
-  }
-}
-function meterTapCode(tap) {
-  return tap === "preFader" || tap === 0 ? 0 : 1;
-}
-function sendTimingCode(timing) {
-  return timing === "preFader" || timing === 0 ? 0 : 1;
-}
-
 // src/mixer.ts
 var Mixer = class _Mixer {
   constructor(mixer) {
@@ -390,6 +455,13 @@ var Mixer = class _Mixer {
   setDualPan(stripIndex, leftPan, rightPan) {
     this.mixer.setDualPan(stripIndex, leftPan, rightPan);
   }
+  /**
+   * Set the strip's surround pan position, used when it feeds a >2-channel bus.
+   * Stored on the scene; inert until the surround DSP path applies it.
+   */
+  setSurroundPan(stripIndex, pan) {
+    this.mixer.setSurroundPan(stripIndex, pan);
+  }
   /**
    * Add a send to a strip after construction.
    *
@@ -732,9 +804,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();
@@ -761,8 +830,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`
@@ -774,7 +849,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
@@ -783,7 +858,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
@@ -795,13 +870,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
@@ -809,7 +884,7 @@ var RealtimeEngine = class {
    * mapped into [minValue, maxValue] for `paramId`.
    */
   bindMidiCc(channel, controller, paramId, options = {}) {
-    this.nativeExt().bindMidiCc(
+    this.native.bindMidiCc(
       channel,
       controller,
       paramId,
@@ -818,42 +893,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
@@ -862,21 +937,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() {
@@ -891,15 +966,33 @@ var RealtimeEngine = class {
   seekSample(timelineSample, renderFrame = -1) {
     this.native.seekSample(timelineSample, renderFrame);
   }
+  /**
+   * Snaps every in-flight parameter ramp (engine-level smoothed params, mixer
+   * lane fader/pan/gate, bus gains) to its target value. Offline renders call
+   * this after a priming process() block so the first audible block renders at
+   * settled values instead of ramping in from defaults.
+   */
+  settleParameters() {
+    this.native.settleParameters();
+  }
   seekPpq(ppq, renderFrame = -1) {
     this.native.seekPpq(ppq, renderFrame);
   }
   setTempo(bpm) {
     this.native.setTempo(bpm);
   }
+  setTempoSegments(segments) {
+    this.native.setTempoSegments([...segments]);
+  }
   setTimeSignature(numerator, denominator) {
     this.native.setTimeSignature(numerator, denominator);
   }
+  setTimeSignatureSegments(segments) {
+    this.native.setTimeSignatureSegments([...segments]);
+  }
+  sampleAtPpq(ppq) {
+    return Number(this.native.sampleAtPpq(ppq));
+  }
   setLoop(startPpq, endPpq, enabled = true) {
     this.native.setLoop(startPpq, endPpq, enabled);
   }
@@ -968,21 +1061,140 @@ var RealtimeEngine = class {
   clipCount() {
     return this.native.clipCount();
   }
+  setTrackLanes(lanes) {
+    this.native.setTrackLanes(
+      lanes.map((lane) => {
+        if (typeof lane === "number") {
+          return { trackId: lane };
+        }
+        if (!lane.sends) {
+          return lane;
+        }
+        return {
+          ...lane,
+          sends: lane.sends.map((send) => ({
+            ...send,
+            // Post-fader (0) is the default for an omitted sendTiming.
+            sendTiming: send.sendTiming === void 0 ? 0 : sendTimingCode(send.sendTiming)
+          }))
+        };
+      })
+    );
+  }
+  /**
+   * Keys one insert of a lane strip from another lane's post-strip audio
+   * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+   */
+  setLaneSidechain(trackId, insertIndex, sourceTrackId) {
+    this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+  }
+  setTrackBuses(buses) {
+    this.native.setTrackBuses(buses);
+  }
+  setBusStripJson(busId, sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid bus strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setBusStripJson(busId, sceneJson);
+  }
+  setTrackStripJson(trackId, sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid track strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setTrackStripJson(trackId, sceneJson);
+  }
+  setTrackStripEqBand(trackId, bandIndex, band) {
+    this.native.setTrackStripEqBandJson(
+      trackId,
+      bandIndex,
+      typeof band === "string" ? band : JSON.stringify(band)
+    );
+  }
+  setTrackStripEqBandJson(trackId, bandIndex, bandJson) {
+    this.native.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+  }
+  setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass = false) {
+    this.native.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
+  }
+  setMasterStripJson(sceneJson) {
+    try {
+      JSON.parse(sceneJson);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid master strip JSON";
+      throw new SonareError(2 /* InvalidFormat */, "InvalidFormat", message);
+    }
+    this.native.setMasterStripJson(sceneJson);
+  }
+  setMasterStripEqBand(bandIndex, band) {
+    this.native.setMasterStripEqBandJson(
+      bandIndex,
+      typeof band === "string" ? band : JSON.stringify(band)
+    );
+  }
+  setMasterStripEqBandJson(bandIndex, bandJson) {
+    this.native.setMasterStripEqBandJson(bandIndex, bandJson);
+  }
+  setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass = false) {
+    this.native.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+  }
+  /**
+   * Changes one track-strip insert parameter in realtime, addressed by the
+   * processor's JSON-key parameter name (see {@link masteringInsertParamInfo}).
+   * Applied at the next block head via the engine command queue; safe during
+   * playback. Throws if the track, insert, or name is unknown, the param is not
+   * realtime-safe, or the command queue is full.
+   */
+  setTrackStripInsertParamByName(trackId, insertIndex, paramName, value) {
+    this.native.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+  }
+  /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
+  setMasterStripInsertParamByName(insertIndex, paramName, value) {
+    this.native.setMasterStripInsertParamByName(insertIndex, paramName, value);
+  }
+  /** Sets a track lane strip's pan position in realtime (glitch-free). */
+  setTrackStripPan(trackId, pan) {
+    this.native.setTrackStripPan(trackId, pan);
+  }
+  /** Sets a track lane strip's pan law in realtime. */
+  setTrackStripPanLaw(trackId, panLaw) {
+    this.native.setTrackStripPanLaw(trackId, panLawCode(panLaw));
+  }
+  /** Sets a track lane strip's pan mode in realtime. */
+  setTrackStripPanMode(trackId, panMode) {
+    this.native.setTrackStripPanMode(trackId, panModeCode(panMode));
+  }
+  /** Sets a track lane strip's dual-pan left/right positions in realtime. */
+  setTrackStripDualPan(trackId, leftPan, rightPan) {
+    this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
+  }
+  /**
+   * Sets a track lane strip's inter-channel alignment delay (whole samples).
+   * Adjusts strip latency, so PDC and reported graph latency are refreshed.
+   */
+  setTrackStripChannelDelaySamples(trackId, delaySamples) {
+    this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
+  }
   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);
@@ -1057,6 +1269,30 @@ var RealtimeEngine = class {
   drainMeterTelemetry(maxRecords = 1024) {
     return this.native.drainMeterTelemetry(maxRecords);
   }
+  /**
+   * Drains pending meter telemetry as per-plane (wide) records for a surround
+   * target. Use this for a surround mix target; {@link drainMeterTelemetry}
+   * stays the stereo fast path. The two share one queue — call only one per
+   * target. The live AudioWorklet path owns the queue via the stereo drain, so
+   * this wide drain is for an offline (non-worklet) engine instance; per-plane
+   * surround meters are not delivered over the live worklet meter ring.
+   */
+  drainMeterTelemetryWide(maxRecords = 1024) {
+    return this.native.drainMeterTelemetryWide(maxRecords);
+  }
+  /**
+   * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
+   * the minimum render-frame gap between snapshots (0 disables). @param bandCount
+   * is the FFT band resolution (1..64); changing it re-prepares the tap. Returns
+   * the band count actually applied.
+   */
+  configureScopeTelemetry(intervalFrames, bandCount) {
+    return this.native.configureScopeTelemetry(intervalFrames, bandCount);
+  }
+  /** Drains pending spectrum + vectorscope snapshots (per mix target). */
+  drainScopeTelemetry(maxRecords = 1024) {
+    return this.native.drainScopeTelemetry(maxRecords);
+  }
   destroy() {
     this.native.delete();
   }
@@ -1100,7 +1336,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) {
@@ -1114,10 +1350,24 @@ function isInitialized() {
   return module !== null;
 }
 
-// src/worklet.ts
+// src/worklet/protocol.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_SCOPE_RING_HEADER_INTS = 6;
+var SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS = 5;
 var SONARE_FRAME_LANE_BASE = 16777216;
 function encodeFrameLo(frame) {
   const f = Math.max(0, Math.floor(frame));
@@ -1176,51 +1426,12 @@ 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;
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
-function isWorkletMessage(value) {
-  if (!isRecord(value) || typeof value.type !== "string") {
-    return false;
-  }
-  return value.type === "scheduleInsertAutomation" || value.type === "setMeterInterval" || value.type === "destroy";
-}
-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;
-  }
-  return value.type === "setConfig" || value.type === "reset" || value.type === "destroy";
-}
-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";
-}
 function sonareMeterRingBufferByteLength(capacity) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   return SONARE_METER_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * SONARE_METER_RING_RECORD_FLOATS * Float32Array.BYTES_PER_ELEMENT;
@@ -1237,19 +1448,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 };
@@ -1298,29 +1517,125 @@ function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
   }
   return { nextReadIndex: writeIndex, spectra };
 }
-function sonareEngineCommandRingBufferByteLength(capacity) {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  return SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * SONARE_ENGINE_COMMAND_RECORD_BYTES;
+function sonareScopeRingRecordFloats(bands, maxPoints) {
+  return SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS + bands + 2 * maxPoints;
 }
-function sonareEngineTelemetryRingBufferByteLength(capacity) {
+function sonareScopeRingBufferByteLength(capacity, bands = 48, maxPoints = 32) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
-  return SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * SONARE_ENGINE_TELEMETRY_RECORD_BYTES;
+  const clampedBands = Math.max(1, Math.floor(bands));
+  const clampedPoints = Math.max(0, Math.floor(maxPoints));
+  return SONARE_SCOPE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * sonareScopeRingRecordFloats(clampedBands, clampedPoints) * Float32Array.BYTES_PER_ELEMENT;
 }
-function createSonareEngineCommandRingBuffer(capacity = 128) {
+function createSonareScopeRingBuffer(capacity = 64, bands = 48, maxPoints = 32) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
+  const clampedBands = Math.max(1, Math.floor(bands));
+  const clampedPoints = Math.max(0, Math.floor(maxPoints));
   const sharedBuffer = new SharedArrayBuffer(
-    sonareEngineCommandRingBufferByteLength(clampedCapacity)
+    sonareScopeRingBufferByteLength(clampedCapacity, clampedBands, clampedPoints)
   );
-  const ring = engineRingFromSharedBuffer(
+  const ring = scopeRingFromSharedBuffer(
     sharedBuffer,
-    SONARE_ENGINE_COMMAND_RECORD_BYTES,
-    clampedCapacity
+    clampedCapacity,
+    clampedBands,
+    clampedPoints
   );
-  return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
-}
-function createSonareEngineTelemetryRingBuffer(capacity = 128) {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const sharedBuffer = new SharedArrayBuffer(
+  Atomics.store(ring.header, 0, 0);
+  Atomics.store(ring.header, 1, clampedCapacity);
+  Atomics.store(ring.header, 2, ring.recordFloats);
+  Atomics.store(ring.header, 3, clampedBands);
+  Atomics.store(ring.header, 4, clampedPoints);
+  Atomics.store(ring.header, 5, 0);
+  return {
+    sharedBuffer,
+    header: ring.header,
+    records: ring.records,
+    capacity: ring.capacity,
+    bands: ring.bands,
+    maxPoints: ring.maxPoints
+  };
+}
+function readSonareScopeRingBuffer(ring, readIndex = 0) {
+  const writeIndex = Atomics.load(ring.header, 0);
+  const bands = Atomics.load(ring.header, 3) || ring.bands;
+  const maxPoints = Atomics.load(ring.header, 4);
+  const recordFloats = Atomics.load(ring.header, 2) || sonareScopeRingRecordFloats(bands, maxPoints);
+  const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
+  const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
+  const scopes = [];
+  for (let index = firstReadable; index < writeIndex; index++) {
+    const offset = index % ring.capacity * recordFloats;
+    const bandCount = Math.min(bands, Math.max(0, ring.records[offset + 3]));
+    const pointCount = Math.min(maxPoints, Math.max(0, ring.records[offset + 4]));
+    const bandsView = new Float32Array(bandCount);
+    bandsView.set(
+      ring.records.subarray(
+        offset + SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS,
+        offset + SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS + bandCount
+      )
+    );
+    const pointsBase = offset + SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS + bands;
+    const pointsView = new Float32Array(pointCount * 2);
+    pointsView.set(ring.records.subarray(pointsBase, pointsBase + pointCount * 2));
+    scopes.push({
+      type: "scope",
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 1]),
+      targetId: ring.records[offset + 2],
+      bands: bandsView,
+      points: pointsView
+    });
+  }
+  return { nextReadIndex: writeIndex, scopes };
+}
+function scopeRingFromSharedBuffer(sharedBuffer, fallbackCapacity, fallbackBands, fallbackMaxPoints) {
+  const headerBytes = SONARE_SCOPE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
+  const header = new Int32Array(sharedBuffer, 0, SONARE_SCOPE_RING_HEADER_INTS);
+  const existingCapacity = Atomics.load(header, 1);
+  const existingBands = Atomics.load(header, 3);
+  const existingMaxPoints = Atomics.load(header, 4);
+  const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
+  const bands = Math.max(1, Math.floor(existingBands || fallbackBands || 48));
+  const maxPoints = Math.max(0, Math.floor(existingMaxPoints || (fallbackMaxPoints ?? 32)));
+  const recordFloats = sonareScopeRingRecordFloats(bands, maxPoints);
+  const minBytes = sonareScopeRingBufferByteLength(capacity, bands, maxPoints);
+  if (sharedBuffer.byteLength < minBytes) {
+    throw new Error("scopeSharedBuffer is too small for the requested ring capacity.");
+  }
+  Atomics.store(header, 1, capacity);
+  Atomics.store(header, 2, recordFloats);
+  Atomics.store(header, 3, bands);
+  Atomics.store(header, 4, maxPoints);
+  return {
+    header,
+    records: new Float32Array(sharedBuffer, headerBytes, capacity * recordFloats),
+    capacity,
+    bands,
+    maxPoints,
+    recordFloats
+  };
+}
+function sonareEngineCommandRingBufferByteLength(capacity) {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  return SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * SONARE_ENGINE_COMMAND_RECORD_BYTES;
+}
+function sonareEngineTelemetryRingBufferByteLength(capacity) {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  return SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * SONARE_ENGINE_TELEMETRY_RECORD_BYTES;
+}
+function createSonareEngineCommandRingBuffer(capacity = 128) {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  const sharedBuffer = new SharedArrayBuffer(
+    sonareEngineCommandRingBufferByteLength(clampedCapacity)
+  );
+  const ring = engineRingFromSharedBuffer(
+    sharedBuffer,
+    SONARE_ENGINE_COMMAND_RECORD_BYTES,
+    clampedCapacity
+  );
+  return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
+}
+function createSonareEngineTelemetryRingBuffer(capacity = 128) {
+  const clampedCapacity = Math.max(1, Math.floor(capacity));
+  const sharedBuffer = new SharedArrayBuffer(
     sonareEngineTelemetryRingBufferByteLength(clampedCapacity)
   );
   const ring = engineRingFromSharedBuffer(
@@ -1509,17 +1824,81 @@ 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) {
   return value > 1e-12 ? 20 * Math.log10(value) : -120;
 }
+
+// src/worklet/guards.ts
+function isWorkletMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  return value.type === "scheduleInsertAutomation" || value.type === "setMeterInterval" || value.type === "destroy";
+}
+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 === "syncClipsDelta" || value.type === "syncMidiClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation" || value.type === "syncTempo" || value.type === "syncMixer" || value.type === "syncCapture" || value.type === "syncTrackStripEqBand" || value.type === "syncMasterStripEqBand" || value.type === "syncTrackStripInsertBypassed" || value.type === "syncMasterStripInsertBypassed" || value.type === "syncTrackStripInsertParamByName" || value.type === "syncMasterStripInsertParamByName" || value.type === "syncTrackStripPan" || value.type === "syncTrackStripPanLaw" || value.type === "syncTrackStripPanMode" || value.type === "syncTrackStripDualPan" || value.type === "syncTrackStripChannelDelaySamples" || value.type === "syncBuiltinInstrument" || value.type === "syncSynthInstrument" || value.type === "syncSf2Instrument" || value.type === "syncLoadSoundFont" || value.type === "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") {
+    return false;
+  }
+  return value.type === "setConfig" || value.type === "reset" || value.type === "destroy";
+}
+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" && (typeof value.targetId === "number" || value.targetId === void 0);
+}
+
+// src/worklet/messages.ts
+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
+  };
+}
+
+// src/worklet.ts
 var SonareWorkletProcessor = class {
   constructor(options, transport) {
     this.closed = false;
@@ -1669,12 +2048,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) {
@@ -1691,12 +2077,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) {
@@ -1761,6 +2154,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));
@@ -1778,12 +2172,21 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       options.telemetryRingCapacity
     ) : void 0;
     this.meterRing = options.meterSharedBuffer ? meterRingFromSharedBuffer(options.meterSharedBuffer, options.meterRingCapacity) : void 0;
+    this.scopeRing = options.scopeSharedBuffer ? scopeRingFromSharedBuffer(
+      options.scopeSharedBuffer,
+      options.scopeRingCapacity,
+      options.scopeBands
+    ) : void 0;
     this.engine = new RealtimeEngine(this.sampleRate, this.blockSize);
     this.engine.prepareChannels(this.channelCount, this.blockSize);
     this.channelBuffers = new Array(this.channelCount);
     for (let ch = 0; ch < this.channelCount; ch++) {
       this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
     }
+    if (this.scopeRing) {
+      const interval = Math.max(1, Math.floor(options.scopeIntervalFrames ?? this.blockSize));
+      this.engine.configureScopeTelemetry(interval, this.scopeRing.bands);
+    }
   }
   process(inputs, outputs) {
     if (this.closed) {
@@ -1841,6 +2244,7 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     }
     this.publishTelemetry();
     this.publishMeters();
+    this.publishScope();
     return true;
   }
   reacquireChannelBuffers() {
@@ -1864,8 +2268,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;
@@ -1876,6 +2300,217 @@ 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);
+        }
+        for (const binding of message.laneSidechains ?? []) {
+          this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
+        }
+        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 "syncTrackStripInsertParamByName":
+        this.engine.setTrackStripInsertParamByName(
+          message.trackId,
+          message.insertIndex,
+          message.paramName,
+          message.value
+        );
+        break;
+      case "syncMasterStripInsertParamByName":
+        this.engine.setMasterStripInsertParamByName(
+          message.insertIndex,
+          message.paramName,
+          message.value
+        );
+        break;
+      case "syncTrackStripPan":
+        this.engine.setTrackStripPan(message.trackId, message.pan);
+        break;
+      case "syncTrackStripPanLaw":
+        this.engine.setTrackStripPanLaw(message.trackId, message.panLaw);
+        break;
+      case "syncTrackStripPanMode":
+        this.engine.setTrackStripPanMode(message.trackId, message.panMode);
+        break;
+      case "syncTrackStripDualPan":
+        this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
+        break;
+      case "syncTrackStripChannelDelaySamples":
+        this.engine.setTrackStripChannelDelaySamples(message.trackId, message.delaySamples);
+        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() {
@@ -1956,6 +2591,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 */,
@@ -1981,16 +2624,29 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     }
     this.transport?.postMessage?.(record);
   }
+  // Drains the engine meter telemetry queue into the stereo meter ring / transport.
+  //
+  // Shared-queue contract: `drainMeterTelemetry` and `drainMeterTelemetryWide`
+  // pop the SAME single-consumer telemetry queue, so exactly ONE of them may run
+  // per engine. The live worklet path owns the queue via the stereo drain below;
+  // the worklet meter ring (SONARE_METER_RING_RECORD_FLOATS) is a fixed stereo
+  // layout carrying planes 0/1 plus the correlation/LUFS summary. Per-plane
+  // surround meters are NOT delivered over the live worklet ring — a host that
+  // needs them must use the offline `drainMeterTelemetryWide()` API on a
+  // non-worklet engine instance (do not also call it on a worklet-driven engine,
+  // or the two drains will starve each other).
   publishMeters() {
     if (this.meterIntervalFrames <= 0 || !this.transport && !this.meterRing) {
       return;
     }
     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 {
@@ -2007,12 +2663,54 @@ 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);
+  }
+  // Drains the engine's scope producer (FFT spectrum + goniometer points) into
+  // the lock-free SAB scope ring. Only the embind runtime publishes scope
+  // telemetry; the sonare-rt runtime owns its own transport. No allocation on
+  // the render path: records are written field-by-field into the ring.
+  publishScope() {
+    const ring = this.scopeRing;
+    if (!ring) {
+      return;
+    }
+    for (const item of this.engine.drainScopeTelemetry(64)) {
+      this.writeScopeRing(ring, item);
+    }
+  }
+  writeScopeRing(ring, record) {
+    const writeIndex = Atomics.load(ring.header, 0);
+    const base = writeIndex % ring.capacity * ring.recordFloats;
+    ring.records[base] = encodeFrameLo(record.renderFrame);
+    ring.records[base + 1] = encodeFrameHi(record.renderFrame);
+    ring.records[base + 2] = record.targetId;
+    const bandCount = Math.min(ring.bands, record.bands.length);
+    ring.records[base + 3] = bandCount;
+    const pointCount = Math.min(ring.maxPoints, record.points.length);
+    ring.records[base + 4] = pointCount;
+    const bandsBase = base + SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS;
+    for (let i = 0; i < bandCount; i++) {
+      ring.records[bandsBase + i] = record.bands[i];
+    }
+    const pointsBase = bandsBase + ring.bands;
+    for (let i = 0; i < pointCount; i++) {
+      const point = record.points[i];
+      ring.records[pointsBase + 2 * i] = point.left;
+      ring.records[pointsBase + 2 * i + 1] = point.right;
+    }
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
   commandRingFromSharedBuffer(sharedBuffer, fallbackCapacity) {
@@ -2144,9 +2842,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 */,
@@ -2161,6 +2878,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;
@@ -2333,26 +3072,53 @@ var SonareRtRealtimeEngineRuntime = class {
   }
 };
 var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
-  constructor(node, capabilities, commandRing, telemetryRing, meterRing) {
+  constructor(node, capabilities, commandRing, telemetryRing, meterRing, scopeRing) {
     this.telemetryReadIndex = 0;
     this.meterReadIndex = 0;
+    this.scopeReadIndex = 0;
     this.telemetryListeners = /* @__PURE__ */ new Set();
     this.meterListeners = /* @__PURE__ */ new Set();
+    this.scopeListeners = /* @__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;
     this.commandRing = commandRing;
     this.telemetryRing = telemetryRing;
     this.meterRing = meterRing;
+    this.scopeRing = scopeRing;
     this.ready = new Promise((resolve, reject) => {
       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);
@@ -2393,6 +3159,8 @@ 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 scopeIntervalFrames = Math.max(0, Math.floor(options.scopeIntervalFrames ?? 0));
+    const scopeRing = mode === "sab" && runtimeTarget === "embind" && scopeIntervalFrames > 0 ? createSonareScopeRingBuffer(options.scopeRingCapacity ?? 64, options.scopeBands ?? 48) : void 0;
     const channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
     const processorOptions = {
       runtimeTarget,
@@ -2406,7 +3174,14 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       telemetrySharedBuffer: telemetryRing?.sharedBuffer,
       telemetryRingCapacity: telemetryRing?.capacity,
       meterSharedBuffer: meterRing?.sharedBuffer,
-      meterRingCapacity: meterRing?.capacity
+      meterRingCapacity: meterRing?.capacity,
+      scopeSharedBuffer: scopeRing?.sharedBuffer,
+      scopeRingCapacity: scopeRing?.capacity,
+      scopeBands: scopeRing?.bands,
+      scopeIntervalFrames: scopeRing ? scopeIntervalFrames : void 0,
+      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, {
@@ -2426,11 +3201,13 @@ 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,
-      meterRing
+      meterRing,
+      scopeRing
     );
   }
   play(sampleTime = -1) {
@@ -2463,6 +3240,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 [];
@@ -2488,6 +3291,20 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     }
     return read.meters;
   }
+  // Drains scope telemetry (FFT spectrum + goniometer points) published into the
+  // SAB scope ring and forwards each record to onScope listeners. A no-op unless
+  // the node was created with scopeIntervalFrames > 0 (embind SAB mode).
+  pollScope() {
+    if (!this.scopeRing) {
+      return [];
+    }
+    const read = readSonareScopeRingBuffer(this.scopeRing, this.scopeReadIndex);
+    this.scopeReadIndex = read.nextReadIndex;
+    for (const scope of read.scopes) {
+      this.emitScope(scope);
+    }
+    return read.scopes;
+  }
   onTelemetry(callback) {
     this.telemetryListeners.add(callback);
     return () => {
@@ -2500,6 +3317,12 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       this.meterListeners.delete(callback);
     };
   }
+  onScope(callback) {
+    this.scopeListeners.add(callback);
+    return () => {
+      this.scopeListeners.delete(callback);
+    };
+  }
   destroy() {
     if (this.destroyed) {
       return;
@@ -2507,8 +3330,17 @@ 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();
+    this.scopeListeners.clear();
   }
   emitTelemetry(telemetry) {
     for (const listener of this.telemetryListeners) {
@@ -2520,14 +3352,57 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       listener(meter);
     }
   }
+  emitScope(scope) {
+    for (const listener of this.scopeListeners) {
+      listener(scope);
+    }
+  }
+  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.trackOutputBus = /* @__PURE__ */ new Map();
+    this.laneSidechains = /* @__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;
@@ -2538,8 +3413,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);
@@ -2550,6 +3438,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)
     };
   }
@@ -2584,13 +3473,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({
@@ -2601,6 +3514,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);
@@ -2623,6 +3547,64 @@ var SonareEngine = class _SonareEngine {
   addAutomationPoint(laneId, ppq, value, curve = "linear") {
     this.scheduleParam("", laneId, ppq, value, curve);
   }
+  /**
+   * Replaces the automation lane for `paramId` with the given breakpoints.
+   *
+   * Unlike scheduleParam (which appends a single point), this sets the whole
+   * lane at once; an empty array clears the lane. The points are defensively
+   * copied and sorted by ppq before being mirrored to the offline engine and
+   * the live worklet engine.
+   *
+   * @param paramId Automation target id (registered parameter or a reserved
+   *   engine mixer target from automationParamId/busAutomationParamId).
+   * @param points Lane breakpoints; order does not matter.
+   */
+  setAutomationLane(paramId, points) {
+    const sorted = points.map((point) => ({ ...point })).sort((a, b) => a.ppq - b.ppq);
+    if (sorted.length === 0) {
+      this.automationLanes.delete(paramId);
+    } else {
+      this.automationLanes.set(paramId, sorted);
+    }
+    this.offlineEngine.setAutomationLane(paramId, sorted);
+    this.postSync({ type: "syncAutomation", paramId, points: sorted });
+  }
+  /**
+   * Returns the automation target id for a mixer strip parameter.
+   *
+   * The id addresses the engine's reserved mixer namespace, so it can be fed
+   * straight to setAutomationLane to automate a fader or pan without
+   * registering a parameter.
+   *
+   * @param target Track id (declares a mixer lane on first use) or 'master'.
+   * @param kind Strip parameter to address.
+   * @returns Reserved engine parameter id for the strip parameter.
+   */
+  automationParamId(target, kind) {
+    const paramKind = kind === "pan" ? ENGINE_MIXER_PARAM_PAN : ENGINE_MIXER_PARAM_FADER_DB;
+    if (target === "master") {
+      return engineMixerMasterTarget(paramKind);
+    }
+    return engineMixerLaneTarget(this.ensureTrackLane(target), paramKind);
+  }
+  /**
+   * Returns the automation target id for a bus fader.
+   *
+   * @param busId Bus id (declares the mixer bus on first use).
+   * @returns Reserved engine parameter id for the bus fader gain (dB).
+   */
+  busAutomationParamId(busId) {
+    return engineMixerBusTarget(this.ensureBus(busId), ENGINE_MIXER_PARAM_FADER_DB);
+  }
+  /**
+   * Returns the number of automation lanes installed on the engine, including
+   * lanes whose breakpoint list is currently empty.
+   *
+   * @returns Engine-side automation lane count.
+   */
+  automationLaneCount() {
+    return this.offlineEngine.automationLaneCount();
+  }
   listParameters() {
     const parameters = [];
     for (let index = 0; index < this.offlineEngine.parameterCount(); index++) {
@@ -2631,12 +3613,300 @@ 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 }))
+        );
+      }
+      if (entry.outputBusId !== void 0) {
+        if (entry.outputBusId === 0) {
+          this.trackOutputBus.delete(entry.trackId);
+        } else {
+          this.trackOutputBus.set(entry.trackId, entry.outputBusId);
+        }
+      }
+    }
+    this.trackLaneIds.splice(0, this.trackLaneIds.length, ...ids);
+    this.syncMixer();
+  }
+  /**
+   * Routes a track lane's post-fader output into a declared bus instead of
+   * the master mix (group/folder routing); busId 0 restores the master mix.
+   */
+  setTrackOutputBus(target, busId) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    if (busId === 0) {
+      this.trackOutputBus.delete(trackId);
+    } else {
+      this.trackOutputBus.set(trackId, busId);
+    }
+    this.syncMixer();
+  }
+  /**
+   * Keys one insert of a lane strip from another lane's post-strip pre-fader
+   * audio (ducking/sidechainRouter inserts). sourceTarget null removes the
+   * binding.
+   */
+  setLaneSidechain(target, insertIndex, sourceTarget) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    const key = `${trackId}:${insertIndex}`;
+    let sourceTrackId = 0;
+    if (sourceTarget !== null) {
+      const sourceIndex = this.ensureTrackLane(sourceTarget);
+      sourceTrackId = this.trackLaneIds[sourceIndex];
+    }
+    if (sourceTrackId === 0) {
+      this.laneSidechains.delete(key);
+    } else {
+      this.laneSidechains.set(key, { trackId, insertIndex, sourceTrackId });
+    }
+    this.offlineEngine.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+    this.postSync({
+      type: "syncMixer",
+      lanes: this.mixerLanes(),
+      laneSidechains: [{ trackId, insertIndex, sourceTrackId }]
+    });
+  }
+  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
+    });
+  }
+  setTrackStripInsertParamByName(target, insertIndex, paramName, value) {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+    this.postSync({
+      type: "syncTrackStripInsertParamByName",
+      trackId,
+      insertIndex,
+      paramName,
+      value
+    });
+  }
+  setTrackStripPan(target, pan) {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripPan(trackId, pan);
+    this.postSync({ type: "syncTrackStripPan", trackId, pan });
+  }
+  setTrackStripPanLaw(target, panLaw) {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    const code = panLawCode(panLaw);
+    this.offlineEngine.setTrackStripPanLaw(trackId, code);
+    this.postSync({ type: "syncTrackStripPanLaw", trackId, panLaw: code });
+  }
+  setTrackStripPanMode(target, panMode) {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    const code = panModeCode(panMode);
+    this.offlineEngine.setTrackStripPanMode(trackId, code);
+    this.postSync({ type: "syncTrackStripPanMode", trackId, panMode: code });
+  }
+  setTrackStripDualPan(target, leftPan, rightPan) {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripDualPan(trackId, leftPan, rightPan);
+    this.postSync({ type: "syncTrackStripDualPan", trackId, leftPan, rightPan });
+  }
+  setTrackStripChannelDelaySamples(target, delaySamples) {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripChannelDelaySamples(trackId, delaySamples);
+    this.postSync({ type: "syncTrackStripChannelDelaySamples", trackId, delaySamples });
+  }
+  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
+    });
+  }
+  setMasterStripInsertParamByName(insertIndex, paramName, value) {
+    this.offlineEngine.setMasterStripInsertParamByName(insertIndex, paramName, value);
+    this.postSync({
+      type: "syncMasterStripInsertParamByName",
+      insertIndex,
+      paramName,
+      value
+    });
+  }
+  setStripInsertParamByName(target, insertIndex, paramName, value) {
+    if (target === "master") {
+      this.setMasterStripInsertParamByName(insertIndex, paramName, value);
+      return;
+    }
+    this.setTrackStripInsertParamByName(target, insertIndex, paramName, value);
+  }
+  setMasterChain(sceneJson) {
+    this.setMasterStripJson(sceneJson);
   }
   addClip(trackId, buffer, startPpq, opts = {}) {
     const id = opts.id ?? this.nextClipId++;
@@ -2644,18 +3914,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 */,
@@ -2665,8 +4025,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 */,
@@ -2675,6 +4035,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 });
@@ -2690,6 +4060,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({
@@ -2698,6 +4117,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 = [];
@@ -2709,6 +4134,9 @@ var SonareEngine = class _SonareEngine {
   onMeter(callback) {
     return this.realtimeNode.onMeter(callback);
   }
+  onScope(callback) {
+    return this.realtimeNode.onScope(callback);
+  }
   onTelemetry(callback) {
     return this.realtimeNode.onTelemetry(callback);
   }
@@ -2718,6 +4146,9 @@ var SonareEngine = class _SonareEngine {
   pollMeters() {
     return this.realtimeNode.pollMeters();
   }
+  pollScope() {
+    return this.realtimeNode.pollScope();
+  }
   destroy() {
     if (this.destroyed) {
       return;
@@ -2728,16 +4159,89 @@ 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 });
+  }
+  mixerLanes() {
+    return this.trackLaneIds.map((trackId) => {
+      const sends = this.trackSends.get(trackId);
+      const outputBusId = this.trackOutputBus.get(trackId);
+      return {
+        trackId,
+        ...sends && sends.length > 0 ? { sends: sends.map((send) => ({ ...send })) } : {},
+        ...outputBusId !== void 0 ? { outputBusId } : {}
+      };
+    });
+  }
+  syncMixer() {
+    const lanes = this.mixerLanes();
+    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,
+      laneSidechains: Array.from(this.laneSidechains.values()),
+      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).
@@ -2764,15 +4268,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 = {}) {
@@ -2993,23 +4520,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) {
@@ -3032,6 +4569,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) {
@@ -3057,6 +4648,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?.({
@@ -3074,6 +4666,7 @@ export {
   SONARE_ENGINE_TELEMETRY_RECORD_BYTES,
   SONARE_METER_RING_HEADER_INTS,
   SONARE_METER_RING_RECORD_FLOATS,
+  SONARE_SCOPE_RING_HEADER_INTS,
   SONARE_SPECTRUM_RING_HEADER_INTS,
   SonareEngine,
   SonareEngineCommandType,
@@ -3087,6 +4680,7 @@ export {
   createSonareEngineCommandRingBuffer,
   createSonareEngineTelemetryRingBuffer,
   createSonareMeterRingBuffer,
+  createSonareScopeRingBuffer,
   createSonareSpectrumRingBuffer,
   decodeFrame,
   encodeFrameHi,
@@ -3097,6 +4691,7 @@ export {
   pushSonareEngineCommandRingBuffer,
   readSonareEngineTelemetryRingBuffer,
   readSonareMeterRingBuffer,
+  readSonareScopeRingBuffer,
   readSonareSpectrumRingBuffer,
   registerSonareRealtimeEngineWorkletProcessor,
   registerSonareRealtimeVoiceChangerWorkletProcessor,
@@ -3104,6 +4699,7 @@ export {
   sonareEngineCommandRingBufferByteLength,
   sonareEngineTelemetryRingBufferByteLength,
   sonareMeterRingBufferByteLength,
+  sonareScopeRingBufferByteLength,
   sonareSpectrumRingBufferByteLength,
   writeSonareEngineTelemetryRingBuffer
 };