@libraz/libsonare 1.7.1 → 1.8.0

package/dist/worklet.js

@@ -400,7 +400,21 @@ var SonareError = class extends Error {
     this.code = code;
     this.codeName = codeName;
   }
+  /**
+   * Brand-based `instanceof`: an error that carries the shape narrows here even
+   * when it is not literally an instance of this class. That is not a
+   * hypothetical — an error posted from the analysis worker arrives as a
+   * structured clone with its prototype gone, which a prototype-based
+   * `instanceof` would silently miss. Delegates to {@link isSonareError} so the
+   * two never disagree.
+   */
+  static [Symbol.hasInstance](value) {
+    return isSonareError(value);
+  }
 };
+function isSonareError(value) {
+  return value instanceof Error && value.name === "SonareError" && typeof value.code === "number";
+}
 
 // src/module_state.ts
 var wrappedModule = null;
@@ -428,6 +442,11 @@ function makeSonareError(raw, thrown) {
       message = info.message || message;
     }
   } catch {
+  } finally {
+    try {
+      raw.sonareReleaseException(thrown);
+    } catch {
+    }
   }
   return new SonareError(code, codeName, message);
 }
@@ -448,6 +467,10 @@ function wrapModuleErrors(raw) {
     if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
       return value;
     }
+    const proto = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || proto === Object.prototype || proto === null) {
+      return value;
+    }
     const objectValue = value;
     const cached = objectCache.get(objectValue);
     if (cached) {
@@ -579,6 +602,10 @@ var AUTOMATION_CURVE_VALUES = {
   hold: 2,
   "s-curve": 3
 };
+var PROJECT_AUTOMATION_CURVE_VALUES = {
+  ...AUTOMATION_CURVE_VALUES,
+  scurve: 3
+};
 var PAN_LAW_VALUES = {
   const3db: 0,
   "const-3db": 0,
@@ -604,6 +631,7 @@ var PAN_MODE_VALUES = {
 };
 var METER_TAP_VALUES = { preFader: 0, postFader: 1 };
 var SEND_TIMING_VALUES = { postFader: 0, preFader: 1 };
+var SIDECHAIN_SOURCE_KIND_VALUES = { track: 0, bus: 1 };
 var TRACK_MONITOR_MODE_VALUES = { off: 0, pfl: 1, afl: 2 };
 function automationCurveCode(curve) {
   return resolveEnumOrdinal(curve, AUTOMATION_CURVE_VALUES, "automation curve");
@@ -622,12 +650,276 @@ function meterTapCode(tap) {
 function sendTimingCode(timing) {
   return resolveEnumOrdinal(timing, SEND_TIMING_VALUES, "send timing");
 }
+function sidechainSourceKindCode(kind) {
+  return resolveEnumOrdinal(kind, SIDECHAIN_SOURCE_KIND_VALUES, "sidechain source kind");
+}
 function trackMonitorModeCode(mode) {
   return resolveEnumOrdinal(mode, TRACK_MONITOR_MODE_VALUES, "track monitor mode");
 }
 
+// src/sample_bank.ts
+var SampleBank = class {
+  /** Create an empty bank. */
+  constructor() {
+    this.released = false;
+    this.native = new (projectModule()).SampleBank();
+    this.nativeId = this.native.id;
+  }
+  /**
+   * Copy mono float frames into the bank and return the new sample's index,
+   * which {@link SampleZoneDesc.sampleIndex} names. The frames are copied, so
+   * the array may be reused afterwards.
+   *
+   * Loop points are clamped inside the sample and a loop mode whose loop
+   * survives the clamp empty is dropped, so a malformed loop plays as an
+   * unlooped sample rather than as a wrap over nothing. An empty array, and a
+   * bank that would exceed 67,108,864 sample points, throw.
+   *
+   * A NaN or Inf frame, `fineTuneCents` or `sourceRate` throws too, and the
+   * bank is left unchanged. Such a value is unattributable once stored: the
+   * reader's interpolation spreads one bad frame across the whole sustain, and
+   * a bad tuning offset renders the voice silent with no error raised.
+   */
+  addSample(data, desc = {}) {
+    return this.native.addSample(data, desc);
+  }
+  /**
+   * Append a key/velocity rectangle to a keymap set, creating any sets below
+   * it. A patch names a set; the first zone in it covering a note is the one
+   * that sounds.
+   *
+   * Every bound defaults on its own (see {@link SampleZoneDesc}), so an empty
+   * rectangle is the whole keyboard at every velocity and narrowing one axis
+   * leaves the other whole. A `sampleIndex` the bank does not have, an inverted
+   * key or velocity range, and a `setIndex` at or above 4096 all throw.
+   */
+  addZone(zone = {}) {
+    const { setIndex, ...rest } = zone;
+    this.native.addZone(setIndex ?? 0, rest);
+  }
+  /** Samples added so far. */
+  sampleCount() {
+    return this.native.sampleCount();
+  }
+  /** Keymap sets the bank has (one past the highest index used). */
+  setCount() {
+    return this.native.setCount();
+  }
+  /** Release the underlying WASM object. Idempotent, as the Node facade is. */
+  delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+  /** Alias for {@link SampleBank.delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
+  }
+};
+
+// src/project_internal.ts
+function normalizeSynthInstrument(patch) {
+  if (patch === null || typeof patch !== "object") {
+    return patch;
+  }
+  const { sampleBank, ...rest } = patch;
+  if (!sampleBank) {
+    return rest;
+  }
+  if (!(sampleBank instanceof SampleBank)) {
+    throw new TypeError("sampleBank must be a SampleBank instance");
+  }
+  if (sampleBank.released) {
+    throw new TypeError("sampleBank is destroyed");
+  }
+  return { ...rest, sampleBankId: sampleBank.nativeId };
+}
+function projectModule() {
+  const candidate = getSonareModule();
+  if (typeof candidate.projectAbiVersion !== "function" || candidate.Project === void 0) {
+    throw new Error("libsonare was built without arrangement (headless DAW) support");
+  }
+  return candidate;
+}
+
+// src/_chain_config.ts
+function flattenChainConfig(config) {
+  const out = {};
+  const walk = (node, prefix) => {
+    for (const [key, value] of Object.entries(node)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "number" || typeof value === "boolean") {
+        out[path] = value;
+      } else if (value !== null && typeof value === "object") {
+        walk(value, path);
+      } else if (value !== void 0) {
+        throw new TypeError(`Mastering override '${path}' must be a number or boolean.`);
+      }
+    }
+  };
+  walk(config, "");
+  return out;
+}
+
+// src/playback_renderer.ts
+function configJsonText(config) {
+  return typeof config === "string" ? config : JSON.stringify(config);
+}
+function nativeHrtf(hrtf) {
+  if (hrtf === void 0) {
+    return null;
+  }
+  if (!(hrtf instanceof HrtfSet)) {
+    throw new TypeError("hrtf must be an HrtfSet");
+  }
+  return hrtf.native;
+}
+var HrtfSet = class _HrtfSet {
+  constructor(native) {
+    this.released = false;
+    this.native = native;
+  }
+  /** Builds an HRTF set from SHRF v1 bytes; malformed data throws. */
+  static fromBytes(bytes) {
+    return new _HrtfSet(getSonareModule().createHrtfSet(bytes));
+  }
+  /** Releases the native handle. Idempotent, as the Node facade is. */
+  delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
+  }
+};
+var PlaybackRenderer = class {
+  constructor(options) {
+    this.released = false;
+    this.native = getSonareModule().createPlaybackRenderer(
+      configJsonText(options.config),
+      nativeHrtf(options.hrtf),
+      options.sampleRate ?? 48e3,
+      options.maxBlockSize ?? 1024
+    );
+  }
+  /**
+   * Renders one planar block; every plane must carry the same frame count, at
+   * most `maxBlockSize` (0 is a no-op). With a fixed input layout the plane
+   * count must equal {@link inputChannels}; with `input.layout: "auto"` it
+   * must be 1, 2, 6 or 8, and a change switches the input layout without
+   * changing the latency. Non-finite input samples are replaced with 0 and
+   * counted ({@link nonFiniteDiscardCount}).
+   */
+  processPlanar(planes) {
+    return this.native.processPlanar(planes);
+  }
+  /** Interleaved variant of {@link processPlanar}. Non-finite input samples are replaced with 0 and counted. */
+  processInterleaved(samples, inChannels) {
+    return this.native.processInterleaved(samples, inChannels);
+  }
+  /** Applies a complete configuration document; a changed prepare key throws. */
+  setConfig(config) {
+    this.native.setConfig(configJsonText(config));
+  }
+  /** The current complete configuration document. */
+  config() {
+    return JSON.parse(this.native.configJson());
+  }
+  /**
+   * Publishes the listener head orientation in degrees: right-handed,
+   * positive yaw turns the head right, positive pitch looks up, positive roll
+   * lowers the right ear. Ignored by a speakers target; a non-finite angle is
+   * ignored.
+   */
+  setHeadOrientation(yawDeg, pitchDeg = 0, rollDeg = 0) {
+    this.native.setHeadOrientation(yawDeg, pitchDeg, rollDeg);
+  }
+  /**
+   * Clears DSP state (filters, FIFOs, dynamics, convolution history, pending
+   * input-layout drains). Configuration and head pose are kept. Call it after
+   * a seek, from the thread that processes.
+   */
+  reset() {
+    this.native.reset();
+  }
+  /**
+   * Renderer latency in samples (headphones: near ear). Depends only on the
+   * target, the sample rate and distance compensation, never on realtime keys
+   * or the input layout.
+   */
+  latencySamples() {
+    return this.native.latencySamples();
+  }
+  /**
+   * Channel count of the active input layout. With `input.layout: "auto"`
+   * this follows the channel count of the most recent non-empty process call
+   * (2 before the first call).
+   */
+  inputChannels() {
+    return this.native.inputChannels();
+  }
+  /** Channel count of the output target. */
+  outputChannels() {
+    return this.native.outputChannels();
+  }
+  /**
+   * Inactive stages, per-stage latency, clamps, the active input layout, and
+   * the layout-switch / truncated-drain counters, as a plain object.
+   */
+  diagnostics() {
+    return JSON.parse(this.native.diagnosticsJson());
+  }
+  /** Non-finite input samples replaced with 0 since construction. */
+  nonFiniteDiscardCount() {
+    return this.native.nonFiniteDiscardCount();
+  }
+  /** Releases the native handle. Idempotent, as the Node facade is. */
+  delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
+  }
+};
+
 // src/realtime_engine.ts
 var EXPECTED_ENGINE_ABI_VERSION = 3;
+var UMP_WORD_MIN = -2147483648;
+var UMP_WORD_MAX = 4294967295;
+function assertUmpWords(fnName, words) {
+  if (!(words instanceof Uint32Array) && !Array.isArray(words)) {
+    throw new TypeError(`${fnName}: words must be a Uint32Array or a number array`);
+  }
+  if (words.length < 1 || words.length > 4) {
+    throw new RangeError(`${fnName}: words must hold 1 to 4 words`);
+  }
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    if (typeof word !== "number" || !Number.isInteger(word) || word < UMP_WORD_MIN || word > UMP_WORD_MAX) {
+      throw new RangeError(`${fnName}: words[${i}] must be an integer 32-bit word`);
+    }
+  }
+  return words;
+}
+function normalizeRenderOfflineRequest(channelsOrRequest, blockSize) {
+  const request = Array.isArray(channelsOrRequest) ? { channels: channelsOrRequest, blockSize } : channelsOrRequest;
+  return {
+    channels: request.channels,
+    blockSize: request.blockSize ?? 128,
+    finalize: request.finalize ?? true
+  };
+}
 function engineCapabilities() {
   const abiVersion = getSonareModule().engineAbiVersion();
   const sharedArrayBuffer = typeof globalThis.SharedArrayBuffer === "function";
@@ -643,8 +935,9 @@ function engineCapabilities() {
     mode: sharedArrayBuffer && atomics ? "sab" : "postMessage"
   };
 }
-var RealtimeEngine = class {
+var RealtimeEngine = class _RealtimeEngine {
   constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024, maxChannels = 64) {
+    this.released = false;
     const module2 = getSonareModule();
     const capabilities = engineCapabilities();
     if (!capabilities.abiCompatible) {
@@ -660,6 +953,15 @@ var RealtimeEngine = class {
       maxChannels
     );
   }
+  /**
+   * Size the engine's queues and scratch for a sample rate and block size.
+   *
+   * `commandCapacity` must not exceed 65536 and `telemetryCapacity` must not
+   * exceed 16384; a larger value throws and leaves the engine untouched. The
+   * telemetry number is not a queue depth paid for one-for-one: the engine
+   * reserves that many meter records per metered lane, so its memory cost is
+   * far larger than the number given here.
+   */
   prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024, maxChannels = 64) {
     this.native.prepareWithChannels(
       sampleRate,
@@ -706,9 +1008,13 @@ var RealtimeEngine = class {
    * scheduled MIDI clips routed to that destination render through the synth.
    * Unknown preset names throw. An object patch's `destinationId` is a JS
    * binding convenience, not part of the NativeSynth patch itself.
+   *
+   * An `engineMode: 'sample'` patch also carries the {@link SampleBank} its
+   * keymap names. The synth takes a share of the bank, so it may be released
+   * right after this call; a sample patch bound without one renders silence.
    */
   setSynthInstrument(patch = {}, destinationId = (typeof patch === "object" ? patch.destinationId : void 0) ?? 0) {
-    this.native.setSynthInstrument(destinationId, patch);
+    this.native.setSynthInstrument(destinationId, normalizeSynthInstrument(patch));
   }
   /**
    * Load (parse) SoundFont 2 bytes into the engine so SF2 instruments can be
@@ -761,6 +1067,113 @@ var RealtimeEngine = class {
   midiCcBindingCount() {
     return this.native.midiCcBindingCount();
   }
+  /**
+   * Replace a destination instrument's controller profile with a named preset
+   * (see {@link controllerProfileNames}). Installing a profile drops every
+   * channel's accumulated axis values: the new bindings say nothing about what
+   * the old ones had reached. An unknown name throws, and so does a destination
+   * with no instrument or one whose instrument holds no profile.
+   */
+  setControllerProfile(destinationId, presetName) {
+    this.native.setControllerProfile(destinationId, presetName);
+  }
+  /** Add one {@link ControllerBinding} on top of the destination's current profile. */
+  bindController(destinationId, binding) {
+    this.native.bindController(destinationId, binding);
+  }
+  /**
+   * Drop every binding of the destination's controller profile. The instrument
+   * keeps a profile; it resolves nothing until something is bound again.
+   */
+  clearControllerBindings(destinationId) {
+    this.native.clearControllerBindings(destinationId);
+  }
+  controllerBindingCount(destinationId) {
+    return this.native.controllerBindingCount(destinationId);
+  }
+  /**
+   * Whether note-on velocity is expression for this instrument. No fixed
+   * default is possible — a wind controller ships sending breath-derived
+   * velocity on one model and a constant on the next — so each preset states it
+   * and a host building its own profile sets it. When false the synth takes
+   * every note at full scale and the bound axes carry the dynamics alone.
+   */
+  setControllerVelocityMeaningful(destinationId, meaningful) {
+    this.native.setControllerVelocityMeaningful(destinationId, meaningful);
+  }
+  controllerVelocityMeaningful(destinationId) {
+    return this.native.controllerVelocityMeaningful(destinationId);
+  }
+  /**
+   * Say which note a value addressed to a whole MIDI channel belongs to when
+   * several are sounding on it, for one per-note dimension
+   * ({@link MPE_DIMENSIONS}, {@link NOTE_TRACKINGS}).
+   *
+   * Set per dimension because the useful answers differ: pressure following the
+   * newest note while bend reaches every one is a real configuration, not a
+   * mistake. MPE poses this question and declines to answer it, so this is a
+   * choice rather than a rule — and it is read only inside an MPE zone, and
+   * only while more than one note is sounding on the channel, which an MPE
+   * sender avoids by giving each note its own member channel.
+   *
+   * Both arguments are required and are a name or its ordinal; an unknown
+   * spelling is refused rather than resolved to a default, as are a destination
+   * with no instrument and one whose instrument holds no controller profile.
+   */
+  setControllerNoteTracking(destinationId, dimension, tracking) {
+    this.native.setControllerNoteTracking(destinationId, dimension, tracking);
+  }
+  /**
+   * Read back {@link setControllerNoteTracking} for one dimension, as the
+   * canonical name.
+   */
+  controllerNoteTracking(destinationId, dimension) {
+    return this.native.controllerNoteTracking(destinationId, dimension);
+  }
+  /**
+   * Set how one MIDI channel (0–15) of a destination's instrument treats a
+   * note-on while another note on that channel is still held: `'poly'` takes a
+   * new voice each time, `'mono-retrigger'` stops and restarts the note (what
+   * GS MONO MODE and CC126 mean), `'mono-legato'` carries the sounding voice
+   * and only moves its pitch — a wind player's slur, which no MIDI message can
+   * reach by design.
+   *
+   * `'mono-legato'` is a request, not a guarantee: an engine whose exciter is
+   * spent at the onset — anything struck or plucked — and a target pitch below
+   * what the engine's delay line can hold both fall back to an ordinary note,
+   * which {@link legatoFallbackCount} counts. A channel outside [0,15] and an
+   * articulation outside the enum are refused rather than clamped, and so is a
+   * destination with no instrument or one whose instrument has no articulation
+   * of its own.
+   */
+  setArticulation(destinationId, channel, articulation) {
+    this.native.setArticulation(destinationId, channel, articulation);
+  }
+  /**
+   * Read back {@link setArticulation} as the canonical name. An ordinal this
+   * build cannot spell is handed back as the number, the way every other enum
+   * leaves this surface.
+   */
+  articulation(destinationId, channel) {
+    return this.native.articulation(destinationId, channel);
+  }
+  /**
+   * How many times a legato continuation was asked for on this destination and
+   * refused, so the note started a voice of its own instead. Counted rather
+   * than inferred: a refusal sounds like an ordinary note, so nothing in the
+   * audio separates "this engine declines legato" from "the mode was never
+   * set". Saturates at 4294967295 rather than wrapping — matching the C ABI, so
+   * the same phrase reports the same number on every surface — after which it
+   * reads as "at least this many".
+   *
+   * Throws on a destination with no instrument, and on one whose instrument has
+   * no articulation of its own — the same two refusals
+   * {@link setArticulation} keeps apart. Reporting 0 for the second would read
+   * as "every slur took", which is the reading this counter exists to prevent.
+   */
+  legatoFallbackCount(destinationId) {
+    return this.native.legatoFallbackCount(destinationId);
+  }
   /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
   setMidiFx(destinationId, configJson) {
     this.native.setMidiFx(destinationId, configJson);
@@ -806,6 +1219,12 @@ var RealtimeEngine = class {
    * block / animation frame. `maxRecords` caps the number of output events
    * returned — the shared unit across every surface. Events past the cap stay
    * queued for the next call (lossless); call again to drain the rest.
+   *
+   * One queued record lowers to at most 4 MIDI 1.0 messages (a MIDI 2.0
+   * registered or assignable controller becomes CC 101/100 or 99/98 plus Data
+   * Entry 6/38), so a positive `maxRecords` below 4 could never consume a record
+   * and is rejected with an `InvalidParameter` `SonareError` instead of
+   * returning nothing forever.
    */
   drainExternalMidi(maxRecords = 1024) {
     return this.native.drainExternalMidi(maxRecords);
@@ -818,7 +1237,7 @@ var RealtimeEngine = class {
     return this.native.externalMidiScratchDestinationId();
   }
   externalMidiScratchRenderFrame() {
-    return this.native.externalMidiScratchRenderFrame();
+    return Number(this.native.externalMidiScratchRenderFrame());
   }
   externalMidiScratchByteWord() {
     return this.native.externalMidiScratchByteWord();
@@ -838,6 +1257,31 @@ var RealtimeEngine = class {
   pushMidiInputCc(group, channel, controller, value, portTimeSamples = 0) {
     this.native.pushMidiInputCc(group, channel, controller, value, portTimeSamples);
   }
+  /**
+   * Push a live MIDI pitch bend to the engine-owned MIDI input source.
+   *
+   * `bend14` is unsigned 14-bit with centre 8192 (0..16383) — the dimension is
+   * not 7-bit, so a value past 16383 is refused rather than narrowed. The input
+   * source must be enabled with {@link setMidiInputSource} first.
+   */
+  pushMidiInputPitchBend(group, channel, bend14, portTimeSamples = 0) {
+    this.native.pushMidiInputPitchBend(group, channel, bend14, portTimeSamples);
+  }
+  /**
+   * Push a live MIDI channel pressure to the engine-owned MIDI input source.
+   * `pressure` is 7-bit (0..127). Under MPE this is the member channel's
+   * per-note pressure.
+   */
+  pushMidiInputChannelPressure(group, channel, pressure, portTimeSamples = 0) {
+    this.native.pushMidiInputChannelPressure(group, channel, pressure, portTimeSamples);
+  }
+  /**
+   * Push a live MIDI polyphonic key pressure to the engine-owned MIDI input
+   * source. `note` and `pressure` are 7-bit (0..127).
+   */
+  pushMidiInputPolyPressure(group, channel, note, pressure, portTimeSamples = 0) {
+    this.native.pushMidiInputPolyPressure(group, channel, note, pressure, portTimeSamples);
+  }
   pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame = -1) {
     this.native.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
   }
@@ -853,9 +1297,53 @@ var RealtimeEngine = class {
   pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
     this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
-  /** Queue one immediate MIDI 1.0 channel-voice UMP word for a destination. */
-  pushMidiUmp(destinationId, word0, renderFrame = -1) {
-    this.native.pushMidiUmp(destinationId, word0, renderFrame);
+  /**
+   * Queue an immediate (live) MIDI pitch bend to a MIDI destination. `bend14`
+   * is unsigned 14-bit with centre 8192 (0..16383); `renderFrame` is the frame
+   * to fire at, or -1 for immediate. Mirrors the Node/Python/C-ABI
+   * `pushMidiPitchBend`.
+   */
+  pushMidiPitchBend(destinationId, group, channel, bend14, renderFrame = -1) {
+    this.native.pushMidiPitchBend(destinationId, group, channel, bend14, renderFrame);
+  }
+  /**
+   * Queue an immediate (live) MIDI channel pressure to a MIDI destination.
+   * `pressure` is 7-bit (0..127); `renderFrame` is the frame to fire at, or -1
+   * for immediate. Mirrors the Node/Python/C-ABI `pushMidiChannelPressure`.
+   */
+  pushMidiChannelPressure(destinationId, group, channel, pressure, renderFrame = -1) {
+    this.native.pushMidiChannelPressure(destinationId, group, channel, pressure, renderFrame);
+  }
+  /**
+   * Queue an immediate (live) MIDI polyphonic key pressure to a MIDI
+   * destination. `note` and `pressure` are 7-bit (0..127); `renderFrame` is the
+   * frame to fire at, or -1 for immediate. Mirrors the Node/Python/C-ABI
+   * `pushMidiPolyPressure`.
+   */
+  pushMidiPolyPressure(destinationId, group, channel, note, pressure, renderFrame = -1) {
+    this.native.pushMidiPolyPressure(destinationId, group, channel, note, pressure, renderFrame);
+  }
+  /**
+   * Queue an immediate (live) raw UMP message to a MIDI destination. `words` is
+   * 1 to 4 words, most significant first, and its length must match the message
+   * type of `words[0]`. MIDI 2.0 channel-voice messages (MT 0x4) arrive at full
+   * width; SysEx7 / data messages (MT 0x3 / 0x5) are refused, use
+   * {@link pushMidiSysex}. Throws when the slot ring or command queue is full
+   * (retry after a process block). `renderFrame` is the render-frame time to
+   * apply, or -1 for immediate. A bare number is accepted as a one-word
+   * message.
+   */
+  pushMidiUmp(destinationId, words, renderFrame = -1) {
+    const list = typeof words === "number" ? [words] : words;
+    this.native.pushMidiUmp(destinationId, assertUmpWords("pushMidiUmp", list), renderFrame);
+  }
+  /**
+   * Push one raw UMP message (1 to 4 words) to the engine-owned MIDI input
+   * source. The message rules match {@link pushMidiUmp}. `portTimeSamples` is
+   * the port timestamp in samples.
+   */
+  pushMidiInputUmp(words, portTimeSamples = 0) {
+    this.native.pushMidiInputUmp(assertUmpWords("pushMidiInputUmp", words), portTimeSamples);
   }
   /**
    * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
@@ -902,10 +1390,18 @@ var RealtimeEngine = class {
   settleParameters() {
     this.native.settleParameters();
   }
+  /** Snap only insert automation slots after structural replay. */
+  settleInsertParameters() {
+    this.native.settleInsertParameters();
+  }
   /** Drains queued commands on an offline/control-only engine immediately. */
   flushControlCommands() {
     this.native.flushControlCommands();
   }
+  /** Applies commands already due on a control-only mirror, retaining future commands. */
+  applyCommandsDueNowPreservingFuture() {
+    this.native.applyCommandsDueNowPreservingFuture();
+  }
   seekPpq(ppq, renderFrame = -1) {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -1001,6 +1497,18 @@ var RealtimeEngine = class {
   clipCount() {
     return this.native.clipCount();
   }
+  /**
+   * Normalizes each send's pre/post tap point to the integer the native layer
+   * reads (defaults to post-fader when omitted). Shared by track lanes and
+   * buses, which carry the same send shape.
+   */
+  static normalizeSends(sends) {
+    return sends.map((send) => ({
+      ...send,
+      // Post-fader (0) is the default for an omitted sendTiming.
+      sendTiming: send.sendTiming === void 0 ? 0 : sendTimingCode(send.sendTiming)
+    }));
+  }
   setTrackLanes(lanes) {
     this.native.setTrackLanes(
       lanes.map((lane) => {
@@ -1010,14 +1518,7 @@ var RealtimeEngine = class {
         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)
-          }))
-        };
+        return { ...lane, sends: _RealtimeEngine.normalizeSends(lane.sends) };
       })
     );
   }
@@ -1029,7 +1530,25 @@ var RealtimeEngine = class {
     this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
   }
   setTrackBuses(buses) {
-    this.native.setTrackBuses(buses);
+    this.native.setTrackBuses(
+      Array.isArray(buses) ? buses.map(
+        (bus) => bus.sends ? { ...bus, sends: _RealtimeEngine.normalizeSends(bus.sends) } : bus
+      ) : buses
+    );
+  }
+  /**
+   * Keys one insert of a bus strip from a track lane or another bus
+   * (ducking/sidechainRouter inserts). `sourceId` 0 removes the binding.
+   */
+  setBusSidechain(busId, insertIndex, sourceKind, sourceId) {
+    this.native.setBusSidechain(busId, insertIndex, sidechainSourceKindCode(sourceKind), sourceId);
+  }
+  /**
+   * Keys one insert of the master strip from a track lane or a bus. Same
+   * source rules as {@link setBusSidechain}.
+   */
+  setMasterSidechain(insertIndex, sourceKind, sourceId) {
+    this.native.setMasterSidechain(insertIndex, sidechainSourceKindCode(sourceKind), sourceId);
   }
   setBusStripJson(busId, sceneJson) {
     try {
@@ -1062,6 +1581,17 @@ var RealtimeEngine = class {
   setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass = false) {
     this.native.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
   }
+  /** Bus-strip counterpart of {@link setTrackStripEqBand}. */
+  setBusStripEqBand(busId, bandIndex, band) {
+    this.native.setBusStripEqBandJson(
+      busId,
+      bandIndex,
+      typeof band === "string" ? band : JSON.stringify(band)
+    );
+  }
+  setBusStripEqBandJson(busId, bandIndex, bandJson) {
+    this.native.setBusStripEqBandJson(busId, bandIndex, bandJson);
+  }
   setMasterStripJson(sceneJson) {
     try {
       JSON.parse(sceneJson);
@@ -1085,22 +1615,59 @@ var RealtimeEngine = class {
   }
   /**
    * 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.
+   * processor's JSON-key parameter name — one of the entries
+   * {@link masteringInsertParamInfo} reports with a non-null `id`; a
+   * construction-only entry (`id` null) takes effect only when the insert is
+   * built. 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);
   }
+  /** Apply a live insert edit on this engine's owning thread without draining its command queue. */
+  applyTrackStripInsertParamByNameNow(trackId, insertIndex, paramName, value) {
+    return this.native.applyTrackStripInsertParamByNameNow(trackId, insertIndex, paramName, value);
+  }
+  /** Restore a retained insert value exactly after a strip scene is replayed. */
+  restoreTrackStripInsertParamByName(trackId, insertIndex, paramName, value) {
+    this.native.restoreTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+  }
   /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
   setMasterStripInsertParamByName(insertIndex, paramName, value) {
     this.native.setMasterStripInsertParamByName(insertIndex, paramName, value);
   }
+  applyMasterStripInsertParamByNameNow(insertIndex, paramName, value) {
+    return this.native.applyMasterStripInsertParamByNameNow(insertIndex, paramName, value);
+  }
+  restoreMasterStripInsertParamByName(insertIndex, paramName, value) {
+    this.native.restoreMasterStripInsertParamByName(insertIndex, paramName, value);
+  }
   /** Bus-strip counterpart of {@link setTrackStripInsertParamByName}. */
   setBusStripInsertParamByName(busId, insertIndex, paramName, value) {
     this.native.setBusStripInsertParamByName(busId, insertIndex, paramName, value);
   }
+  applyBusStripInsertParamByNameNow(busId, insertIndex, paramName, value) {
+    return this.native.applyBusStripInsertParamByNameNow(busId, insertIndex, paramName, value);
+  }
+  restoreBusStripInsertParamByName(busId, insertIndex, paramName, value) {
+    this.native.restoreBusStripInsertParamByName(busId, insertIndex, paramName, value);
+  }
+  /**
+   * Forgets the remembered manual insert-parameter values of one track strip
+   * and discards its queued insert edits. Call before {@link setTrackStripJson}
+   * replaces the strip when its old values must not carry over; the setter
+   * never does this itself, since a queued edit may already target the new chain.
+   */
+  clearTrackInsertParameterBases(trackId) {
+    this.native.clearTrackInsertParameterBases(trackId);
+  }
+  clearBusInsertParameterBases(busId) {
+    this.native.clearBusInsertParameterBases(busId);
+  }
+  clearMasterInsertParameterBases() {
+    this.native.clearMasterInsertParameterBases();
+  }
   /** Bus-strip counterpart of {@link setTrackStripInsertBypassed}. */
   setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass = false) {
     this.native.setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass);
@@ -1111,6 +1678,15 @@ var RealtimeEngine = class {
    * Returns `-1` when the track, insert, or name is unknown. (The Python binding
    * raises a `SonareError` for an unknown id where Node/WASM return the `-1`
    * sentinel.)
+   *
+   * This trio is how a mastering processor gets time-varying automation: the
+   * `eq.*`, `dynamics.*`, `saturation.*`, `spectral.*`, `stereo.*`,
+   * `maximizer.*` and `multiband.*` processors are all available as strip
+   * inserts, so placing one on a strip and resolving its parameter here drives
+   * it at audio-block precision, live and offline alike. The whole-signal
+   * stages of the offline mastering chain (`repair.*`, `loudness`, and the
+   * match stages) have no insert form and no automation id: they buffer the
+   * entire signal by construction and do not run on the realtime path.
    */
   resolveTrackInsertAutomationId(trackId, insertIndex, paramName) {
     return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
@@ -1121,6 +1697,41 @@ var RealtimeEngine = class {
   resolveBusInsertAutomationId(busId, insertIndex, paramName) {
     return this.native.resolveBusInsertAutomationId(busId, insertIndex, paramName);
   }
+  /**
+   * Resolves a hosted instrument's continuous parameter (by its JSON-key name)
+   * to the reserved automation id usable with `setAutomationLane` /
+   * `setParameter`, so an instrument parameter is driven at audio-block
+   * precision exactly like a strip insert. Returns `-1` when the destination
+   * has no bound instrument, the instrument exposes no automatable parameters,
+   * or the name is unknown.
+   *
+   * For the NativeSynth ({@link setSynthInstrument}) the names are the
+   * continuous {@link SynthPatch} fields: `gain`, `busDrive`, `cutoffHz`,
+   * `resonanceQ`, `drive`, `keyTrack`, `envToCutoffCents`, `velToCutoffCents`,
+   * `ampAttackMs`, `ampDecayMs`, `ampSustain`, `ampReleaseMs`,
+   * `filterAttackMs`, `filterDecayMs`, `filterSustain`, `filterReleaseMs`,
+   * `lfoRateHz`, `lfoToPitchCents`, `lfo2RateHz`, `glideMs`, `bodyMix`,
+   * `stereoSpread`, `detuneCents`, `driftCents`, `pitchOffsetCents`,
+   * `hpCutoffHz`, `sampleHoldHz`, `bitDepth`.
+   *
+   * Structural fields (`preset`, `engineMode`, `waveform`, `filterModel`,
+   * `unison`, `polyphony`, `body`, `modRoutings`) are not automatable and
+   * return `-1`: they resize voice pools or swap DSP topology, which is not
+   * audio-thread safe. Rebind the instrument with a new patch instead.
+   *
+   * `gain`, `busDrive`, `cutoffHz`, `resonanceQ`, `envToCutoffCents`,
+   * `lfoToPitchCents` and `pitchOffsetCents` reach voices that are already
+   * sounding from the next block; the rest are cached into per-voice state at
+   * note-on and take effect from the next note, so a lane that moves one of
+   * them under a held note looks inert until the next one speaks — that is the
+   * behaviour, not a dropped write.
+   *
+   * The id survives an unbind/rebind of the same destination and applies
+   * nothing while that destination is unbound.
+   */
+  resolveInstrumentAutomationId(destinationId, paramName) {
+    return this.native.resolveInstrumentAutomationId(destinationId, paramName);
+  }
   /** Sets a track lane strip's pan position in realtime (glitch-free). */
   setTrackStripPan(trackId, pan) {
     this.native.setTrackStripPan(trackId, pan);
@@ -1137,6 +1748,25 @@ var RealtimeEngine = class {
   setTrackStripDualPan(trackId, leftPan, rightPan) {
     this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
   }
+  /**
+   * Sets a bus strip's output pan position in realtime (glitch-free). Throws
+   * for an unknown bus or one wider than stereo.
+   */
+  setBusStripPan(busId, pan) {
+    this.native.setBusStripPan(busId, pan);
+  }
+  /** Sets a bus strip's pan law in realtime. */
+  setBusStripPanLaw(busId, panLaw) {
+    this.native.setBusStripPanLaw(busId, panLawCode(panLaw));
+  }
+  /** Sets a bus strip's pan mode in realtime. */
+  setBusStripPanMode(busId, panMode) {
+    this.native.setBusStripPanMode(busId, panModeCode(panMode));
+  }
+  /** Sets a bus strip's dual-pan left/right positions in realtime. */
+  setBusStripDualPan(busId, leftPan, rightPan) {
+    this.native.setBusStripDualPan(busId, 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.
@@ -1177,6 +1807,52 @@ var RealtimeEngine = class {
   clipPageRequestOverflowCount() {
     return this.native.clipPageRequestOverflowCount();
   }
+  /** Cumulative warp-stretch requests dropped because the native queue was full. */
+  warpStretchOverflowCount() {
+    return this.native.warpStretchOverflowCount();
+  }
+  /**
+   * Sets the number of concurrent time-stretch voices. `voices` must be an
+   * integer in `[0, 64]`; a non-integer, negative, or larger value throws and
+   * leaves the capacity unchanged. Default is 8. Capacity 0 disables
+   * time-stretch, so every warped clip plays resampled instead and none of
+   * that counts toward {@link warpStretchOverflowCount}. A change applied
+   * while the engine is running restarts the splice state of any clip
+   * stretching through a voice at that moment. Control-thread only.
+   */
+  setWarpVoiceCapacity(voices) {
+    this.native.setWarpVoiceCapacity(voices);
+  }
+  /** Reads the current time-stretch voice capacity (default 8). */
+  warpVoiceCapacity() {
+    return this.native.warpVoiceCapacity();
+  }
+  /**
+   * Sets the clip-page look-ahead window in timeline frames.
+   *
+   * The player reports the pages it is *about to* read that are not resident
+   * yet, so a streaming host can service them before the audio thread reaches
+   * them. Without look-ahead a page miss is only reported after the read
+   * already produced silence, which costs one block of silence at every page
+   * boundary the host has not primed — the reason a sliding-window streamer
+   * cannot keep a live playhead fed from miss reports alone.
+   *
+   * Look-ahead requests drain through the same `popClipPageRequest` queue and
+   * are queued *after* the block's genuine misses, so a host that keeps only
+   * the newest request per clip (as {@link ClipPageStreamer} does) tracks the
+   * look-ahead frontier.
+   *
+   * `prepare` defaults this to half a second at the engine's sample rate. `0`
+   * disables the look-ahead. A clip whose pages are all resident produces no
+   * requests at all, with or without look-ahead. Safe to call during playback.
+   */
+  setClipPagePrefetchFrames(frames) {
+    this.native.setClipPagePrefetchFrames(frames);
+  }
+  /** Current clip-page look-ahead window in timeline frames. */
+  clipPagePrefetchFrames() {
+    return this.native.clipPagePrefetchFrames();
+  }
   setCaptureBuffer(numChannels, capacityFrames) {
     this.native.setCaptureBuffer(numChannels, capacityFrames);
   }
@@ -1238,15 +1914,66 @@ var RealtimeEngine = class {
   processPrepared(numFrames) {
     this.native.processPrepared(numFrames);
   }
+  /**
+   * Allocates the cue-bus counterpart of {@link prepareChannels}. Needed only
+   * when PFL/AFL monitoring must reach a separate output: `processPrepared`
+   * folds the cue bus into the program output, while
+   * {@link processPreparedWithMonitor} keeps the two apart. Call once, off the
+   * audio thread, with at least as many channels as `prepareChannels` got.
+   */
+  prepareMonitorChannels(numChannels, maxFrames) {
+    this.native.prepareMonitorChannels(numChannels, maxFrames);
+  }
+  /**
+   * Returns a Float32Array view onto the persistent cue-bus scratch for one
+   * channel (valid for up to `numFrames`). Read it after
+   * {@link processPreparedWithMonitor}. Re-acquire after WASM memory growth.
+   */
+  getMonitorChannelBuffer(channel, numFrames) {
+    return this.native.getMonitorChannelBuffer(channel, numFrames);
+  }
+  /**
+   * Runs the engine in place over the prepared scratch, writing the cue bus to
+   * the monitor scratch instead of folding it into the program output.
+   * Allocation-free: safe on the AudioWorklet render thread after
+   * `prepareChannels` and `prepareMonitorChannels`.
+   */
+  processPreparedWithMonitor(numFrames) {
+    this.native.processPreparedWithMonitor(numFrames);
+  }
   processWithMonitor(channels) {
     return this.native.processWithMonitor(channels);
   }
-  renderOffline(channels, blockSize = 128) {
-    return this.native.renderOffline(channels, blockSize);
+  renderOffline(channelsOrRequest, blockSize = 128) {
+    const request = normalizeRenderOfflineRequest(channelsOrRequest, blockSize);
+    return this.native.renderOffline(request.channels, request.blockSize, request.finalize);
+  }
+  /**
+   * End a chunked offline render: release every note the sequencer still holds
+   * and flush the PDC / alignment delay lines. Required after
+   * `renderOffline({ finalize: false })`; the finalizing form does it itself.
+   *
+   * Skipping it leaves every note still sounding at the last chunk held. On an
+   * engine-internal instrument the tail simply never releases; on a destination
+   * marked external ({@link RealtimeEngine.setMidiDestinationExternal}) the
+   * note-ons already left through the external MIDI queue, so the note-offs
+   * emitted here are the only ones the receiving device will get and the notes
+   * otherwise hang outside the engine.
+   */
+  finishOfflineRender() {
+    this.native.finishOfflineRender();
   }
+  /**
+   * Bounce the timeline to an interleaved buffer. `numChannels` above the
+   * prepared channel count throws an `InvalidParameter` `SonareError`.
+   */
   bounceOffline(options) {
     return this.native.bounceOffline(options);
   }
+  /**
+   * Freeze the current graph to audio. `numChannels` above the prepared channel
+   * count throws an `InvalidParameter` `SonareError`.
+   */
   freezeOffline(options) {
     return this.native.freezeOffline(options);
   }
@@ -1340,9 +2067,18 @@ var RealtimeEngine = class {
   scopeScratchPointRight(index) {
     return this.native.scopeScratchPointRight(index);
   }
+  /** Release the underlying WASM object. Idempotent, as the Node facade is. */
   destroy() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
     this.native.delete();
   }
+  /** Alias for {@link destroy}, matching embind's own release method name. */
+  delete() {
+    this.destroy();
+  }
 };
 var ClipPageProvider = class {
   constructor(engine, id) {
@@ -1374,12 +2110,20 @@ var ClipPageProvider = class {
 // src/mixer.ts
 var Mixer = class _Mixer {
   constructor(mixer, blockSize) {
+    this.released = false;
     this.mixer = mixer;
     this.blockSize = blockSize;
   }
   /**
    * Build a mixer from a scene JSON string.
    *
+   * A strip's meters are sized when the strip is built, so this is where their
+   * configuration is chosen: an optional `metering` object on the strip
+   * (`enabled` / `lufs` / `truePeak` / `truePeakOversample`) selects it, and
+   * leaving it out keeps the full default (LUFS + true peak at 4x, about 1.4 MB
+   * per strip at 48 kHz). `{"enabled": false}` drops both meters for a strip
+   * whose snapshots are never read.
+   *
    * @param json - Scene JSON (strips, buses, sends, connections, inserts)
    * @param sampleRate - Sample rate in Hz (default: 48000)
    * @param blockSize - Maximum block size per {@link processStereo} call (default: 512)
@@ -1486,15 +2230,65 @@ var Mixer = class _Mixer {
       }
     };
   }
-  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
-  stripCount() {
-    return this.mixer.stripCount();
-  }
   /**
-   * Schedule sample-accurate insert-parameter automation on a strip's insert.
+   * Turn the master-output meter on or off.
    *
-   * @param stripIndex - Strip index in `[0, stripCount())`
-   * @param insertIndex - Index into the strip's combined insert sequence
+   * While on, every {@link MixerRealtimeBuffer.process} call meters the stereo
+   * master it just produced, so a caller reads {@link meterSnapshot} instead of
+   * copying the output and measuring it again. `truePeakDb*` is an inter-sample
+   * peak taken after oversampling (ITU-R BS.1770-4 Annex 2 requires at least
+   * 4x), which is a different and higher quantity than the sample peak.
+   *
+   * Enabling resets the meter, so a reading never mixes in audio from a period
+   * when metering was off.
+   *
+   * @param enabled - Whether to meter the master output.
+   * @param truePeakOversample - 0 (= 4x) or a power of two in [1, 16].
+   */
+  configureMeter(enabled, truePeakOversample = 4) {
+    this.mixer.configureMeter(enabled, truePeakOversample);
+  }
+  /**
+   * Latest master-output meter reading, describing the most recently metered
+   * block. All dB fields are finite and floored at -120.
+   *
+   * @throws When the meter has never been enabled.
+   */
+  meterSnapshot() {
+    return this.mixer.meterSnapshot();
+  }
+  /**
+   * Latch the latest meter reading into the mixer's internal scratch so
+   * {@link meterScratchValue} can read it back one number at a time.
+   *
+   * This is the allocation-free form of {@link meterSnapshot}, for an audio
+   * render callback that must not create a JS object per interval. It returns
+   * `false` instead of throwing when the meter has never been enabled.
+   *
+   * @returns Whether a reading was latched.
+   */
+  latchMeterSnapshot() {
+    return this.mixer.latchMeterSnapshot();
+  }
+  /**
+   * Read one field of the snapshot latched by {@link latchMeterSnapshot}.
+   *
+   * @param field - `0` peakDbL, `1` peakDbR, `2` rmsDbL, `3` rmsDbR,
+   *   `4` correlation, `5` truePeakDbL, `6` truePeakDbR. Any other index
+   *   reads `0`.
+   */
+  meterScratchValue(field) {
+    return this.mixer.meterScratchValue(field);
+  }
+  /** Number of strips in the mixer (e.g. strips loaded from the scene). */
+  stripCount() {
+    return this.mixer.stripCount();
+  }
+  /**
+   * Schedule sample-accurate insert-parameter automation on a strip's insert.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   * @param insertIndex - Index into the strip's combined insert sequence
    *   (`[pre-inserts... post-inserts...]`)
    * @param paramId - Processor-specific parameter id
    * @param samplePos - Absolute samples from the start of processing (the mixer
@@ -1523,6 +2317,17 @@ var Mixer = class _Mixer {
     const index = this.mixer.stripById(id);
     return index < 0 ? null : index;
   }
+  /**
+   * Add a channel strip to the mixer topology. `metering` configures the strip's
+   * pre/post taps; omitting it keeps the full default (LUFS + true peak at 4x,
+   * about 1.4 MB per strip at 48 kHz). Marks the routing graph dirty; call
+   * {@link compile} (or {@link processStereo}) to rebuild.
+   *
+   * @throws If the id is already taken, or `truePeakOversample` is outside `[0, 16]`
+   */
+  addStrip(id, metering = {}) {
+    this.mixer.addStrip(id, metering);
+  }
   /**
    * Add a bus to the mixer topology. `role` is one of `'master'`, `'aux'`, or
    * `'submix'` (defaults to `'aux'`). Marks the routing graph dirty; call
@@ -1588,6 +2393,30 @@ var Mixer = class _Mixer {
   setWidth(stripIndex, width) {
     this.mixer.setWidth(stripIndex, width);
   }
+  /**
+   * Snap the strip's input-trim, fader, pan and width smoothers to the values
+   * already set on it, so the next processed block opens at those values
+   * instead of gliding to them over the smoothing window (~5 ms).
+   *
+   * Call it after configuring a strip and before rendering a finite buffer: a
+   * strip is smoothed for a live fader, and an offline render that does not
+   * settle carries that glide as a level and image sweep across the head of
+   * its output. Unlike a reset it clears nothing — automation, meters and
+   * insert state are untouched.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   *
+   * @example
+   * ```typescript
+   * mixer.setFaderDb(0, -3);
+   * mixer.setPan(0, 0.3);
+   * mixer.settle(0);
+   * const { left, right } = mixer.processStereo([dryLeft], [dryRight]);
+   * ```
+   */
+  settle(stripIndex) {
+    this.mixer.settle(stripIndex);
+  }
   /** Set the strip's mute state. */
   setMuted(stripIndex, muted) {
     this.mixer.setMuted(stripIndex, muted);
@@ -1631,7 +2460,10 @@ var Mixer = class _Mixer {
   }
   /**
    * 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.
+   *
+   * Applied when the engine's track mixer renders this strip's lane into a
+   * destination with more than two channels. This stereo-only mixer's own
+   * block entry points ignore it.
    */
   setSurroundPan(stripIndex, pan) {
     this.mixer.setSurroundPan(stripIndex, pan);
@@ -1697,6 +2529,59 @@ var Mixer = class _Mixer {
   busMeter(busId) {
     return this.mixer.busMeter(busId);
   }
+  /**
+   * Number of blocks in which the strip discarded recursive state because a
+   * non-finite value had reached it.
+   *
+   * Advisory telemetry, and the only thing that separates a degraded strip
+   * from a clean one. A discard returns the affected state to its
+   * post-reset value, so the strip recovers in silence and the output stays
+   * finite and in range while carrying samples unrelated to the input;
+   * nothing else reports that this happened.
+   *
+   * The count covers the strip's own state, its EQ, every insert it owns and
+   * both of its meters. None of those is separately addressable here, so a
+   * discard inside one is observable only through this number -- and a
+   * meter that loses its loudness window then reports the floor, which is
+   * exactly what a genuinely silent strip reports, so nothing else
+   * distinguishes the two.
+   *
+   * A meter's own discard lags by one block: it checks its loudness state at
+   * the top of a block, before consuming that block's samples, so the block
+   * that corrupts it is not the block the count moves on -- read this again
+   * after one more block has processed. The EQ and inserts have no such lag;
+   * they discard at the end of their own process, in the same block that
+   * carried the poison.
+   *
+   * Cumulative since the strip was created and never cleared, so two
+   * readings bracket a span of audio. The unit is one processed block, never
+   * a channel, so a stereo block that discards on both channels adds one and
+   * the number does not depend on a dimension the caller did not choose.
+   *
+   * @param stripIndex - Strip index in `[0, stripCount())`
+   */
+  stripNonFiniteDiscardCount(stripIndex) {
+    return this.mixer.stripNonFiniteDiscardCount(stripIndex);
+  }
+  /**
+   * Number of blocks in which a bus discarded recursive state because a
+   * non-finite value had reached it. Same contract as
+   * {@link stripNonFiniteDiscardCount}, for a bus: covers every insert the
+   * bus owns and its meter, neither separately addressable, so a discard
+   * inside one is observable only here. Cumulative across graph recompiles
+   * -- the count lives with the bus, not the compiled node, so an unrelated
+   * edit elsewhere in the mixer does not reset it.
+   *
+   * A bus's DSP record is created by the first {@link compile}. Throws for a
+   * bus that has been declared with {@link addBus} but never compiled --
+   * reading zero there would read as clean, and it is not. Also throws for
+   * an unknown bus id.
+   *
+   * @param busId - Bus id, as passed to {@link addBus} or declared in scene JSON
+   */
+  busNonFiniteDiscardCount(busId) {
+    return this.mixer.busNonFiniteDiscardCount(busId);
+  }
   /**
    * Schedule sample-accurate fader automation on a strip.
    *
@@ -1751,6 +2636,11 @@ var Mixer = class _Mixer {
   /**
    * Read up to `maxPoints` of a strip's most recent goniometer samples
    * (oldest to newest).
+   *
+   * `maxPoints` must be a finite non-negative integer; anything else throws an
+   * `InvalidParameter` error. It is a request rather than an allocation size —
+   * a value beyond the strip's goniometer ring simply returns every point the
+   * ring holds.
    */
   readGoniometerLatest(stripIndex, maxPoints) {
     return this.mixer.readGoniometerLatest(stripIndex, maxPoints);
@@ -1786,8 +2676,12 @@ var Mixer = class _Mixer {
     }
     return this.mixer.drainTailStereo(numSamples);
   }
-  /** Release the underlying WASM object. Safe to call only once. */
+  /** Release the underlying WASM object. Idempotent, as the Node facade is. */
   delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
     this.mixer.delete();
   }
   /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
@@ -1804,10 +2698,19 @@ var RealtimeVoiceChanger = class {
    * explicit {@link prepare} lifecycle for callers that configure later.
    */
   constructor(config = "neutral-monitor", sampleRate, maxBlockSize = 128, channels = 1) {
+    this.released = false;
     const module2 = getSonareModule();
     this.changer = module2.createRealtimeVoiceChanger(config);
     if (sampleRate !== void 0) {
-      this.changer.prepare(sampleRate, maxBlockSize, channels);
+      let prepared = false;
+      try {
+        this.changer.prepare(sampleRate, maxBlockSize, channels);
+        prepared = true;
+      } finally {
+        if (!prepared) {
+          this.changer.delete();
+        }
+      }
     }
   }
   prepare(sampleRate, maxBlockSize = 128, channels = 1) {
@@ -1833,6 +2736,34 @@ var RealtimeVoiceChanger = class {
   latencySamples() {
     return this.changer.latencySamples();
   }
+  /**
+   * Channel-blocks in which the chain discarded its own state because a
+   * non-finite value had reached it.
+   *
+   * Advisory telemetry, and the only thing that separates a degraded stream
+   * from a clean one. Every stage of this chain leaves an in-domain finite
+   * value where a non-finite one was — the input scrub and the
+   * inter-sample-peak limiter substitute silence, the sample-domain limiter
+   * folds an infinity onto its ceiling — so the output stays finite, in range
+   * and free of any error while carrying samples unrelated to the input. A
+   * non-zero count is what says the samples in between were not computed from
+   * what you supplied.
+   *
+   * Monotonic for the lifetime of the instance. The unit is one processed
+   * block, never a channel, so a stereo block that discards on both channels
+   * adds one and the number does not depend on a dimension you did not choose.
+   *
+   * @example
+   * ```ts
+   * changer.processInterleaved(block, 2);
+   * if (changer.nonFiniteDiscardCount() > 0) {
+   *   // the audio just produced is not a function of `block`
+   * }
+   * ```
+   */
+  nonFiniteDiscardCount() {
+    return this.changer.nonFiniteDiscardCount();
+  }
   /**
    * Monotonically increases whenever {@link prepare} can replace the native
    * scratch buffers. Cached WASM heap views must be reacquired after it changes.
@@ -2000,9 +2931,151 @@ var RealtimeVoiceChanger = class {
       }
     };
   }
+  /** Releases the native handle. Idempotent, as the Node facade is. */
   delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
     this.changer.delete();
   }
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
+  }
+};
+
+// src/streaming_processors.ts
+var StreamingMasteringChain = class {
+  constructor(config) {
+    this.released = false;
+    const module2 = getSonareModule();
+    const { loudnessStaticGainDb, loudnessStaticGainPeakDb, ...chainConfig } = config;
+    this.chain = module2.createStreamingMasteringChain({
+      __flatParams: flattenChainConfig(chainConfig),
+      loudnessStaticGainDb,
+      loudnessStaticGainPeakDb
+    });
+  }
+  /**
+   * Initialize processors for the given sample rate and block layout.
+   *
+   * @param sampleRate - Sample rate in Hz
+   * @param maxBlockSize - Maximum block size per process call
+   * @param numChannels - 1 (mono) or 2 (stereo)
+   */
+  prepare(sampleRate, maxBlockSize, numChannels) {
+    this.chain.prepare(sampleRate, maxBlockSize, numChannels);
+  }
+  /**
+   * Process one mono block, returning the processed samples (same length).
+   */
+  processMono(samples) {
+    return this.chain.processMono(samples);
+  }
+  /**
+   * Process one stereo block, returning the processed channels.
+   */
+  processStereo(left, right) {
+    if (left.length !== right.length) {
+      throw new Error("Stereo channel lengths must match.");
+    }
+    return this.chain.processStereo(left, right);
+  }
+  /**
+   * Emit delayed audio and finite processor tails after the final mono block.
+   * Call until this returns an empty array. The initial `latencySamples()`
+   * samples of the concatenated stream are delayed and should be discarded for
+   * time-aligned output.
+   */
+  flushMono() {
+    return this.chain.flushMono();
+  }
+  /** Stereo counterpart of {@link flushMono}. */
+  flushStereo() {
+    return this.chain.flushStereo();
+  }
+  /** Reset all processor state without rebuilding. */
+  reset() {
+    this.chain.reset();
+  }
+  /** Total reported latency in samples across all active processors. */
+  latencySamples() {
+    return this.chain.latencySamples();
+  }
+  /** Ordered stage names that will run (e.g. `"eq.tilt"`). */
+  stageNames() {
+    return this.chain.stageNames();
+  }
+  /**
+   * Samples a stage replaced with a finite in-domain one, keeping the output
+   * finite and in range.
+   *
+   * A non-finite sample supplied by the caller is rejected before any stage
+   * runs, so a replacement is always of a value a stage itself produced.
+   *
+   * Only the true-peak limiters replace anything, so with the maximizer's
+   * limiter and the loudness stage both disabled a zero here means no stage was
+   * able to replace anything rather than that nothing needed replacing.
+   *
+   * Cumulative over every block since {@link prepare}, and aggregated over the
+   * stages and channels, so it identifies neither which block nor which stage.
+   * Read it per block and compare against the previous reading to localize one.
+   *
+   * {@link prepare} rebuilds the stages and so clears it; {@link reset} does
+   * not, because it drops processor state without rebuilding.
+   *
+   * @example
+   * ```typescript
+   * chain.processMono(block);
+   * if (chain.nonFiniteSubstitutionCount() > previous) {
+   *   // the block just produced is not derived from `block` everywhere
+   * }
+   * ```
+   */
+  nonFiniteSubstitutionCount() {
+    return this.chain.nonFiniteSubstitutionCount();
+  }
+  /**
+   * Processing calls in which a stage discarded its own recursive state
+   * because a non-finite value had reached it.
+   *
+   * The companion to {@link nonFiniteSubstitutionCount}, and not the same
+   * measurement -- a caller who assumes they are will read one and think
+   * they have the other. That one counts SAMPLES a stage replaced and so
+   * sums across stages; a discard is a whole stage returning to its
+   * post-reset value and is counted once per call however many stages did
+   * it. A stage may run more than once per call, which is why this is a
+   * delta over the call and never a sum.
+   *
+   * Non-finite input is rejected before any stage runs, so what a stage
+   * discards is always state it produced itself -- a finite sample large
+   * enough to overflow inside a filter, most often. Unlike the substitution
+   * count every stage can contribute, so a zero here means no stage
+   * discarded rather than that none could.
+   *
+   * Both {@link processMono}/{@link processStereo} and
+   * {@link flushMono}/{@link flushStereo} count, since a flush drives the
+   * same stages. {@link prepare} rebuilds the stages and so clears it (as it
+   * does {@link nonFiniteSubstitutionCount}, so the two counters on one
+   * handle share an epoch); {@link reset} does not, because it drops
+   * processor state without rebuilding.
+   */
+  nonFiniteDiscardCount() {
+    return this.chain.nonFiniteDiscardCount();
+  }
+  /** Release the underlying WASM object. Idempotent, as the Node facade is. */
+  delete() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.chain.delete();
+  }
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy() {
+    this.delete();
+  }
 };
 
 // src/index.ts
@@ -2053,11 +3126,11 @@ function buildTempoSync(tempoBpm, timeSignature, tempoSegments, timeSignatureSeg
   };
 }
 function resolveTargetId(target) {
-  if (typeof target === "number") {
-    return target;
+  const value = typeof target === "number" ? target : target.trim() === "" ? Number.NaN : Number(target);
+  if (!Number.isInteger(value)) {
+    throw new RangeError(`target id must be an integer, got ${JSON.stringify(target)}`);
   }
-  const parsed = Number.parseInt(target, 10);
-  return Number.isFinite(parsed) ? parsed : 0;
+  return value;
 }
 function resolveParamId(parameters, nodeId, param) {
   if (typeof param === "number") {
@@ -2100,101 +3173,6 @@ function setAutomationLane(ctx, paramId, points) {
   ctx.postSync({ type: "syncAutomation", paramId, points: sorted });
 }
 
-// src/worklet/engine-offline.ts
-function buildCaptureConfig(options, defaultChannels) {
-  return {
-    bufferFrames: Math.trunc(options.bufferFrames),
-    channels: Math.trunc(options.channels ?? defaultChannels),
-    source: options.source ?? "output",
-    recordOffsetSamples: Math.trunc(options.recordOffsetSamples ?? 0),
-    inputMonitor: {
-      enabled: Boolean(options.inputMonitor?.enabled),
-      gain: options.inputMonitor?.gain ?? 1
-    }
-  };
-}
-function buildTransportFacade(ctx) {
-  return {
-    play: (sampleTime = -1) => {
-      const ok = ctx.realtimeNode.play(sampleTime);
-      if (ok) {
-        ctx.setTransportPlaying(true);
-      }
-      return ok;
-    },
-    stop: (sampleTime = -1) => {
-      const ok = ctx.realtimeNode.stop(sampleTime);
-      if (ok) {
-        ctx.setTransportPlaying(false);
-        ctx.flushPendingInstrumentSync();
-      }
-      return ok;
-    },
-    seekPpq: (ppq, sampleTime = -1) => {
-      ctx.offlineEngine.seekPpq(ppq, sampleTime);
-      const ok = ctx.realtimeNode.seekPpq(ppq, sampleTime);
-      ctx.flushOfflineMirror();
-      return ok;
-    },
-    seekSeconds: (seconds, sampleTime = -1) => {
-      const timelineSample = Math.max(0, Math.round(seconds * ctx.sampleRate));
-      ctx.offlineEngine.seekSample(timelineSample, sampleTime);
-      const ok = ctx.realtimeNode.seekSample(timelineSample, sampleTime);
-      ctx.flushOfflineMirror();
-      return ok;
-    },
-    setTempo: (bpm) => ctx.setTempo(bpm),
-    setTempoSegments: (segments) => ctx.setTempoSegments(segments),
-    setLoop: (startPpq, endPpq, enabled = true) => ctx.setLoop(startPpq, endPpq, enabled)
-  };
-}
-function normalizeTrackLanes(existing, 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 < existing.length; index++) {
-    if (ids[index] !== existing[index]) {
-      throw new Error(
-        "Mixer lanes are append-only: keep existing lanes in order and only append new track ids"
-      );
-    }
-  }
-  return { entries, ids };
-}
-function resolveMarkerSet(markers, nextMarkerId) {
-  const resolved = [];
-  const seen = /* @__PURE__ */ new Set();
-  let counter = nextMarkerId;
-  for (const marker2 of markers) {
-    if (!Number.isFinite(marker2.ppq)) {
-      throw new Error(`Invalid marker ppq: ${String(marker2.ppq)}`);
-    }
-    if (marker2.id !== void 0) {
-      if (!Number.isInteger(marker2.id) || marker2.id <= 0) {
-        throw new Error(`Invalid marker id: ${String(marker2.id)}`);
-      }
-      if (seen.has(marker2.id)) {
-        throw new Error(`Duplicate marker id: ${marker2.id}`);
-      }
-    }
-    const id = marker2.id ?? counter++;
-    seen.add(id);
-    if (id >= counter) {
-      counter = id + 1;
-    }
-    resolved.push({ id, ppq: marker2.ppq, name: marker2.name ?? "" });
-  }
-  return { resolved, nextMarkerId: counter };
-}
-
 // src/worklet/protocol.ts
 var ENGINE_MIXER_TARGET_BASE = 1297612800;
 var ENGINE_MIXER_PARAM_FADER_DB = 1;
@@ -2281,11 +3259,9 @@ var SonareEngineTelemetryError = /* @__PURE__ */ ((SonareEngineTelemetryError2)
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["MetronomeOverflow"] = 18] = "MetronomeOverflow";
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["InvalidCommand"] = 19] = "InvalidCommand";
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["MaxChannelsExceeded"] = 20] = "MaxChannelsExceeded";
+  SonareEngineTelemetryError2[SonareEngineTelemetryError2["ParameterBaseOverflow"] = 21] = "ParameterBaseOverflow";
   return SonareEngineTelemetryError2;
 })(SonareEngineTelemetryError || {});
-function toDb(value) {
-  return value > 0 ? 20 * Math.log10(value) : Number.NEGATIVE_INFINITY;
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -2764,6 +3740,16 @@ function clipPageRequestRingFromSharedBuffer(sharedBuffer, fallbackCapacity) {
 function recordOffset(index, capacity, recordBytes) {
   return index % capacity * recordBytes;
 }
+function isUint32Slot(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= 4294967295;
+}
+function toUint32Slot(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!isUint32Slot(resolved)) {
+    throw new RangeError(`${name} must be an integer within [0, 4294967295]`);
+  }
+  return resolved;
+}
 function toSafeInteger(value, fallback) {
   const resolved = typeof value === "bigint" ? Number(value) : value;
   if (resolved === void 0) {
@@ -2783,8 +3769,8 @@ function readInt64Words(view, offset) {
   return view.getInt32(offset + 4, true) * 4294967296 + view.getUint32(offset, true);
 }
 function writeEngineCommandRecord(view, offset, command) {
-  view.setUint32(offset, command.type, true);
-  view.setUint32(offset + 4, command.targetId ?? 0, true);
+  view.setUint32(offset, toUint32Slot(command.type, 0, "type"), true);
+  view.setUint32(offset + 4, toUint32Slot(command.targetId, 0, "targetId"), true);
   writeInt64Words(view, offset + 8, toSafeInteger(command.sampleTime, -1));
   view.setFloat64(offset + 16, command.argFloat ?? 0, true);
   writeInt64Words(view, offset + 24, toSafeInteger(command.argInt, 0));
@@ -2853,43 +3839,337 @@ function magnitudeToDb(value) {
   return value > 1e-12 ? 20 * Math.log10(value) : -120;
 }
 
-// src/worklet/engine-capture-facade.ts
-function configureCapture(ctx, options) {
-  const config = buildCaptureConfig(options, ctx.offlineChannelCount);
-  ctx.offlineEngine.setCaptureBuffer(config.channels, config.bufferFrames);
-  ctx.offlineEngine.setCaptureSource(config.source);
-  ctx.offlineEngine.setRecordOffsetSamples(config.recordOffsetSamples);
-  ctx.offlineEngine.setInputMonitor(config.inputMonitor.enabled, config.inputMonitor.gain);
-  ctx.setCaptureConfig(config);
-  ctx.postSync({ type: "syncCapture", ...config });
-}
-function armRecord(ctx, trackId, enabled) {
-  if (trackId !== 0) {
-    throw new RangeError("Capture is global; armRecord only accepts trackId 0");
-  }
-  if (enabled && !ctx.getCaptureConfig()) {
-    throw new Error("Capture buffer is not configured");
+// src/worklet/guards.ts
+function isWorkletMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
   }
-  ctx.offlineEngine.armCapture(enabled);
-  return ctx.sendCommand({
-    type: 13 /* ArmRecord */,
-    targetId: 0,
-    sampleTime: -1,
-    argInt: enabled ? 1 : 0
-  });
+  return value.type === "scheduleInsertAutomation" || value.type === "setMeterInterval" || value.type === "destroy";
 }
-function punch(ctx, inPpq, outPpq) {
-  const inSample = ctx.offlineEngine.sampleAtPpq(inPpq);
-  const outSample = ctx.offlineEngine.sampleAtPpq(outPpq);
-  ctx.offlineEngine.setCapturePunch(inSample, outSample, true);
-  return ctx.sendCommand({
-    type: 14 /* Punch */,
-    sampleTime: -1,
-    argInt: inSample,
-    argFloat: outSample
-  });
+function isEngineCommandRecord(value) {
+  return isRecord(value) && typeof value.type === "number";
 }
-function captureStatus(ctx) {
+var ENGINE_SYNC_MESSAGE_TYPES = {
+  destroy: true,
+  syncAutomation: true,
+  syncBuiltinInstrument: true,
+  syncBusStripDualPan: true,
+  syncBusStripEqBand: true,
+  syncBusStripInsertBypassed: true,
+  syncBusStripInsertParamByName: true,
+  syncBusStripPan: true,
+  syncBusStripPanLaw: true,
+  syncBusStripPanMode: true,
+  syncCapture: true,
+  syncClearMidiFx: true,
+  syncClearMidiInputSource: true,
+  syncClipPage: true,
+  syncClipPageClear: true,
+  syncClipPageCommit: true,
+  syncClipPageDestroy: true,
+  syncClipPagePrefetchFrames: true,
+  syncClipPageProvider: true,
+  syncClips: true,
+  syncClipsDelta: true,
+  syncExternalMidiClock: true,
+  syncLoadSoundFont: true,
+  syncMarkers: true,
+  syncMasterStripEqBand: true,
+  syncMasterStripInsertBypassed: true,
+  syncMasterStripInsertParamByName: true,
+  syncMetronome: true,
+  syncMidiCc: true,
+  syncMidiCcBinding: true,
+  syncMidiChannelPressure: true,
+  syncMidiClips: true,
+  syncMidiDestinationExternal: true,
+  syncMidiFx: true,
+  syncMidiInputChannelPressure: true,
+  syncMidiInputCc: true,
+  syncMidiInputNoteOff: true,
+  syncMidiInputNoteOn: true,
+  syncMidiInputPitchBend: true,
+  syncMidiInputPolyPressure: true,
+  syncMidiInputSource: true,
+  syncMidiNoteOff: true,
+  syncMidiNoteOn: true,
+  syncMidiPanic: true,
+  syncMidiPitchBend: true,
+  syncMidiPolyPressure: true,
+  syncMidiSysex: true,
+  syncMidiUmp: true,
+  syncMixer: true,
+  syncParameters: true,
+  syncSf2Instrument: true,
+  syncSynthInstrument: true,
+  syncTempo: true,
+  syncTrackStripChannelDelaySamples: true,
+  syncTrackStripDualPan: true,
+  syncTrackStripEqBand: true,
+  syncTrackStripInsertBypassed: true,
+  syncTrackStripInsertParamByName: true,
+  syncTrackStripPan: true,
+  syncTrackStripPanLaw: true,
+  syncTrackStripPanMode: true,
+  syncWarpVoiceCapacity: true
+};
+var engineSyncMessageTypes = new Set(Object.keys(ENGINE_SYNC_MESSAGE_TYPES));
+function isEngineSyncMessage(value) {
+  return isRecord(value) && typeof value.type === "string" && engineSyncMessageTypes.has(value.type);
+}
+function isEngineCaptureRequestMessage(value) {
+  return isRecord(value) && value.type === "captureRequest" && typeof value.requestId === "number" && (value.op === "status" || value.op === "read" || value.op === "reset");
+}
+function isCaptureStatus(value) {
+  return isRecord(value) && typeof value.capturedFrames === "number" && Number.isSafeInteger(value.capturedFrames) && value.capturedFrames >= 0 && typeof value.overflowCount === "number" && Number.isSafeInteger(value.overflowCount) && value.overflowCount >= 0 && typeof value.armed === "boolean" && typeof value.punchEnabled === "boolean" && (value.source === "input" || value.source === "output") && typeof value.recordOffsetSamples === "number" && Number.isSafeInteger(value.recordOffsetSamples);
+}
+function isCaptureChannel(value) {
+  return value instanceof Float32Array && typeof ArrayBuffer !== "undefined" && value.buffer instanceof ArrayBuffer;
+}
+function isCaptureChannels(value) {
+  return Array.isArray(value) && value.every((channel) => isCaptureChannel(channel));
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function engineCaptureResponseRequestId(value) {
+  if (!isRecord(value) || value.type !== "captureResponse" || typeof value.requestId !== "number" || !Number.isSafeInteger(value.requestId)) {
+    return void 0;
+  }
+  return value.requestId;
+}
+function isEngineCaptureResponseMessage(value) {
+  const requestId = engineCaptureResponseRequestId(value);
+  if (requestId === void 0 || !isRecord(value)) {
+    return false;
+  }
+  if (value.ok === false) {
+    return typeof value.error === "string" && !hasOwn(value, "status") && !hasOwn(value, "channels");
+  }
+  if (value.ok !== true || hasOwn(value, "error")) {
+    return false;
+  }
+  const hasStatus = hasOwn(value, "status");
+  const hasChannels = hasOwn(value, "channels");
+  if (hasStatus && hasChannels) {
+    return false;
+  }
+  if (hasStatus) {
+    return isCaptureStatus(value.status);
+  }
+  if (hasChannels) {
+    return isCaptureChannels(value.channels);
+  }
+  return true;
+}
+function isEngineCaptureResponseForOperation(response, op) {
+  if (!response.ok) {
+    return true;
+  }
+  switch (op) {
+    case "status":
+      return "status" in response;
+    case "read":
+      return "channels" in response;
+    case "reset":
+      return !("status" in response) && !("channels" in response);
+  }
+}
+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";
+}
+var isOptionalNumber = (value) => value === void 0 || typeof value === "number";
+function isPlaybackMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  switch (value.type) {
+    case "config":
+      return typeof value.config === "string";
+    case "orientation":
+      return typeof value.yaw === "number" && isOptionalNumber(value.pitch) && isOptionalNumber(value.roll);
+    case "reset":
+    case "diagnostics":
+    case "destroy":
+      return true;
+    default:
+      return false;
+  }
+}
+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 isExternalMidiBatchMessage(value) {
+  return isRecord(value) && value.type === "externalMidi" && Array.isArray(value.events);
+}
+function isClipPageRequestMessage(value) {
+  return isRecord(value) && value.type === "clipPageRequest" && Array.isArray(value.requests) && value.requests.every(
+    (request) => isRecord(request) && typeof request.clipId === "number" && typeof request.pageIndex === "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);
+}
+function requireIntegerOption(value, fallback, name, minimum) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < minimum) {
+    throw new RangeError(`${name} must be an integer of at least ${minimum}`);
+  }
+  return resolved;
+}
+function requireInteger(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved)) {
+    throw new RangeError(`${name} must be an integer`);
+  }
+  return resolved;
+}
+function requireChannelCount(channelCount, fallback) {
+  return requireIntegerOption(channelCount, fallback, "channelCount", 1);
+}
+
+// src/worklet/engine-offline.ts
+function buildCaptureConfig(options, defaultChannels) {
+  return {
+    // bufferFrames has no default; NaN makes the guard refuse an absent value.
+    bufferFrames: requireIntegerOption(options.bufferFrames, Number.NaN, "bufferFrames", 1),
+    channels: requireChannelCount(options.channels, defaultChannels),
+    source: options.source ?? "output",
+    recordOffsetSamples: requireInteger(options.recordOffsetSamples, 0, "recordOffsetSamples"),
+    inputMonitor: {
+      enabled: Boolean(options.inputMonitor?.enabled),
+      gain: options.inputMonitor?.gain ?? 1
+    }
+  };
+}
+function buildTransportFacade(ctx) {
+  return {
+    play: (sampleTime = -1) => {
+      const ok = ctx.realtimeNode.play(sampleTime);
+      if (ok) {
+        ctx.setTransportPlaying(true);
+      }
+      return ok;
+    },
+    stop: (sampleTime = -1) => {
+      const ok = ctx.realtimeNode.stop(sampleTime);
+      if (ok) {
+        ctx.setTransportPlaying(false);
+        ctx.flushPendingInstrumentSync();
+      }
+      return ok;
+    },
+    seekPpq: (ppq, sampleTime = -1) => {
+      ctx.offlineEngine.seekPpq(ppq, sampleTime);
+      const ok = ctx.realtimeNode.seekPpq(ppq, sampleTime);
+      ctx.flushOfflineMirror();
+      return ok;
+    },
+    seekSeconds: (seconds, sampleTime = -1) => {
+      const timelineSample = Math.max(0, Math.round(seconds * ctx.sampleRate));
+      ctx.offlineEngine.seekSample(timelineSample, sampleTime);
+      const ok = ctx.realtimeNode.seekSample(timelineSample, sampleTime);
+      ctx.flushOfflineMirror();
+      return ok;
+    },
+    setTempo: (bpm) => ctx.setTempo(bpm),
+    setTempoSegments: (segments) => ctx.setTempoSegments(segments),
+    setLoop: (startPpq, endPpq, enabled = true) => ctx.setLoop(startPpq, endPpq, enabled)
+  };
+}
+function normalizeTrackLanes(existing, 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 RangeError(`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 < existing.length; index++) {
+    if (ids[index] !== existing[index]) {
+      throw new Error(
+        "Mixer lanes are append-only: keep existing lanes in order and only append new track ids"
+      );
+    }
+  }
+  return { entries, ids };
+}
+function resolveMarkerSet(markers, nextMarkerId) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  let counter = nextMarkerId;
+  for (const marker2 of markers) {
+    if (!Number.isFinite(marker2.ppq) || marker2.ppq < 0) {
+      throw new RangeError(`Invalid marker ppq: ${String(marker2.ppq)}`);
+    }
+    if (marker2.id !== void 0) {
+      if (!Number.isInteger(marker2.id) || marker2.id <= 0) {
+        throw new RangeError(`Invalid marker id: ${String(marker2.id)}`);
+      }
+      if (seen.has(marker2.id)) {
+        throw new Error(`Duplicate marker id: ${marker2.id}`);
+      }
+    }
+    const id = marker2.id ?? counter++;
+    seen.add(id);
+    if (id >= counter) {
+      counter = id + 1;
+    }
+    resolved.push({ id, ppq: marker2.ppq, name: marker2.name ?? "" });
+  }
+  return { resolved, nextMarkerId: counter };
+}
+
+// src/worklet/engine-capture-facade.ts
+function configureCapture(ctx, options) {
+  const config = buildCaptureConfig(options, ctx.offlineChannelCount);
+  ctx.offlineEngine.setCaptureBuffer(config.channels, config.bufferFrames);
+  ctx.offlineEngine.setCaptureSource(config.source);
+  ctx.offlineEngine.setRecordOffsetSamples(config.recordOffsetSamples);
+  ctx.offlineEngine.setInputMonitor(config.inputMonitor.enabled, config.inputMonitor.gain);
+  ctx.setCaptureConfig(config);
+  ctx.postSync({ type: "syncCapture", ...config });
+}
+function armRecord(ctx, trackId, enabled) {
+  if (trackId !== 0) {
+    throw new RangeError("Capture is global; armRecord only accepts trackId 0");
+  }
+  if (enabled && !ctx.getCaptureConfig()) {
+    throw new Error("Capture buffer is not configured");
+  }
+  ctx.offlineEngine.armCapture(enabled);
+  return ctx.sendCommand({
+    type: 13 /* ArmRecord */,
+    targetId: 0,
+    sampleTime: -1,
+    argInt: enabled ? 1 : 0
+  });
+}
+function punch(ctx, inPpq, outPpq) {
+  const inSample = ctx.offlineEngine.sampleAtPpq(inPpq);
+  const outSample = ctx.offlineEngine.sampleAtPpq(outPpq);
+  ctx.offlineEngine.setCapturePunch(inSample, outSample, true);
+  return ctx.sendCommand({
+    type: 14 /* Punch */,
+    sampleTime: -1,
+    argInt: inSample,
+    argFloat: outSample
+  });
+}
+function captureStatus(ctx) {
   return ctx.realtimeNode.requestCaptureStatus();
 }
 function capturedAudio(ctx) {
@@ -3045,16 +4325,191 @@ function syncMarkers(ctx) {
 }
 
 // src/worklet/engine-mixer-facade.ts
+function emptyStripJson(target) {
+  switch (target.kind) {
+    case "track":
+      return `{"version":1,"strips":[{"id":"track-${target.trackId}"}],"buses":[],"connections":[]}`;
+    case "bus":
+      return `{"version":1,"strips":[],"buses":[{"id":"bus-${target.busId}"}],"connections":[]}`;
+    case "master":
+      return '{"version":1,"strips":[{"id":"master"}],"buses":[],"connections":[]}';
+  }
+}
+function pruneStripSidechains(ctx, target, sceneJson) {
+  const scene = JSON.parse(sceneJson);
+  const entry = target.kind === "bus" ? scene.buses?.[0] : scene.strips?.[0];
+  const insertCount = Array.isArray(entry?.inserts) ? entry.inserts.length : 0;
+  if (target.kind === "track") {
+    for (const [key, binding] of ctx.laneSidechains) {
+      if (binding.trackId === target.trackId && binding.insertIndex >= insertCount) {
+        ctx.laneSidechains.delete(key);
+      }
+    }
+  } else if (target.kind === "bus") {
+    for (const [key, binding] of ctx.busSidechains) {
+      if (binding.busId === target.busId && binding.insertIndex >= insertCount) {
+        ctx.busSidechains.delete(key);
+      }
+    }
+  } else {
+    for (const [key, binding] of ctx.masterSidechains) {
+      if (binding.insertIndex >= insertCount) {
+        ctx.masterSidechains.delete(key);
+      }
+    }
+  }
+}
+function hasInsertParamOverrides(overrides, target) {
+  for (const override of overrides.values()) {
+    if (sameStripTarget(override.target, target)) {
+      return true;
+    }
+  }
+  return false;
+}
+function applyFullStripJson(engine, target, sceneJson, resetInserts) {
+  const apply = (json) => {
+    switch (target.kind) {
+      case "track":
+        engine.setTrackStripJson(target.trackId, json);
+        break;
+      case "bus":
+        engine.setBusStripJson(target.busId, json);
+        break;
+      case "master":
+        engine.setMasterStripJson(json);
+        break;
+    }
+  };
+  engine.applyCommandsDueNowPreservingFuture();
+  apply(sceneJson);
+  if (resetInserts) {
+    switch (target.kind) {
+      case "track":
+        engine.clearTrackInsertParameterBases(target.trackId);
+        break;
+      case "bus":
+        engine.clearBusInsertParameterBases(target.busId);
+        break;
+      case "master":
+        engine.clearMasterInsertParameterBases();
+        break;
+    }
+    apply(emptyStripJson(target));
+    apply(sceneJson);
+  }
+}
+function insertParamOverrideKey(override) {
+  const targetId = override.target.kind === "track" ? override.target.trackId : override.target.kind === "bus" ? override.target.busId : "master";
+  return JSON.stringify([override.target.kind, targetId, override.insertIndex, override.paramName]);
+}
+function clearInsertParamOverrides(overrides, target) {
+  for (const [key, override] of overrides) {
+    if (sameStripTarget(override.target, target)) {
+      overrides.delete(key);
+    }
+  }
+}
+function sameStripTarget(left, right) {
+  if (left.kind !== right.kind) {
+    return false;
+  }
+  if (left.kind === "track" && right.kind === "track") {
+    return left.trackId === right.trackId;
+  }
+  if (left.kind === "bus" && right.kind === "bus") {
+    return left.busId === right.busId;
+  }
+  return left.kind === "master" && right.kind === "master";
+}
+function flattenInsertParamOverride(override) {
+  switch (override.target.kind) {
+    case "track":
+      return {
+        kind: "track",
+        trackId: override.target.trackId,
+        insertIndex: override.insertIndex,
+        paramName: override.paramName,
+        value: override.value
+      };
+    case "bus":
+      return {
+        kind: "bus",
+        busId: override.target.busId,
+        insertIndex: override.insertIndex,
+        paramName: override.paramName,
+        value: override.value
+      };
+    case "master":
+      return {
+        kind: "master",
+        insertIndex: override.insertIndex,
+        paramName: override.paramName,
+        value: override.value
+      };
+  }
+}
+function cachedStripJson(ctx, target) {
+  switch (target.kind) {
+    case "track":
+      return ctx.trackStripJson.get(target.trackId);
+    case "bus":
+      return ctx.busStripJson.get(target.busId);
+    case "master":
+      return ctx.getMasterStripJson();
+  }
+}
+function cacheStripJson(ctx, target, sceneJson) {
+  switch (target.kind) {
+    case "track":
+      ctx.trackStripJson.set(target.trackId, sceneJson);
+      return;
+    case "bus":
+      ctx.busStripJson.set(target.busId, sceneJson);
+      return;
+    case "master":
+      ctx.cacheMasterStripJson(sceneJson);
+      return;
+  }
+}
 function mixerLanes(ctx) {
   return buildMixerLanes(ctx.trackLaneIds, ctx.trackSends, ctx.trackOutputBus);
 }
-function syncMixer(ctx) {
+function syncMixer(ctx, busesAlreadyApplied = false, forceInsertResets = []) {
   const lanes = mixerLanes(ctx);
   const buses = ctx.buses.map((bus) => ({ ...bus }));
-  ctx.offlineEngine.setTrackBuses(buses);
+  if (!busesAlreadyApplied) {
+    ctx.offlineEngine.setTrackBuses(buses);
+  }
   if (lanes.length > 0) {
+    ctx.offlineEngine.settleInsertParameters();
     ctx.offlineEngine.setTrackLanes(lanes);
   }
+  if (forceInsertResets.length > 0) {
+    for (const binding of ctx.laneSidechains.values()) {
+      ctx.offlineEngine.setLaneSidechain(
+        binding.trackId,
+        binding.insertIndex,
+        binding.sourceTrackId
+      );
+    }
+    for (const binding of ctx.busSidechains.values()) {
+      ctx.offlineEngine.setBusSidechain(
+        binding.busId,
+        binding.insertIndex,
+        binding.sourceKind,
+        binding.sourceId
+      );
+    }
+    for (const binding of ctx.masterSidechains.values()) {
+      ctx.offlineEngine.setMasterSidechain(
+        binding.insertIndex,
+        binding.sourceKind,
+        binding.sourceId
+      );
+    }
+  }
+  replayInsertParamOverrides(ctx, lanes, buses);
   const trackStrips = Array.from(ctx.trackStripJson, ([trackId, sceneJson]) => ({
     trackId,
     sceneJson
@@ -3063,6 +4518,10 @@ function syncMixer(ctx) {
     busId,
     sceneJson
   }));
+  const insertParamOverrides = Array.from(
+    ctx.insertParamOverrides.values(),
+    flattenInsertParamOverride
+  );
   ctx.postSync({
     type: "syncMixer",
     lanes,
@@ -3070,9 +4529,49 @@ function syncMixer(ctx) {
     trackStrips,
     laneSidechains: Array.from(ctx.laneSidechains.values()),
     busStrips,
-    masterStripJson: ctx.getMasterStripJson()
+    masterStripJson: ctx.getMasterStripJson(),
+    busSidechains: Array.from(ctx.busSidechains.values()),
+    masterSidechains: Array.from(ctx.masterSidechains.values()),
+    ...insertParamOverrides.length > 0 ? { insertParamOverrides } : {},
+    ...forceInsertResets.length > 0 ? { forceInsertResets } : {}
   });
 }
+function replayInsertParamOverrides(ctx, lanes = mixerLanes(ctx), buses = ctx.buses) {
+  const activeTrackIds = new Set(lanes.map((lane) => lane.trackId));
+  const activeBusIds = new Set(buses.map((bus) => bus.busId));
+  for (const [key, override] of ctx.insertParamOverrides) {
+    const active = override.target.kind === "track" ? activeTrackIds.has(override.target.trackId) : override.target.kind === "bus" ? activeBusIds.has(override.target.busId) : true;
+    if (!active) {
+      ctx.insertParamOverrides.delete(key);
+      continue;
+    }
+    switch (override.target.kind) {
+      case "track":
+        ctx.offlineEngine.restoreTrackStripInsertParamByName(
+          override.target.trackId,
+          override.insertIndex,
+          override.paramName,
+          override.value
+        );
+        break;
+      case "bus":
+        ctx.offlineEngine.restoreBusStripInsertParamByName(
+          override.target.busId,
+          override.insertIndex,
+          override.paramName,
+          override.value
+        );
+        break;
+      case "master":
+        ctx.offlineEngine.restoreMasterStripInsertParamByName(
+          override.insertIndex,
+          override.paramName,
+          override.value
+        );
+        break;
+    }
+  }
+}
 function setTrackLanes(ctx, lanes) {
   const { entries, ids } = normalizeTrackLanes(ctx.trackLaneIds, lanes);
   for (const entry of entries) {
@@ -3112,143 +4611,116 @@ function setLaneSidechain(ctx, target, insertIndex, sourceTarget) {
     const sourceIndex = ctx.ensureTrackLane(sourceTarget);
     sourceTrackId = ctx.trackLaneIds[sourceIndex];
   }
+  ctx.offlineEngine.setLaneSidechain(trackId, insertIndex, sourceTrackId);
   if (sourceTrackId === 0) {
     ctx.laneSidechains.delete(key);
   } else {
     ctx.laneSidechains.set(key, { trackId, insertIndex, sourceTrackId });
   }
-  ctx.offlineEngine.setLaneSidechain(trackId, insertIndex, sourceTrackId);
   ctx.postSync({
     type: "syncMixer",
+    sidechainDelta: true,
     lanes: ctx.mixerLanes(),
-    laneSidechains: [{ trackId, insertIndex, sourceTrackId }]
-  });
-}
-function setSends(ctx, target, sends) {
-  const laneIndex = ctx.ensureTrackLane(target);
-  const trackId = ctx.trackLaneIds[laneIndex];
-  ctx.trackSends.set(
-    trackId,
-    sends.map((send) => ({ ...send }))
-  );
-  ctx.syncMixer();
-}
-function setTrackBuses(ctx, buses) {
-  ctx.buses.splice(0, ctx.buses.length, ...buses.map((bus) => ({ ...bus })));
-  ctx.syncMixer();
-}
-function setBusGain(ctx, busId, db) {
-  const busIndex = ctx.ensureBus(busId);
-  ctx.buses[busIndex] = { ...ctx.buses[busIndex], busId, gainDb: db };
-  ctx.offlineEngine.setTrackBuses(ctx.buses);
-  return ctx.sendSmoothedParam(engineMixerBusTarget(busIndex, ENGINE_MIXER_PARAM_FADER_DB), db);
-}
-function setBusStripJson(ctx, busId, sceneJson) {
-  ctx.ensureBus(busId);
-  ctx.offlineEngine.setBusStripJson(busId, sceneJson);
-  ctx.busStripJson.set(busId, sceneJson);
-  ctx.syncMixer();
-}
-
-// 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 === "syncClipPageProvider" || value.type === "syncClipPage" || value.type === "syncClipPageClear" || value.type === "syncClipPageCommit" || value.type === "syncClipPageDestroy" || value.type === "syncMidiClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation" || value.type === "syncTempo" || value.type === "syncMixer" || value.type === "syncCapture" || value.type === "syncTrackStripEqBand" || value.type === "syncMasterStripEqBand" || value.type === "syncTrackStripInsertBypassed" || value.type === "syncMasterStripInsertBypassed" || value.type === "syncTrackStripInsertParamByName" || value.type === "syncMasterStripInsertParamByName" || value.type === "syncBusStripInsertParamByName" || value.type === "syncTrackStripPan" || value.type === "syncTrackStripPanLaw" || value.type === "syncTrackStripPanMode" || value.type === "syncTrackStripDualPan" || value.type === "syncTrackStripChannelDelaySamples" || value.type === "syncBuiltinInstrument" || value.type === "syncSynthInstrument" || value.type === "syncSf2Instrument" || value.type === "syncLoadSoundFont" || value.type === "syncMidiFx" || value.type === "syncClearMidiFx" || value.type === "syncMidiNoteOn" || value.type === "syncMidiNoteOff" || value.type === "syncMidiCc" || value.type === "syncMidiUmp" || value.type === "syncMidiSysex" || value.type === "syncMidiPanic" || value.type === "syncMidiDestinationExternal" || value.type === "syncExternalMidiClock" || value.type === "destroy";
-}
-function isEngineCaptureRequestMessage(value) {
-  return isRecord(value) && value.type === "captureRequest" && typeof value.requestId === "number" && (value.op === "status" || value.op === "read" || value.op === "reset");
-}
-function isCaptureStatus(value) {
-  return isRecord(value) && typeof value.capturedFrames === "number" && Number.isSafeInteger(value.capturedFrames) && value.capturedFrames >= 0 && typeof value.overflowCount === "number" && Number.isSafeInteger(value.overflowCount) && value.overflowCount >= 0 && typeof value.armed === "boolean" && typeof value.punchEnabled === "boolean" && (value.source === "input" || value.source === "output") && typeof value.recordOffsetSamples === "number" && Number.isSafeInteger(value.recordOffsetSamples);
-}
-function isCaptureChannel(value) {
-  return value instanceof Float32Array && typeof ArrayBuffer !== "undefined" && value.buffer instanceof ArrayBuffer;
-}
-function isCaptureChannels(value) {
-  return Array.isArray(value) && value.every((channel) => isCaptureChannel(channel));
-}
-function hasOwn(value, key) {
-  return Object.prototype.hasOwnProperty.call(value, key);
-}
-function engineCaptureResponseRequestId(value) {
-  if (!isRecord(value) || value.type !== "captureResponse" || typeof value.requestId !== "number" || !Number.isSafeInteger(value.requestId)) {
-    return void 0;
-  }
-  return value.requestId;
-}
-function isEngineCaptureResponseMessage(value) {
-  const requestId = engineCaptureResponseRequestId(value);
-  if (requestId === void 0 || !isRecord(value)) {
-    return false;
-  }
-  if (value.ok === false) {
-    return typeof value.error === "string" && !hasOwn(value, "status") && !hasOwn(value, "channels");
-  }
-  if (value.ok !== true || hasOwn(value, "error")) {
-    return false;
-  }
-  const hasStatus = hasOwn(value, "status");
-  const hasChannels = hasOwn(value, "channels");
-  if (hasStatus && hasChannels) {
-    return false;
-  }
-  if (hasStatus) {
-    return isCaptureStatus(value.status);
+    laneSidechains: [{ trackId, insertIndex, sourceTrackId }]
+  });
+}
+function setBusSidechain(ctx, busId, insertIndex, kind, sourceId) {
+  const sourceKind = sidechainSourceKindCode(kind);
+  ctx.ensureBus(busId);
+  ensureSidechainSource(ctx, sourceKind, sourceId);
+  ctx.offlineEngine.setBusSidechain(busId, insertIndex, sourceKind, sourceId);
+  const key = `${busId}:${insertIndex}`;
+  if (sourceId === 0) {
+    ctx.busSidechains.delete(key);
+  } else {
+    ctx.busSidechains.set(key, { busId, insertIndex, sourceKind, sourceId });
   }
-  if (hasChannels) {
-    return isCaptureChannels(value.channels);
+  ctx.postSync({
+    type: "syncMixer",
+    sidechainDelta: true,
+    lanes: ctx.mixerLanes(),
+    busSidechains: [{ busId, insertIndex, sourceKind, sourceId }]
+  });
+}
+function setMasterSidechain(ctx, insertIndex, kind, sourceId) {
+  const sourceKind = sidechainSourceKindCode(kind);
+  ensureSidechainSource(ctx, sourceKind, sourceId);
+  ctx.offlineEngine.setMasterSidechain(insertIndex, sourceKind, sourceId);
+  if (sourceId === 0) {
+    ctx.masterSidechains.delete(insertIndex);
+  } else {
+    ctx.masterSidechains.set(insertIndex, { insertIndex, sourceKind, sourceId });
   }
-  return true;
+  ctx.postSync({
+    type: "syncMixer",
+    sidechainDelta: true,
+    lanes: ctx.mixerLanes(),
+    masterSidechains: [{ insertIndex, sourceKind, sourceId }]
+  });
 }
-function isEngineCaptureResponseForOperation(response, op) {
-  if (!response.ok) {
-    return true;
+function ensureSidechainSource(ctx, sourceKind, sourceId) {
+  if (sourceId === 0) {
+    return;
   }
-  switch (op) {
-    case "status":
-      return "status" in response;
-    case "read":
-      return "channels" in response;
-    case "reset":
-      return !("status" in response) && !("channels" in response);
+  if (sourceKind === 1) {
+    ctx.ensureBus(sourceId);
+  } else {
+    ctx.ensureTrackLane(sourceId);
   }
 }
-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 setSends(ctx, target, sends) {
+  const laneIndex = ctx.ensureTrackLane(target);
+  const trackId = ctx.trackLaneIds[laneIndex];
+  ctx.trackSends.set(
+    trackId,
+    sends.map((send) => ({ ...send }))
+  );
+  ctx.syncMixer();
 }
-function isRealtimeVoiceChangerMessage(value) {
-  if (!isRecord(value) || typeof value.type !== "string") {
-    return false;
+function setTrackBuses(ctx, buses) {
+  ctx.offlineEngine.setTrackBuses(buses);
+  const retainedBusIds = new Set(buses.map((bus) => bus.busId));
+  for (const bus of ctx.buses) {
+    if (!retainedBusIds.has(bus.busId)) {
+      ctx.clearInsertAutomationLanes({ kind: "bus", busId: bus.busId }, true);
+    }
   }
-  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 isExternalMidiBatchMessage(value) {
-  return isRecord(value) && value.type === "externalMidi" && Array.isArray(value.events);
+  ctx.buses.splice(0, ctx.buses.length, ...buses.map((bus) => ({ ...bus })));
+  const activeBusIds = new Set(ctx.buses.map((bus) => bus.busId));
+  for (const busId of ctx.busStripJson.keys()) {
+    if (!activeBusIds.has(busId)) {
+      ctx.busStripJson.delete(busId);
+    }
+  }
+  for (const [key, binding] of ctx.busSidechains) {
+    if (!activeBusIds.has(binding.busId) || binding.sourceKind === 1 && !activeBusIds.has(binding.sourceId)) {
+      ctx.busSidechains.delete(key);
+    }
+  }
+  for (const [key, binding] of ctx.masterSidechains) {
+    if (binding.sourceKind === 1 && !activeBusIds.has(binding.sourceId)) {
+      ctx.masterSidechains.delete(key);
+    }
+  }
+  syncMixer(ctx, true);
 }
-function isClipPageRequestMessage(value) {
-  return isRecord(value) && value.type === "clipPageRequest" && Array.isArray(value.requests) && value.requests.every(
-    (request) => isRecord(request) && typeof request.clipId === "number" && typeof request.pageIndex === "number"
-  );
+function setBusGain(ctx, busId, db) {
+  const busIndex = ctx.ensureBus(busId);
+  ctx.buses[busIndex] = { ...ctx.buses[busIndex], busId, gainDb: db };
+  return ctx.sendSmoothedParam(engineMixerBusTarget(busIndex, ENGINE_MIXER_PARAM_FADER_DB), db);
 }
-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);
+function setBusStripJson(ctx, busId, sceneJson) {
+  ctx.ensureBus(busId);
+  const target = { kind: "bus", busId };
+  const resetInserts = ctx.busStripJson.has(busId) && ctx.busStripJson.get(busId) !== sceneJson || hasInsertParamOverrides(ctx.insertParamOverrides, target);
+  applyFullStripJson(ctx.offlineEngine, target, sceneJson, resetInserts);
+  if (resetInserts) {
+    ctx.clearInsertAutomationLanes(target);
+  }
+  pruneStripSidechains(ctx, target, sceneJson);
+  ctx.busStripJson.set(busId, sceneJson);
+  clearInsertParamOverrides(ctx.insertParamOverrides, target);
+  ctx.syncMixer(resetInserts ? [target] : []);
 }
 
 // src/worklet/engine-node.ts
@@ -3265,15 +4737,17 @@ function isTrackMonitorMode(value) {
   const mode = typeof value === "bigint" ? Number(value) : value;
   return typeof mode === "number" && Number.isSafeInteger(mode) && mode >= 0 && mode <= 2;
 }
-function isTrackMonitorLaneIndex(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= 4294967295;
-}
 function isValidCommandRecord(command) {
   const type = Number(command.type);
   if (!Number.isSafeInteger(type) || type < 0 /* SetParam */ || type > 17 /* SeekMarker */ && type !== 26 /* SetTrackMonitorMode */) {
     return false;
   }
-  return (command.targetId === void 0 || Number.isSafeInteger(command.targetId)) && (command.argFloat === void 0 || Number.isFinite(command.argFloat)) && isFiniteInteger(command.argInt) && isFiniteInteger(command.sampleTime) && (type !== 26 /* SetTrackMonitorMode */ || isTrackMonitorLaneIndex(command.targetId) && isTrackMonitorMode(command.argInt));
+  return (
+    // The record writer refuses a targetId outside the slot by throwing, and
+    // this path answers false instead, so it must reject the same domain here.
+    (command.targetId === void 0 || isUint32Slot(command.targetId)) && (command.argFloat === void 0 || Number.isFinite(command.argFloat)) && isFiniteInteger(command.argInt) && isFiniteInteger(command.sampleTime) && // A track-monitor command cannot infer a lane: its target is required.
+    (type !== 26 /* SetTrackMonitorMode */ || isUint32Slot(command.targetId) && isTrackMonitorMode(command.argInt))
+  );
 }
 var AUDIO_WORKLET_RENDER_QUANTUM = 128;
 function workletBlockSize(blockSize) {
@@ -3318,6 +4792,9 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       this.resolveReady();
     }
     this.node.port.onmessage = (event) => {
+      if (this.destroyed) {
+        return;
+      }
       const captureRequestId = engineCaptureResponseRequestId(event.data);
       if (captureRequestId !== void 0) {
         const pending = this.captureRequests.get(captureRequestId);
@@ -3399,18 +4876,65 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         "SharedArrayBuffer mode requested but SharedArrayBuffer/Atomics are unavailable."
       );
     }
-    const commandRing = mode === "sab" ? createSonareEngineCommandRingBuffer(options.commandRingCapacity ?? 128) : void 0;
-    const telemetryRing = mode === "sab" ? createSonareEngineTelemetryRingBuffer(options.telemetryRingCapacity ?? 128) : void 0;
-    const meterRing = mode === "sab" ? createSonareMeterRingBuffer(options.meterRingCapacity ?? 128) : void 0;
-    const scopeIntervalFrames = Math.max(0, Math.floor(options.scopeIntervalFrames ?? 0));
-    const scopeRing = mode === "sab" && scopeIntervalFrames > 0 ? createSonareScopeRingBuffer(options.scopeRingCapacity ?? 64, options.scopeBands ?? 48) : void 0;
-    const clipPageRequestRing = mode === "sab" ? createSonareClipPageRequestRingBuffer(options.clipPageRequestRingCapacity ?? 128) : void 0;
-    const externalMidiRing = mode === "sab" ? createSonareExternalMidiRingBuffer(options.externalMidiRingCapacity ?? 256) : void 0;
-    const channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
+    const commandRingCapacity = requireIntegerOption(
+      options.commandRingCapacity,
+      128,
+      "commandRingCapacity",
+      1
+    );
+    if (commandRingCapacity > 65536) {
+      throw new RangeError("commandRingCapacity must be at most 65536");
+    }
+    const telemetryRingCapacity = requireIntegerOption(
+      options.telemetryRingCapacity,
+      128,
+      "telemetryRingCapacity",
+      1
+    );
+    const meterRingCapacity = requireIntegerOption(
+      options.meterRingCapacity,
+      128,
+      "meterRingCapacity",
+      1
+    );
+    const scopeRingCapacity = requireIntegerOption(
+      options.scopeRingCapacity,
+      64,
+      "scopeRingCapacity",
+      1
+    );
+    const scopeBands = requireIntegerOption(options.scopeBands, 48, "scopeBands", 1);
+    const clipPageRequestRingCapacity = requireIntegerOption(
+      options.clipPageRequestRingCapacity,
+      128,
+      "clipPageRequestRingCapacity",
+      1
+    );
+    const externalMidiRingCapacity = requireIntegerOption(
+      options.externalMidiRingCapacity,
+      256,
+      "externalMidiRingCapacity",
+      1
+    );
+    const commandRing = mode === "sab" ? createSonareEngineCommandRingBuffer(commandRingCapacity) : void 0;
+    const telemetryRing = mode === "sab" ? createSonareEngineTelemetryRingBuffer(telemetryRingCapacity) : void 0;
+    const meterRing = mode === "sab" ? createSonareMeterRingBuffer(meterRingCapacity) : void 0;
+    const scopeIntervalFrames = requireIntegerOption(
+      options.scopeIntervalFrames,
+      0,
+      "scopeIntervalFrames",
+      0
+    );
+    const scopeRing = mode === "sab" && scopeIntervalFrames > 0 ? createSonareScopeRingBuffer(scopeRingCapacity, scopeBands) : void 0;
+    const clipPageRequestRing = mode === "sab" ? createSonareClipPageRequestRingBuffer(clipPageRequestRingCapacity) : void 0;
+    const externalMidiRing = mode === "sab" ? createSonareExternalMidiRingBuffer(externalMidiRingCapacity) : void 0;
+    const channelCount = requireChannelCount(options.channelCount, 2);
+    const cueOutput = options.cueOutput === true;
     const processorOptions = {
       sampleRate: options.sampleRate ?? context.sampleRate,
       blockSize,
       channelCount,
+      cueOutput,
       commandSharedBuffer: commandRing?.sharedBuffer,
       commandRingCapacity: commandRing?.capacity,
       telemetrySharedBuffer: telemetryRing?.sharedBuffer,
@@ -3432,8 +4956,10 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     const factory = options.nodeFactory ?? ((ctx, name, nodeOptions) => new AudioWorkletNode(ctx, name, nodeOptions));
     const node = factory(context, processorName, {
       numberOfInputs: 1,
-      numberOfOutputs: 1,
-      outputChannelCount: [channelCount],
+      // The cue bus needs its own output; a single-output node keeps the
+      // historical mix where process() folds the cue into the program.
+      numberOfOutputs: cueOutput ? 2 : 1,
+      outputChannelCount: cueOutput ? [channelCount, channelCount] : [channelCount],
       processorOptions
     });
     return new _SonareRealtimeEngineNode(
@@ -3446,6 +4972,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         audioWorklet,
         clipPageRequestsRealtimeSafe: mode === "sab",
         externalMidiRealtimeSafe: mode === "sab",
+        cueOutput,
         engineAbiVersion: detectedCapabilities?.engineAbiVersion,
         expectedEngineAbiVersion: detectedCapabilities?.expectedEngineAbiVersion,
         abiCompatible: detectedCapabilities?.abiCompatible,
@@ -3678,6 +5205,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.scopeListeners.clear();
     this.midiOutListeners.clear();
     this.clipPageRequestListeners.clear();
+    this.syncErrorListeners.clear();
+    this.node.port.onmessage = null;
   }
   emitTelemetry(telemetry) {
     for (const listener of this.telemetryListeners) {
@@ -3817,6 +5346,9 @@ function resolveBusInsertAutomationId(ctx, busId, insertIndex, paramName) {
   ctx.ensureBus(busId);
   return ctx.offlineEngine.resolveBusInsertAutomationId(busId, insertIndex, paramName);
 }
+function resolveInstrumentAutomationId(ctx, destinationId, paramName) {
+  return ctx.offlineEngine.resolveInstrumentAutomationId(destinationId, paramName);
+}
 function automationLaneCount(ctx) {
   return ctx.offlineEngine.automationLaneCount();
 }
@@ -3841,14 +5373,41 @@ function clearParameters(ctx) {
 function trackIdFor(ctx, target) {
   return ctx.trackLaneIds[ctx.ensureTrackLane(target)];
 }
+function mergeStripJson(ctx, target, update) {
+  const scene = JSON.parse(ctx.readStripJson(target) ?? emptyStripJson(target));
+  update(target.kind === "bus" ? scene.buses[0] : scene.strips[0]);
+  ctx.writeStripJson(target, JSON.stringify(scene));
+}
+function mergeEqBand(ctx, target, bandIndex, bandJson) {
+  mergeStripJson(ctx, target, (entry) => {
+    const eq = entry.eq ?? { enabled: true, bands: [] };
+    const bands = eq.bands ?? [];
+    while (bands.length < bandIndex) {
+      bands.push({});
+    }
+    bands[bandIndex] = JSON.parse(bandJson);
+    entry.eq = { ...eq, bands };
+  });
+}
+function setInsertParamByName(ctx, target, insertIndex, paramName, value, applyNative, message) {
+  applyNative();
+  const override = { target, insertIndex, paramName, value };
+  ctx.insertParamOverrides.set(insertParamOverrideKey(override), override);
+  ctx.postSync(message);
+}
 function setTrackStripJson(ctx, trackId, sceneJson, trackStripJson) {
-  ctx.offlineEngine.setTrackStripJson(trackId, sceneJson);
+  const target = { kind: "track", trackId };
+  const resetInserts = trackStripJson.has(trackId) && trackStripJson.get(trackId) !== sceneJson || hasInsertParamOverrides(ctx.insertParamOverrides, target);
+  applyFullStripJson(ctx.offlineEngine, target, sceneJson, resetInserts);
+  clearInsertParamOverrides(ctx.insertParamOverrides, target);
   trackStripJson.set(trackId, sceneJson);
+  return { resetInserts };
 }
 function setTrackStripEqBand(ctx, target, bandIndex, band) {
   const trackId = trackIdFor(ctx, target);
   const bandJson = typeof band === "string" ? band : JSON.stringify(band);
   ctx.offlineEngine.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: "track", trackId }, bandIndex, bandJson);
   ctx.postSync({ type: "syncTrackStripEqBand", trackId, bandIndex, bandJson });
 }
 function setTrackStripInsertBypassed(ctx, target, insertIndex, bypassed, resetOnBypass) {
@@ -3864,39 +5423,68 @@ function setTrackStripInsertBypassed(ctx, target, insertIndex, bypassed, resetOn
 }
 function setTrackStripInsertParamByName(ctx, target, insertIndex, paramName, value) {
   const trackId = trackIdFor(ctx, target);
-  ctx.offlineEngine.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
-  ctx.postSync({ type: "syncTrackStripInsertParamByName", trackId, insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: "track", trackId },
+    insertIndex,
+    paramName,
+    value,
+    () => ctx.offlineEngine.restoreTrackStripInsertParamByName(trackId, insertIndex, paramName, value),
+    { type: "syncTrackStripInsertParamByName", trackId, insertIndex, paramName, value }
+  );
 }
 function setTrackStripPan(ctx, target, pan) {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripPan(trackId, pan);
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.pan = pan;
+  });
   ctx.postSync({ type: "syncTrackStripPan", trackId, pan });
 }
 function setTrackStripPanLaw(ctx, target, panLaw) {
   const trackId = trackIdFor(ctx, target);
   const code = panLawCode(panLaw);
   ctx.offlineEngine.setTrackStripPanLaw(trackId, code);
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.panLaw = code;
+  });
   ctx.postSync({ type: "syncTrackStripPanLaw", trackId, panLaw: code });
 }
 function setTrackStripPanMode(ctx, target, panMode) {
   const trackId = trackIdFor(ctx, target);
   const code = panModeCode(panMode);
   ctx.offlineEngine.setTrackStripPanMode(trackId, code);
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.panMode = code;
+  });
   ctx.postSync({ type: "syncTrackStripPanMode", trackId, panMode: code });
 }
 function setTrackStripDualPan(ctx, target, leftPan, rightPan) {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripDualPan(trackId, leftPan, rightPan);
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.dualPanLeft = leftPan;
+    entry.dualPanRight = rightPan;
+  });
   ctx.postSync({ type: "syncTrackStripDualPan", trackId, leftPan, rightPan });
 }
 function setTrackStripChannelDelaySamples(ctx, target, delaySamples) {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripChannelDelaySamples(trackId, delaySamples);
+  mergeStripJson(ctx, { kind: "track", trackId }, (entry) => {
+    entry.channelDelaySamples = delaySamples;
+  });
   ctx.postSync({ type: "syncTrackStripChannelDelaySamples", trackId, delaySamples });
 }
+function cacheMasterStripScalar(ctx, field, value) {
+  mergeStripJson(ctx, { kind: "master" }, (entry) => {
+    entry[field] = value;
+  });
+}
 function setMasterStripEqBand(ctx, bandIndex, band) {
   const bandJson = typeof band === "string" ? band : JSON.stringify(band);
   ctx.offlineEngine.setMasterStripEqBandJson(bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: "master" }, bandIndex, bandJson);
   ctx.postSync({ type: "syncMasterStripEqBand", bandIndex, bandJson });
 }
 function setMasterStripInsertBypassed(ctx, insertIndex, bypassed, resetOnBypass) {
@@ -3904,12 +5492,67 @@ function setMasterStripInsertBypassed(ctx, insertIndex, bypassed, resetOnBypass)
   ctx.postSync({ type: "syncMasterStripInsertBypassed", insertIndex, bypassed, resetOnBypass });
 }
 function setMasterStripInsertParamByName(ctx, insertIndex, paramName, value) {
-  ctx.offlineEngine.setMasterStripInsertParamByName(insertIndex, paramName, value);
-  ctx.postSync({ type: "syncMasterStripInsertParamByName", insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: "master" },
+    insertIndex,
+    paramName,
+    value,
+    () => ctx.offlineEngine.restoreMasterStripInsertParamByName(insertIndex, paramName, value),
+    { type: "syncMasterStripInsertParamByName", insertIndex, paramName, value }
+  );
 }
 function setBusStripInsertParamByName(ctx, busId, insertIndex, paramName, value) {
-  ctx.offlineEngine.setBusStripInsertParamByName(busId, insertIndex, paramName, value);
-  ctx.postSync({ type: "syncBusStripInsertParamByName", busId, insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: "bus", busId },
+    insertIndex,
+    paramName,
+    value,
+    () => ctx.offlineEngine.restoreBusStripInsertParamByName(busId, insertIndex, paramName, value),
+    { type: "syncBusStripInsertParamByName", busId, insertIndex, paramName, value }
+  );
+}
+function setBusStripInsertBypassed(ctx, busId, insertIndex, bypassed, resetOnBypass) {
+  ctx.offlineEngine.setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass);
+  ctx.postSync({ type: "syncBusStripInsertBypassed", busId, insertIndex, bypassed, resetOnBypass });
+}
+function setBusStripEqBand(ctx, busId, bandIndex, band) {
+  const bandJson = typeof band === "string" ? band : JSON.stringify(band);
+  ctx.offlineEngine.setBusStripEqBandJson(busId, bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: "bus", busId }, bandIndex, bandJson);
+  ctx.postSync({ type: "syncBusStripEqBand", busId, bandIndex, bandJson });
+}
+function setBusStripPan(ctx, busId, pan) {
+  ctx.offlineEngine.setBusStripPan(busId, pan);
+  mergeStripJson(ctx, { kind: "bus", busId }, (entry) => {
+    entry.pan = pan;
+  });
+  ctx.postSync({ type: "syncBusStripPan", busId, pan });
+}
+function setBusStripPanLaw(ctx, busId, panLaw) {
+  const code = panLawCode(panLaw);
+  ctx.offlineEngine.setBusStripPanLaw(busId, code);
+  mergeStripJson(ctx, { kind: "bus", busId }, (entry) => {
+    entry.panLaw = code;
+  });
+  ctx.postSync({ type: "syncBusStripPanLaw", busId, panLaw: code });
+}
+function setBusStripPanMode(ctx, busId, panMode) {
+  const code = panModeCode(panMode);
+  ctx.offlineEngine.setBusStripPanMode(busId, code);
+  mergeStripJson(ctx, { kind: "bus", busId }, (entry) => {
+    entry.panMode = code;
+  });
+  ctx.postSync({ type: "syncBusStripPanMode", busId, panMode: code });
+}
+function setBusStripDualPan(ctx, busId, leftPan, rightPan) {
+  ctx.offlineEngine.setBusStripDualPan(busId, leftPan, rightPan);
+  mergeStripJson(ctx, { kind: "bus", busId }, (entry) => {
+    entry.dualPanLeft = leftPan;
+    entry.dualPanRight = rightPan;
+  });
+  ctx.postSync({ type: "syncBusStripDualPan", busId, leftPan, rightPan });
 }
 function pushMidiNoteOn(ctx, trackId, group, channel, note, velocity, renderFrame) {
   const destinationId = ctx.resolveTargetId(trackId);
@@ -3950,9 +5593,55 @@ function pushMidiCc(ctx, trackId, group, channel, controller, value, renderFrame
     renderFrame
   });
 }
+function pushMidiPitchBend(ctx, trackId, group, channel, bend14, renderFrame) {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiPitchBend(destinationId, group, channel, bend14, renderFrame);
+  ctx.postSync({
+    type: "syncMidiPitchBend",
+    destinationId,
+    group,
+    channel,
+    data0: bend14,
+    data1: 0,
+    renderFrame
+  });
+}
+function pushMidiChannelPressure(ctx, trackId, group, channel, pressure, renderFrame) {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiChannelPressure(destinationId, group, channel, pressure, renderFrame);
+  ctx.postSync({
+    type: "syncMidiChannelPressure",
+    destinationId,
+    group,
+    channel,
+    data0: pressure,
+    data1: 0,
+    renderFrame
+  });
+}
+function pushMidiPolyPressure(ctx, trackId, group, channel, note, pressure, renderFrame) {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiPolyPressure(
+    destinationId,
+    group,
+    channel,
+    note,
+    pressure,
+    renderFrame
+  );
+  ctx.postSync({
+    type: "syncMidiPolyPressure",
+    destinationId,
+    group,
+    channel,
+    data0: note,
+    data1: pressure,
+    renderFrame
+  });
+}
 function pushMidiUmp(ctx, trackId, word0, renderFrame) {
   const destinationId = ctx.resolveTargetId(trackId);
-  ctx.offlineEngine.pushMidiUmp(destinationId, word0, renderFrame);
+  ctx.offlineEngine.pushMidiUmp(destinationId, [word0], renderFrame);
   ctx.postSync({ type: "syncMidiUmp", destinationId, word0, renderFrame });
 }
 function setBuiltinInstrument(ctx, trackId, config) {
@@ -4078,6 +5767,7 @@ function transferableAudioBuffers(channels) {
 var SonareEngine = class _SonareEngine {
   constructor(context, realtimeNode, offlineEngine, sampleRate, offlineBlockSize, offlineChannelCount) {
     this.automationLanes = /* @__PURE__ */ new Map();
+    this.insertAutomationIdsByTarget = /* @__PURE__ */ new Map();
     this.clips = /* @__PURE__ */ new Map();
     this.midiClips = /* @__PURE__ */ new Map();
     this.markers = /* @__PURE__ */ new Map();
@@ -4085,9 +5775,12 @@ var SonareEngine = class _SonareEngine {
     this.trackSends = /* @__PURE__ */ new Map();
     this.trackOutputBus = /* @__PURE__ */ new Map();
     this.laneSidechains = /* @__PURE__ */ new Map();
+    this.busSidechains = /* @__PURE__ */ new Map();
+    this.masterSidechains = /* @__PURE__ */ new Map();
     this.buses = [];
     this.trackStripJson = /* @__PURE__ */ new Map();
     this.busStripJson = /* @__PURE__ */ new Map();
+    this.insertParamOverrides = /* @__PURE__ */ new Map();
     this.tempoBpm = 120;
     this.timeSignature = { numerator: 4, denominator: 4 };
     this.tempoSegments = [{ startPpq: 0, bpm: 120 }];
@@ -4246,12 +5939,17 @@ var SonareEngine = class _SonareEngine {
    * @returns Reserved insert-automation id, or -1 when strip/insert/key unknown.
    */
   resolveTrackInsertAutomationId(target, insertIndex, paramName) {
-    return resolveTrackInsertAutomationId(
+    const id = resolveTrackInsertAutomationId(
       this.parameterContext,
       target,
       insertIndex,
       paramName
     );
+    if (id >= 0) {
+      const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+      this.rememberInsertAutomationId({ kind: "track", trackId }, id);
+    }
+    return id;
   }
   /**
    * Resolves a master-strip insert parameter to its reserved insert-automation
@@ -4262,7 +5960,15 @@ var SonareEngine = class _SonareEngine {
    * @returns Reserved insert-automation id, or -1 when insert/key unknown.
    */
   resolveMasterInsertAutomationId(insertIndex, paramName) {
-    return resolveMasterInsertAutomationId(this.parameterContext, insertIndex, paramName);
+    const id = resolveMasterInsertAutomationId(
+      this.parameterContext,
+      insertIndex,
+      paramName
+    );
+    if (id >= 0) {
+      this.rememberInsertAutomationId({ kind: "master" }, id);
+    }
+    return id;
   }
   /**
    * Resolves a bus-strip insert parameter to its reserved insert-automation id.
@@ -4275,12 +5981,29 @@ var SonareEngine = class _SonareEngine {
    * @returns Reserved insert-automation id, or -1 when bus/insert/key unknown.
    */
   resolveBusInsertAutomationId(busId, insertIndex, paramName) {
-    return resolveBusInsertAutomationId(
+    const id = resolveBusInsertAutomationId(
       this.parameterContext,
       busId,
       insertIndex,
       paramName
     );
+    if (id >= 0) {
+      this.rememberInsertAutomationId({ kind: "bus", busId }, id);
+    }
+    return id;
+  }
+  /**
+   * Resolves a hosted instrument's continuous parameter to its reserved
+   * instrument-automation id, so an instrument parameter follows a breakpoint
+   * lane at audio-block precision like a strip insert. Bind the instrument
+   * (`setSynthInstrument`) before resolving.
+   *
+   * @param destinationId MIDI destination the instrument is bound to.
+   * @param paramName Instrument JSON-key parameter name (e.g. `cutoffHz`).
+   * @returns Reserved instrument-automation id, or -1 when destination/key unknown.
+   */
+  resolveInstrumentAutomationId(destinationId, paramName) {
+    return resolveInstrumentAutomationId(this.parameterContext, destinationId, paramName);
   }
   /**
    * Returns the number of automation lanes installed on the engine, including
@@ -4310,10 +6033,18 @@ var SonareEngine = class _SonareEngine {
     return setTrackMonitorMode(this.parameterContext, target, mode, renderFrame);
   }
   setStripGain(target, db) {
-    return this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_FADER_DB), db);
+    const sent = this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_FADER_DB), db);
+    if (sent && target === "master") {
+      cacheMasterStripScalar(this.stripContext, "faderDb", db);
+    }
+    return sent;
   }
   setStripPan(target, pan) {
-    return this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_PAN), pan);
+    const sent = this.sendSmoothedParam(this.stripParamId(target, ENGINE_MIXER_PARAM_PAN), pan);
+    if (sent && target === "master") {
+      cacheMasterStripScalar(this.stripContext, "pan", pan);
+    }
+    return sent;
   }
   /**
    * Declares the mixer track lanes in an explicit order.
@@ -4350,14 +6081,37 @@ var SonareEngine = class _SonareEngine {
   setTrackBuses(buses) {
     setTrackBuses(this.mixerContext, buses);
   }
+  /**
+   * Keys one insert of a bus strip from a track lane or another bus
+   * (ducking/sidechainRouter inserts). `sourceId` 0 removes the binding.
+   */
+  setBusSidechain(busId, insertIndex, sourceKind, sourceId) {
+    setBusSidechain(this.mixerContext, busId, insertIndex, sourceKind, sourceId);
+  }
+  /**
+   * Keys one insert of the master strip from a track lane or a bus. Same
+   * source rules as {@link setBusSidechain}.
+   */
+  setMasterSidechain(insertIndex, sourceKind, sourceId) {
+    setMasterSidechain(this.mixerContext, insertIndex, sourceKind, sourceId);
+  }
   setBusGain(busId, db) {
     return setBusGain(this.mixerContext, busId, db);
   }
   setTrackStripJson(target, sceneJson) {
     const laneIndex = this.ensureTrackLane(target);
     const trackId = this.trackLaneIds[laneIndex];
-    setTrackStripJson(this.stripContext, trackId, sceneJson, this.trackStripJson);
-    this.syncMixer();
+    const { resetInserts } = setTrackStripJson(
+      this.stripContext,
+      trackId,
+      sceneJson,
+      this.trackStripJson
+    );
+    if (resetInserts) {
+      this.clearInsertAutomationLanes({ kind: "track", trackId });
+    }
+    pruneStripSidechains(this.mixerContext, { kind: "track", trackId }, sceneJson);
+    this.syncMixer(resetInserts ? [{ kind: "track", trackId }] : []);
   }
   setTrackStripEqBand(target, bandIndex, band) {
     setTrackStripEqBand(this.stripContext, target, bandIndex, band);
@@ -4414,9 +6168,16 @@ var SonareEngine = class _SonareEngine {
     setBusStripJson(this.mixerContext, busId, sceneJson);
   }
   setMasterStripJson(sceneJson) {
-    this.offlineEngine.setMasterStripJson(sceneJson);
+    const target = { kind: "master" };
+    const resetInserts = this.masterStripJson !== void 0 && this.masterStripJson !== sceneJson || hasInsertParamOverrides(this.insertParamOverrides, target);
+    applyFullStripJson(this.offlineEngine, target, sceneJson, resetInserts);
+    if (resetInserts) {
+      this.clearInsertAutomationLanes(target);
+    }
+    pruneStripSidechains(this.mixerContext, target, sceneJson);
+    clearInsertParamOverrides(this.insertParamOverrides, target);
     this.masterStripJson = sceneJson;
-    this.syncMixer();
+    this.syncMixer(resetInserts ? [target] : []);
   }
   setMasterStripEqBand(bandIndex, band) {
     setMasterStripEqBand(this.stripContext, bandIndex, band);
@@ -4431,6 +6192,47 @@ var SonareEngine = class _SonareEngine {
     this.ensureBus(busId);
     setBusStripInsertParamByName(this.stripContext, busId, insertIndex, paramName, value);
   }
+  /**
+   * Bus-strip counterpart of {@link setStripInsertBypassed}. A bus is addressed
+   * by its numeric id, which the `target` of the track/master form cannot
+   * express, so it is its own method exactly like
+   * {@link setBusStripInsertParamByName}. Bypassing keeps the insert's internal
+   * state (reverb tail, compressor envelope) unless `resetOnBypass` is set;
+   * re-posting the bus scene JSON, the only workaround before this existed,
+   * rebuilds the chain and loses it.
+   */
+  setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass = false) {
+    this.ensureBus(busId);
+    setBusStripInsertBypassed(
+      this.stripContext,
+      busId,
+      insertIndex,
+      bypassed,
+      resetOnBypass
+    );
+  }
+  /** Bus-strip counterpart of {@link setTrackStripEqBand}. */
+  setBusStripEqBand(busId, bandIndex, band) {
+    this.ensureBus(busId);
+    setBusStripEqBand(this.stripContext, busId, bandIndex, band);
+  }
+  /** Bus-strip counterpart of {@link setTrackStripPan}; refused on a surround bus. */
+  setBusStripPan(busId, pan) {
+    this.ensureBus(busId);
+    setBusStripPan(this.stripContext, busId, pan);
+  }
+  setBusStripPanLaw(busId, panLaw) {
+    this.ensureBus(busId);
+    setBusStripPanLaw(this.stripContext, busId, panLaw);
+  }
+  setBusStripPanMode(busId, panMode) {
+    this.ensureBus(busId);
+    setBusStripPanMode(this.stripContext, busId, panMode);
+  }
+  setBusStripDualPan(busId, leftPan, rightPan) {
+    this.ensureBus(busId);
+    setBusStripDualPan(this.stripContext, busId, leftPan, rightPan);
+  }
   setStripInsertParamByName(target, insertIndex, paramName, value) {
     if (target === "master") {
       this.setMasterStripInsertParamByName(insertIndex, paramName, value);
@@ -4511,6 +6313,49 @@ var SonareEngine = class _SonareEngine {
     }
     return { binding, provider: binding.provider };
   }
+  /**
+   * Sets the clip-page look-ahead window in timeline frames on both the worklet
+   * engine and this thread's offline engine.
+   *
+   * The audio thread reports the pages it is *about to* read that are not
+   * resident yet, so the sliding-window streamer can service them before the
+   * playhead reaches them. Without look-ahead a page miss is only reported
+   * after the read already produced silence, which costs one block of silence
+   * at every page boundary that was not primed.
+   *
+   * Defaults to half a second at the engine's sample rate. `0` disables it.
+   * Safe to call during playback.
+   */
+  setClipPagePrefetchFrames(frames) {
+    if (this.destroyed) {
+      throw new Error("SonareEngine is destroyed.");
+    }
+    if (!Number.isFinite(frames) || frames < 0) {
+      throw new Error("clip page prefetch frames must be a finite value >= 0.");
+    }
+    this.offlineEngine.setClipPagePrefetchFrames(frames);
+    this.postSync({ type: "syncClipPagePrefetchFrames", frames });
+  }
+  /**
+   * Sets the number of concurrent time-stretch voices on both this thread's
+   * offline engine and the live worklet engine. `voices` must be an integer
+   * in `[0, 64]`; a non-integer, negative, or larger value throws and leaves
+   * the capacity unchanged on both engines. Default is 8. Capacity 0 disables
+   * time-stretch, so every warped clip plays resampled instead. A change
+   * applied while the engine is running restarts the splice state of any clip
+   * stretching through a voice at that moment.
+   */
+  setWarpVoiceCapacity(voices) {
+    if (this.destroyed) {
+      throw new Error("SonareEngine is destroyed.");
+    }
+    this.offlineEngine.setWarpVoiceCapacity(voices);
+    this.postSync({ type: "syncWarpVoiceCapacity", voices });
+  }
+  /** Reads the current time-stretch voice capacity (default 8). */
+  warpVoiceCapacity() {
+    return this.offlineEngine.warpVoiceCapacity();
+  }
   addClip(trackId, buffer, startPpq, opts = {}) {
     return addClip(this.clipContext, trackId, buffer, startPpq, opts);
   }
@@ -4572,6 +6417,30 @@ var SonareEngine = class _SonareEngine {
   pushMidiCc(trackId, group, channel, controller, value, renderFrame = -1) {
     pushMidiCc(this.stripContext, trackId, group, channel, controller, value, renderFrame);
   }
+  pushMidiPitchBend(trackId, group, channel, bend14, renderFrame = -1) {
+    pushMidiPitchBend(this.stripContext, trackId, group, channel, bend14, renderFrame);
+  }
+  pushMidiChannelPressure(trackId, group, channel, pressure, renderFrame = -1) {
+    pushMidiChannelPressure(
+      this.stripContext,
+      trackId,
+      group,
+      channel,
+      pressure,
+      renderFrame
+    );
+  }
+  pushMidiPolyPressure(trackId, group, channel, note, pressure, renderFrame = -1) {
+    pushMidiPolyPressure(
+      this.stripContext,
+      trackId,
+      group,
+      channel,
+      note,
+      pressure,
+      renderFrame
+    );
+  }
   pushMidiUmp(trackId, word0, renderFrame = -1) {
     pushMidiUmp(this.stripContext, trackId, word0, renderFrame);
   }
@@ -4625,6 +6494,39 @@ var SonareEngine = class _SonareEngine {
       portTimeSamples
     });
   }
+  pushMidiInputPitchBend(group, channel, bend14, portTimeSamples = 0) {
+    this.offlineEngine.pushMidiInputPitchBend(group, channel, bend14, portTimeSamples);
+    this.postSync({
+      type: "syncMidiInputPitchBend",
+      group,
+      channel,
+      data0: bend14,
+      data1: 0,
+      portTimeSamples
+    });
+  }
+  pushMidiInputChannelPressure(group, channel, pressure, portTimeSamples = 0) {
+    this.offlineEngine.pushMidiInputChannelPressure(group, channel, pressure, portTimeSamples);
+    this.postSync({
+      type: "syncMidiInputChannelPressure",
+      group,
+      channel,
+      data0: pressure,
+      data1: 0,
+      portTimeSamples
+    });
+  }
+  pushMidiInputPolyPressure(group, channel, note, pressure, portTimeSamples = 0) {
+    this.offlineEngine.pushMidiInputPolyPressure(group, channel, note, pressure, portTimeSamples);
+    this.postSync({
+      type: "syncMidiInputPolyPressure",
+      group,
+      channel,
+      data0: note,
+      data1: pressure,
+      portTimeSamples
+    });
+  }
   pushMidiPanic(renderFrame = -1) {
     this.offlineEngine.pushMidiPanic(renderFrame);
     this.postSync({ type: "syncMidiPanic", renderFrame });
@@ -4822,8 +6724,32 @@ var SonareEngine = class _SonareEngine {
   mixerLanes() {
     return mixerLanes(this.mixerContext);
   }
-  syncMixer() {
-    syncMixer(this.mixerContext);
+  syncMixer(forceInsertResets = []) {
+    syncMixer(this.mixerContext, false, forceInsertResets);
+  }
+  insertAutomationTargetKey(target) {
+    return target.kind === "track" ? `track:${target.trackId}` : target.kind === "bus" ? `bus:${target.busId}` : "master";
+  }
+  rememberInsertAutomationId(target, id) {
+    const key = this.insertAutomationTargetKey(target);
+    const ids = this.insertAutomationIdsByTarget.get(key) ?? /* @__PURE__ */ new Set();
+    ids.add(id);
+    this.insertAutomationIdsByTarget.set(key, ids);
+  }
+  clearInsertAutomationLanes(target, forgetResolvedIds = false) {
+    const key = this.insertAutomationTargetKey(target);
+    const ids = this.insertAutomationIdsByTarget.get(key);
+    if (!ids) {
+      return;
+    }
+    for (const id of ids) {
+      if (this.automationLanes.has(id)) {
+        this.setAutomationLane(id, []);
+      }
+    }
+    if (forgetResolvedIds) {
+      this.insertAutomationIdsByTarget.delete(key);
+    }
   }
   postInstrumentSync(message) {
     if (this.destroyed) {
@@ -4851,21 +6777,16 @@ var SonareEngine = class _SonareEngine {
     if (this.destroyed) {
       return;
     }
-    try {
-      if (transfer && transfer.length > 0) {
-        this.realtimeNode.node.port.postMessage(message, transfer);
-      } else {
-        this.realtimeNode.node.port.postMessage(message);
-      }
-    } finally {
-      this.flushOfflineMirror();
+    if (transfer && transfer.length > 0) {
+      this.realtimeNode.node.port.postMessage(message, transfer);
+    } else {
+      this.realtimeNode.node.port.postMessage(message);
     }
   }
-  // The offline engine is a control-thread mirror. It has no render loop to
-  // drain its command ring, so drain it after each control operation. Never
-  // call this from the worklet/audio path: it is intentionally control-only.
+  // The control-only mirror applies due commands immediately while preserving
+  // scheduled ones for its next render block.
   flushOfflineMirror() {
-    this.offlineEngine.flushControlCommands();
+    this.offlineEngine.applyCommandsDueNowPreservingFuture();
   }
   sendMirroredCommand(command) {
     const accepted = this.realtimeNode.sendCommand(command);
@@ -4883,16 +6804,24 @@ var SonareEngine = class _SonareEngine {
       trackSends: this.trackSends,
       trackOutputBus: this.trackOutputBus,
       laneSidechains: this.laneSidechains,
+      busSidechains: this.busSidechains,
+      masterSidechains: this.masterSidechains,
       buses: this.buses,
       trackStripJson: this.trackStripJson,
       busStripJson: this.busStripJson,
+      insertParamOverrides: this.insertParamOverrides,
+      flushOfflineMirror: () => this.flushOfflineMirror(),
       postSync: (message) => this.postSync(message),
       ensureTrackLane: (target) => this.ensureTrackLane(target),
       ensureBus: (busId) => this.ensureBus(busId),
       mixerLanes: () => this.mixerLanes(),
-      syncMixer: () => this.syncMixer(),
+      syncMixer: (forceInsertResets) => this.syncMixer(forceInsertResets),
+      clearInsertAutomationLanes: (target, forgetResolvedIds) => this.clearInsertAutomationLanes(target, forgetResolvedIds),
       sendSmoothedParam: (paramId, value) => this.sendSmoothedParam(paramId, value),
-      getMasterStripJson: () => this.masterStripJson
+      getMasterStripJson: () => this.masterStripJson,
+      cacheMasterStripJson: (sceneJson) => {
+        this.masterStripJson = sceneJson;
+      }
     };
   }
   // Collaborator surface handed to the strip/pan/EQ/insert/MIDI free functions
@@ -4905,7 +6834,10 @@ var SonareEngine = class _SonareEngine {
       postSync: (message) => this.postSync(message),
       postInstrumentSync: (message) => this.postInstrumentSync(message),
       ensureTrackLane: (target) => this.ensureTrackLane(target),
-      resolveTargetId: (target) => this.resolveTargetId(target)
+      resolveTargetId: (target) => this.resolveTargetId(target),
+      readStripJson: (target) => cachedStripJson(this.mixerContext, target),
+      writeStripJson: (target, sceneJson) => cacheStripJson(this.mixerContext, target, sceneJson),
+      insertParamOverrides: this.insertParamOverrides
     };
   }
   // Collaborator surface handed to the automation-lane free functions so they
@@ -5047,7 +6979,7 @@ var SonareEngine = class _SonareEngine {
   ensureTrackLane(target) {
     const trackId = this.resolveTargetId(target);
     if (!Number.isInteger(trackId) || trackId <= 0) {
-      throw new Error(`Invalid track id for mixer lane: ${String(target)}`);
+      throw new RangeError(`Invalid track id for mixer lane: ${String(target)}`);
     }
     const existing = this.trackLaneIds.indexOf(trackId);
     if (existing >= 0) {
@@ -5058,20 +6990,36 @@ var SonareEngine = class _SonareEngine {
     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)}`);
+    if (!Number.isInteger(busId) || busId <= 0) {
+      throw new RangeError(`Invalid bus id for mixer bus: ${String(busId)}`);
     }
-    const existing = this.buses.findIndex((bus) => bus.busId === resolved);
+    const existing = this.buses.findIndex((bus) => bus.busId === busId);
     if (existing >= 0) {
       return existing;
     }
-    this.buses.push({ busId: resolved });
+    this.buses.push({ busId });
     this.syncMixer();
     return this.buses.length - 1;
   }
 };
 
+// src/worklet/audio_types.ts
+function copyPlanesToOutput(output, planes, frames) {
+  const monoFanOut = planes.length === 1;
+  for (let ch = 0; ch < output.length; ch++) {
+    const target = output[ch];
+    const source = monoFanOut ? planes[0] : planes[ch];
+    let copied = 0;
+    if (source) {
+      copied = Math.min(target.length, frames, source.length);
+      target.set(source.subarray(0, copied));
+    }
+    if (copied < target.length) {
+      target.fill(0, copied);
+    }
+  }
+}
+
 // src/worklet/messages.ts
 var DEFAULT_METRONOME_CONFIG = {
   beatGain: 0.35,
@@ -5115,6 +7063,10 @@ 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 };
+    // Cue-bus plane, allocated only when the host asked for a separate PFL/AFL
+    // output. Empty otherwise, so a single-output host pays no heap and keeps the
+    // historical behaviour where process() folds the cue into the program mix.
+    this.monitorBuffers = [];
     this.liveClips = /* @__PURE__ */ new Map();
     this.pagedClipProviders = /* @__PURE__ */ new Map();
     this.pagedClipPageFrames = /* @__PURE__ */ new Map();
@@ -5128,9 +7080,14 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     this.clipPageRequestOverflowReported = 0;
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
-    this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
+    this.channelCount = requireChannelCount(options.channelCount, 2);
     this.transport = transport;
-    this.meterIntervalFrames = Math.max(0, Math.floor(options.meterIntervalFrames ?? 2048));
+    this.meterIntervalFrames = requireIntegerOption(
+      options.meterIntervalFrames,
+      2048,
+      "meterIntervalFrames",
+      0
+    );
     this.commandRing = options.commandSharedBuffer ? this.commandRingFromSharedBuffer(options.commandSharedBuffer, options.commandRingCapacity) : void 0;
     this.telemetryRing = options.telemetrySharedBuffer ? this.telemetryRingFromSharedBuffer(
       options.telemetrySharedBuffer,
@@ -5150,10 +7107,13 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       options.externalMidiSharedBuffer,
       options.externalMidiRingCapacity
     ) : void 0;
+    if (this.commandRing && this.commandRing.capacity > 65536) {
+      throw new RangeError("commandRingCapacity must be at most 65536");
+    }
     this.engine = new RealtimeEngine(
       this.sampleRate,
       this.blockSize,
-      1024,
+      Math.max(1024, this.commandRing?.capacity ?? 0),
       1024,
       this.channelCount
     );
@@ -5162,8 +7122,21 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     for (let ch = 0; ch < this.channelCount; ch++) {
       this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
     }
+    this.cueOutput = options.cueOutput === true;
+    if (this.cueOutput) {
+      this.engine.prepareMonitorChannels(this.channelCount, this.blockSize);
+      this.monitorBuffers = new Array(this.channelCount);
+      for (let ch = 0; ch < this.channelCount; ch++) {
+        this.monitorBuffers[ch] = this.engine.getMonitorChannelBuffer(ch, this.blockSize);
+      }
+    }
     if (this.scopeRing) {
-      const interval = Math.max(1, Math.floor(options.scopeIntervalFrames ?? this.blockSize));
+      const interval = requireIntegerOption(
+        options.scopeIntervalFrames,
+        this.blockSize,
+        "scopeIntervalFrames",
+        0
+      );
       this.engine.configureScopeTelemetry(interval, this.scopeRing.bands);
     }
   }
@@ -5198,6 +7171,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     if ((this.channelBuffers[0]?.byteLength ?? 0) === 0) {
       this.reacquireChannelBuffers();
     }
+    if (this.cueOutput && (this.monitorBuffers[0]?.byteLength ?? 0) === 0) {
+      this.reacquireMonitorBuffers();
+    }
     const input = inputs[0];
     for (let ch = 0; ch < this.channelCount; ch++) {
       const dst = this.channelBuffers[ch];
@@ -5208,17 +7184,16 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         dst.fill(0, 0, usableFrames);
       }
     }
-    this.engine.processPrepared(usableFrames);
-    for (let ch = 0; ch < output.length; ch++) {
-      const target = output[ch];
-      const source = this.channelBuffers[ch] ?? this.channelBuffers[0];
-      if (source) {
-        target.set(source.subarray(0, Math.min(target.length, usableFrames)));
-        if (target.length > usableFrames) {
-          target.fill(0, usableFrames);
-        }
-      } else {
-        target.fill(0);
+    if (this.cueOutput) {
+      this.engine.processPreparedWithMonitor(usableFrames);
+    } else {
+      this.engine.processPrepared(usableFrames);
+    }
+    copyPlanesToOutput(output, this.channelBuffers, usableFrames);
+    if (this.cueOutput) {
+      const cue = outputs[1];
+      if (cue) {
+        copyPlanesToOutput(cue, this.monitorBuffers, usableFrames);
       }
     }
     this.publishClipPageRequests();
@@ -5233,6 +7208,11 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
     }
   }
+  reacquireMonitorBuffers() {
+    for (let ch = 0; ch < this.channelCount; ch++) {
+      this.monitorBuffers[ch] = this.engine.getMonitorChannelBuffer(ch, this.blockSize);
+    }
+  }
   receiveCommand(command) {
     if (!this.closed) {
       this.safeApplyCommand(command);
@@ -5320,6 +7300,14 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         }
         break;
       }
+      case "syncClipPagePrefetchFrames": {
+        this.engine.setClipPagePrefetchFrames(message.frames);
+        break;
+      }
+      case "syncWarpVoiceCapacity": {
+        this.engine.setWarpVoiceCapacity(message.voices);
+        break;
+      }
       case "syncClipPageCommit": {
         const providerId = this.pagedClipProviders.get(message.clipId);
         const clip = message.clip ?? this.pendingPagedClips.get(message.clipId);
@@ -5378,11 +7366,60 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
           );
         }
         break;
-      case "syncMixer":
+      case "syncMixer": {
+        if (message.sidechainDelta === true) {
+          for (const binding of message.laneSidechains ?? []) {
+            this.engine.setLaneSidechain(
+              binding.trackId,
+              binding.insertIndex,
+              binding.sourceTrackId
+            );
+          }
+          for (const binding of message.busSidechains ?? []) {
+            this.engine.setBusSidechain(
+              binding.busId,
+              binding.insertIndex,
+              binding.sourceKind,
+              binding.sourceId
+            );
+          }
+          for (const binding of message.masterSidechains ?? []) {
+            this.engine.setMasterSidechain(
+              binding.insertIndex,
+              binding.sourceKind,
+              binding.sourceId
+            );
+          }
+          break;
+        }
+        if (this.commandRing) {
+          const write = Atomics.load(this.commandRing.header, 0);
+          const read = Atomics.load(this.commandRing.header, 1);
+          this.drainCommands(Math.min(this.commandRing.capacity, Math.max(0, write - read)));
+        }
+        this.engine.applyCommandsDueNowPreservingFuture();
+        this.engine.settleInsertParameters();
         if (message.buses) {
           this.engine.setTrackBuses(message.buses);
         }
         this.engine.setTrackLanes(message.lanes);
+        for (const target of message.forceInsertResets ?? []) {
+          const emptyJson = emptyStripJson(target);
+          switch (target.kind) {
+            case "track":
+              this.engine.clearTrackInsertParameterBases(target.trackId);
+              this.engine.setTrackStripJson(target.trackId, emptyJson);
+              break;
+            case "bus":
+              this.engine.clearBusInsertParameterBases(target.busId);
+              this.engine.setBusStripJson(target.busId, emptyJson);
+              break;
+            case "master":
+              this.engine.clearMasterInsertParameterBases();
+              this.engine.setMasterStripJson(emptyJson);
+              break;
+          }
+        }
         for (const strip of message.trackStrips ?? []) {
           this.engine.setTrackStripJson(strip.trackId, strip.sceneJson);
         }
@@ -5395,7 +7432,46 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         for (const binding of message.laneSidechains ?? []) {
           this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
         }
+        for (const binding of message.busSidechains ?? []) {
+          this.engine.setBusSidechain(
+            binding.busId,
+            binding.insertIndex,
+            binding.sourceKind,
+            binding.sourceId
+          );
+        }
+        for (const binding of message.masterSidechains ?? []) {
+          this.engine.setMasterSidechain(binding.insertIndex, binding.sourceKind, binding.sourceId);
+        }
+        for (const override of message.insertParamOverrides ?? []) {
+          switch (override.kind) {
+            case "track":
+              this.engine.restoreTrackStripInsertParamByName(
+                override.trackId,
+                override.insertIndex,
+                override.paramName,
+                override.value
+              );
+              break;
+            case "bus":
+              this.engine.restoreBusStripInsertParamByName(
+                override.busId,
+                override.insertIndex,
+                override.paramName,
+                override.value
+              );
+              break;
+            case "master":
+              this.engine.restoreMasterStripInsertParamByName(
+                override.insertIndex,
+                override.paramName,
+                override.value
+              );
+              break;
+          }
+        }
         break;
+      }
       case "syncCapture":
         this.engine.setCaptureBuffer(message.channels, message.bufferFrames);
         this.engine.setCaptureSource(message.source);
@@ -5408,6 +7484,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       case "syncMasterStripEqBand":
         this.engine.setMasterStripEqBandJson(message.bandIndex, message.bandJson);
         break;
+      case "syncBusStripEqBand":
+        this.engine.setBusStripEqBandJson(message.busId, message.bandIndex, message.bandJson);
+        break;
       case "syncTrackStripInsertBypassed":
         this.engine.setTrackStripInsertBypassed(
           message.trackId,
@@ -5424,26 +7503,57 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
         );
         break;
       case "syncTrackStripInsertParamByName":
-        this.engine.setTrackStripInsertParamByName(
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (!this.engine.applyTrackStripInsertParamByNameNow(
           message.trackId,
           message.insertIndex,
           message.paramName,
           message.value
-        );
+        )) {
+          this.engine.restoreTrackStripInsertParamByName(
+            message.trackId,
+            message.insertIndex,
+            message.paramName,
+            message.value
+          );
+        }
         break;
       case "syncMasterStripInsertParamByName":
-        this.engine.setMasterStripInsertParamByName(
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (!this.engine.applyMasterStripInsertParamByNameNow(
           message.insertIndex,
           message.paramName,
           message.value
-        );
+        )) {
+          this.engine.restoreMasterStripInsertParamByName(
+            message.insertIndex,
+            message.paramName,
+            message.value
+          );
+        }
         break;
       case "syncBusStripInsertParamByName":
-        this.engine.setBusStripInsertParamByName(
+        this.engine.applyCommandsDueNowPreservingFuture();
+        if (!this.engine.applyBusStripInsertParamByNameNow(
           message.busId,
           message.insertIndex,
           message.paramName,
           message.value
+        )) {
+          this.engine.restoreBusStripInsertParamByName(
+            message.busId,
+            message.insertIndex,
+            message.paramName,
+            message.value
+          );
+        }
+        break;
+      case "syncBusStripInsertBypassed":
+        this.engine.setBusStripInsertBypassed(
+          message.busId,
+          message.insertIndex,
+          message.bypassed,
+          message.resetOnBypass
         );
         break;
       case "syncTrackStripPan":
@@ -5458,6 +7568,18 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       case "syncTrackStripDualPan":
         this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
         break;
+      case "syncBusStripPan":
+        this.engine.setBusStripPan(message.busId, message.pan);
+        break;
+      case "syncBusStripPanLaw":
+        this.engine.setBusStripPanLaw(message.busId, message.panLaw);
+        break;
+      case "syncBusStripPanMode":
+        this.engine.setBusStripPanMode(message.busId, message.panMode);
+        break;
+      case "syncBusStripDualPan":
+        this.engine.setBusStripDualPan(message.busId, message.leftPan, message.rightPan);
+        break;
       case "syncTrackStripChannelDelaySamples":
         this.engine.setTrackStripChannelDelaySamples(message.trackId, message.delaySamples);
         break;
@@ -5509,8 +7631,36 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
           message.renderFrame
         );
         break;
+      case "syncMidiPitchBend":
+        this.engine.pushMidiPitchBend(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.renderFrame
+        );
+        break;
+      case "syncMidiChannelPressure":
+        this.engine.pushMidiChannelPressure(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.renderFrame
+        );
+        break;
+      case "syncMidiPolyPressure":
+        this.engine.pushMidiPolyPressure(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.data0,
+          message.data1,
+          message.renderFrame
+        );
+        break;
       case "syncMidiUmp":
-        this.engine.pushMidiUmp(message.destinationId, message.word0, message.renderFrame);
+        this.engine.pushMidiUmp(message.destinationId, [message.word0], message.renderFrame);
         break;
       case "syncMidiSysex":
         this.engine.pushMidiSysex(message.destinationId, message.data, message.renderFrame);
@@ -5563,6 +7713,31 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
           message.portTimeSamples
         );
         break;
+      case "syncMidiInputPitchBend":
+        this.engine.pushMidiInputPitchBend(
+          message.group,
+          message.channel,
+          message.data0,
+          message.portTimeSamples
+        );
+        break;
+      case "syncMidiInputChannelPressure":
+        this.engine.pushMidiInputChannelPressure(
+          message.group,
+          message.channel,
+          message.data0,
+          message.portTimeSamples
+        );
+        break;
+      case "syncMidiInputPolyPressure":
+        this.engine.pushMidiInputPolyPressure(
+          message.group,
+          message.channel,
+          message.data0,
+          message.data1,
+          message.portTimeSamples
+        );
+        break;
     }
   }
   receiveCaptureRequest(message) {
@@ -5643,11 +7818,11 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       this.closed = true;
     }
   }
-  drainCommands() {
+  drainCommands(limit = 64) {
     if (!this.commandRing) {
       return;
     }
-    for (let i = 0; i < 64; i++) {
+    for (let i = 0; i < limit; i++) {
       const command = popSonareEngineCommandRingBuffer(this.commandRing);
       if (!command) {
         return;
@@ -5834,10 +8009,9 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
       if (meter.frame !== this.lastMeterFrame) {
         this.lastMeterFrame = meter.frame;
       }
-      if (this.meterRing) {
-        this.writeMeterRing(meter);
+      if (this.transport?.onMeter) {
+        this.transport.onMeter(meter);
       } else {
-        this.transport?.onMeter?.(meter);
         this.transport?.postMessage?.(meter);
       }
     }
@@ -5854,29 +8028,18 @@ var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletPr
     }
     Atomics.store(ring.header, 0, writeIndex + 1);
   }
-  writeMeterRing(meter) {
-    const ring = this.meterRing;
-    if (!ring) {
-      return;
-    }
-    const writeIndex = Atomics.load(ring.header, 0);
-    const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
-    ring.records[offset] = encodeFrameLo(meter.frame);
-    ring.records[offset + 1] = 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);
-  }
+  // A snapshot-object ring writer used to live here as well. It was
+  // unreachable: publishMeters returns after the writeMeterScratch loop
+  // whenever a ring exists, so the ring is never fed from a materialised
+  // snapshot. writeMeterScratch above is the only ring writer, and it keeps the
+  // render callback allocation-free by reading the engine's scratch registers
+  // directly.
+  //
+  // writeIndex is a free-running monotonic counter, so an overflow guard would
+  // fire on essentially every write past the first `capacity` records and store
+  // an ever-growing value, not a dropped-record count. Readers already detect
+  // silent overrun via firstReadable = max(readIndex, writeIndex - capacity),
+  // so header slot 3 is left at its initial 0.
   // Drains the engine's scope producer (FFT spectrum + goniometer points) into
   // the lock-free SAB scope ring. No allocation on the render path: records are
   // written field-by-field into the ring.
@@ -6084,15 +8247,7 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
           }
           return;
         }
-        if (isEngineCommandRecord(event.data)) {
-          this.bridge.receiveCommand(event.data);
-        } else if (isEngineSyncMessage(event.data)) {
-          this.bridge.receiveSync(event.data);
-        } else if (isEngineCaptureRequestMessage(event.data)) {
-          this.bridge.receiveCaptureRequest(event.data);
-        } else if (isEngineTransportRequestMessage(event.data)) {
-          this.bridge.receiveTransportRequest(event.data);
-        }
+        this.routeMessage(event.data);
       };
       if (port?.addEventListener) {
         port.addEventListener("message", onMessage);
@@ -6111,18 +8266,35 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
       }
       return true;
     }
+    /**
+     * Single dispatch point for the port, shared with the buffered replay so
+     * the two cannot recognize different message sets.
+     */
+    routeMessage(data) {
+      const bridge = this.bridge;
+      if (!bridge) {
+        return;
+      }
+      if (isEngineCommandRecord(data)) {
+        bridge.receiveCommand(data);
+      } else if (isEngineSyncMessage(data)) {
+        bridge.receiveSync(data);
+      } else if (isEngineCaptureRequestMessage(data)) {
+        bridge.receiveCaptureRequest(data);
+      } else if (isEngineTransportRequestMessage(data)) {
+        bridge.receiveTransportRequest(data);
+      } else if (isRecord(data) && typeof data.type === "string" && data.type.startsWith("sync")) {
+        this.port?.postMessage?.({
+          type: "syncError",
+          syncType: data.type,
+          message: `Unrecognized worklet sync message: ${data.type}`
+        });
+      }
+    }
     replayPendingMessages() {
       const messages = this.pendingMessages.splice(0);
       for (const data of messages) {
-        if (isEngineCommandRecord(data)) {
-          this.bridge?.receiveCommand(data);
-        } else if (isEngineSyncMessage(data)) {
-          this.bridge?.receiveSync(data);
-        } else if (isEngineCaptureRequestMessage(data)) {
-          this.bridge?.receiveCaptureRequest(data);
-        } else if (isEngineTransportRequestMessage(data)) {
-          this.bridge?.receiveTransportRequest(data);
-        }
+        this.routeMessage(data);
       }
     }
     async initializeEmbind(options, port) {
@@ -6175,15 +8347,48 @@ var SonareWorkletProcessor = class {
     this.processedFrames = 0;
     this.lastMeterFrame = 0;
     this.lastSpectrumFrame = 0;
+    /**
+     * Reused meter record, so a publish writes fields instead of allocating one.
+     *
+     * `targetId` is always the master and the four LUFS / gain-reduction fields
+     * are always unavailable here — the mixer worklet does not run the
+     * K-weighting filters, and a floor value would read as silence — so both are
+     * set once rather than per interval.
+     */
+    this.meterScratch = {
+      type: "meter",
+      targetId: 0,
+      frame: 0,
+      peakDbL: 0,
+      peakDbR: 0,
+      rmsDbL: 0,
+      rmsDbR: 0,
+      correlation: 0,
+      truePeakDbL: 0,
+      truePeakDbR: 0,
+      momentaryLufs: Number.NaN,
+      shortTermLufs: Number.NaN,
+      integratedLufs: Number.NaN,
+      gainReductionDb: Number.NaN
+    };
     if (!options.sceneJson) {
       throw new Error("sceneJson is required.");
     }
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
-    this.meterIntervalFrames = Math.max(0, Math.floor(options.meterIntervalFrames ?? 2048));
-    this.spectrumIntervalFrames = Math.max(0, Math.floor(options.spectrumIntervalFrames ?? 0));
+    this.meterIntervalFrames = requireIntegerOption(
+      options.meterIntervalFrames,
+      2048,
+      "meterIntervalFrames",
+      0
+    );
+    this.spectrumIntervalFrames = requireIntegerOption(
+      options.spectrumIntervalFrames,
+      0,
+      "spectrumIntervalFrames",
+      0
+    );
     this.transport = transport;
-    this.meterIntervalFrames = Math.max(0, Math.floor(options.meterIntervalFrames ?? 2048));
     this.meterRing = options.meterSharedBuffer ? meterRingFromSharedBuffer(options.meterSharedBuffer, options.meterRingCapacity) : void 0;
     this.spectrumRing = options.spectrumSharedBuffer ? spectrumRingFromSharedBuffer(
       options.spectrumSharedBuffer,
@@ -6200,6 +8405,7 @@ var SonareWorkletProcessor = class {
       throw new Error("stripCount must match the scene strip count.");
     }
     this.realtime = this.mixer.createRealtimeBuffer();
+    this.mixer.configureMeter(this.meterIntervalFrames > 0, 4);
   }
   process(inputs, outputs) {
     if (this.closed) {
@@ -6246,10 +8452,7 @@ var SonareWorkletProcessor = class {
       }
     }
     this.processedFrames += usable;
-    this.publishMeter(
-      this.realtime.outLeft.subarray(0, usable),
-      this.realtime.outRight.subarray(0, usable)
-    );
+    this.publishMeter();
     this.publishSpectrum(
       this.realtime.outLeft.subarray(0, usable),
       this.realtime.outRight.subarray(0, usable)
@@ -6265,7 +8468,11 @@ var SonareWorkletProcessor = class {
       return;
     }
     if (message.type === "setMeterInterval") {
-      this.meterIntervalFrames = Math.max(0, Math.floor(message.frames));
+      const frames = Math.max(0, Math.floor(message.frames));
+      if (frames > 0 !== this.meterIntervalFrames > 0) {
+        this.mixer.configureMeter(frames > 0, 4);
+      }
+      this.meterIntervalFrames = frames;
       return;
     }
     if (message.type === "scheduleInsertAutomation") {
@@ -6285,58 +8492,52 @@ var SonareWorkletProcessor = class {
       this.closed = true;
     }
   }
-  publishMeter(left, right) {
-    if (!this.transport || this.meterIntervalFrames <= 0) {
+  publishMeter() {
+    if (!this.transport && !this.meterRing || this.meterIntervalFrames <= 0) {
       return;
     }
     if (this.processedFrames - this.lastMeterFrame < this.meterIntervalFrames) {
       return;
     }
     this.lastMeterFrame = this.processedFrames;
-    let peakL = 0;
-    let peakR = 0;
-    let sumL = 0;
-    let sumR = 0;
-    let sumLR = 0;
-    for (let i = 0; i < left.length; i++) {
-      const l = left[i] ?? 0;
-      const r = right[i] ?? 0;
-      const absL = Math.abs(l);
-      const absR = Math.abs(r);
-      if (absL > peakL) {
-        peakL = absL;
-      }
-      if (absR > peakR) {
-        peakR = absR;
-      }
-      sumL += l * l;
-      sumR += r * r;
-      sumLR += l * r;
+    if (!this.mixer.latchMeterSnapshot()) {
+      return;
+    }
+    if (this.meterRing) {
+      const meter2 = this.meterScratch;
+      meter2.frame = this.processedFrames;
+      meter2.peakDbL = this.mixer.meterScratchValue(0);
+      meter2.peakDbR = this.mixer.meterScratchValue(1);
+      meter2.rmsDbL = this.mixer.meterScratchValue(2);
+      meter2.rmsDbR = this.mixer.meterScratchValue(3);
+      meter2.correlation = this.mixer.meterScratchValue(4);
+      meter2.truePeakDbL = this.mixer.meterScratchValue(5);
+      meter2.truePeakDbR = this.mixer.meterScratchValue(6);
+      this.writeMeterRing(meter2);
+      return;
     }
-    const rmsL = Math.sqrt(sumL / Math.max(1, left.length));
-    const rmsR = Math.sqrt(sumR / Math.max(1, right.length));
-    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,
-      truePeakDbL: toDb(peakL),
-      truePeakDbR: toDb(peakR),
+      peakDbL: this.mixer.meterScratchValue(0),
+      peakDbR: this.mixer.meterScratchValue(1),
+      rmsDbL: this.mixer.meterScratchValue(2),
+      rmsDbR: this.mixer.meterScratchValue(3),
+      correlation: this.mixer.meterScratchValue(4),
+      truePeakDbL: this.mixer.meterScratchValue(5),
+      truePeakDbR: this.mixer.meterScratchValue(6),
+      // Declared unavailable rather than floored: the mixer worklet does not run
+      // the K-weighting filters, and a floor value would read as silence.
       momentaryLufs: Number.NaN,
       shortTermLufs: Number.NaN,
       integratedLufs: Number.NaN,
       gainReductionDb: Number.NaN
     };
-    this.transport.onMeter?.(meter);
-    if (this.meterRing) {
-      this.writeMeterRing(meter);
+    if (this.transport?.onMeter) {
+      this.transport.onMeter(meter);
     } else {
-      this.transport.postMessage?.(meter);
+      this.transport?.postMessage?.(meter);
     }
   }
   writeMeterRing(meter) {
@@ -6380,8 +8581,11 @@ var SonareWorkletProcessor = class {
       frame: this.processedFrames,
       bands: new Float32Array(this.spectrumBands)
     };
-    this.transport?.onSpectrum?.(spectrum);
-    this.transport?.postMessage?.(spectrum);
+    if (this.transport?.onSpectrum) {
+      this.transport.onSpectrum(spectrum);
+    } else {
+      this.transport?.postMessage?.(spectrum);
+    }
   }
   computeSpectrum(left, right) {
     const n = Math.max(1, Math.min(left.length, right.length));
@@ -6449,13 +8653,232 @@ function registerSonareWorkletProcessor(name = "sonare-worklet-processor") {
   scope.registerProcessor(name, RegisteredSonareWorkletProcessor);
 }
 
+// src/worklet/playback-processor.ts
+var MAX_INPUT_CHANNELS = 8;
+var SPEAKER_LAYOUT_CHANNELS = { stereo: 2, "5.1": 6, "7.1": 8 };
+function configObject(config) {
+  if (config === void 0) {
+    return {};
+  }
+  return typeof config === "string" ? JSON.parse(config) : config;
+}
+function outputChannelCount(config) {
+  if (config.target?.kind !== "speakers") {
+    return 2;
+  }
+  const count = SPEAKER_LAYOUT_CHANNELS[config.target.layout ?? ""];
+  if (count === void 0) {
+    throw new RangeError('target.layout must be "stereo", "5.1" or "7.1" for a speakers target');
+  }
+  return count;
+}
+var _SonarePlaybackWorkletProcessor = class _SonarePlaybackWorkletProcessor {
+  constructor(options = {}, port) {
+    this.inputPlanes = [];
+    this.outputPlanes = [];
+    this.unsupportedInputBlocks = 0;
+    this.destroyed = false;
+    this.port = port;
+    this.maxBlockSize = requireIntegerOption(options.maxBlockSize, 128, "maxBlockSize", 1);
+    const scopeRate = globalThis.sampleRate;
+    const sampleRate = options.sampleRate ?? (typeof scopeRate === "number" ? scopeRate : 48e3);
+    const hrtf = options.hrtf ? HrtfSet.fromBytes(new Uint8Array(options.hrtf)) : void 0;
+    try {
+      this.renderer = new PlaybackRenderer({
+        config: options.config ?? {},
+        hrtf,
+        sampleRate,
+        maxBlockSize: this.maxBlockSize
+      });
+    } finally {
+      hrtf?.delete();
+    }
+    this.native = this.renderer.native;
+    this.outputChannels = this.native.outputChannels();
+    this.acquirePlanes();
+  }
+  /**
+   * Handles a control-plane message. AudioWorklet port handlers run on the
+   * rendering thread between `process()` calls, which is what makes `reset`
+   * safe here. A refused message is answered with an `error` message.
+   */
+  receiveMessage(message) {
+    if (this.destroyed) {
+      return;
+    }
+    try {
+      switch (message.type) {
+        case "config":
+          this.renderer.setConfig(message.config);
+          break;
+        case "orientation":
+          this.renderer.setHeadOrientation(message.yaw, message.pitch ?? 0, message.roll ?? 0);
+          break;
+        case "reset":
+          this.renderer.reset();
+          break;
+        case "diagnostics":
+          this.port?.postMessage?.({
+            type: "diagnostics",
+            diagnostics: this.diagnostics()
+          });
+          break;
+        case "destroy":
+          this.destroy();
+          break;
+      }
+    } catch (error) {
+      this.port?.postMessage?.({
+        type: "error",
+        request: message.type,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /** The renderer's diagnostics plus `unsupported_input_blocks`, as a plain object. */
+  diagnostics() {
+    return {
+      ...this.renderer.diagnostics(),
+      unsupported_input_blocks: this.unsupportedInputBlocks
+    };
+  }
+  process(inputs, outputs) {
+    if (this.destroyed) {
+      return false;
+    }
+    const output = outputs[0];
+    const requested = output?.[0]?.length ?? 0;
+    if (!output || requested === 0) {
+      return true;
+    }
+    const frames = this.clampFrames(requested);
+    if (this.inputPlanes[0]?.byteLength === 0 || this.outputPlanes[0]?.byteLength === 0) {
+      this.acquirePlanes();
+    }
+    const input = inputs[0];
+    const inChannels = input?.length ?? 0;
+    let code;
+    if (inChannels === 0) {
+      code = this.native.processPreparedSilence(frames);
+    } else if (inChannels > MAX_INPUT_CHANNELS) {
+      this.unsupportedInputBlocks++;
+      code = this.native.processPreparedSilence(frames);
+    } else {
+      for (let ch = 0; ch < inChannels; ch++) {
+        const source = input[ch];
+        const plane = this.inputPlanes[ch];
+        const copied = Math.min(frames, source.length);
+        plane.set(copied === source.length ? source : source.subarray(0, copied));
+        if (copied < frames) {
+          plane.fill(0, copied, frames);
+        }
+      }
+      code = this.native.processPrepared(inChannels, frames);
+      if (code !== 0) {
+        this.unsupportedInputBlocks++;
+        code = this.native.processPreparedSilence(frames);
+      }
+    }
+    if (code === 0) {
+      copyPlanesToOutput(output, this.outputPlanes, frames);
+    } else {
+      for (const channel of output) {
+        channel.fill(0);
+      }
+    }
+    return true;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.renderer.delete();
+  }
+  acquirePlanes() {
+    this.inputPlanes = [];
+    for (let ch = 0; ch < MAX_INPUT_CHANNELS; ch++) {
+      this.inputPlanes.push(this.native.inputPlane(ch));
+    }
+    this.outputPlanes = [];
+    for (let ch = 0; ch < this.outputChannels; ch++) {
+      this.outputPlanes.push(this.native.outputPlane(ch));
+    }
+  }
+  // Frames past the construction-time capacity are left silent rather than
+  // reallocating on the audio thread.
+  clampFrames(frames) {
+    if (frames <= this.maxBlockSize) {
+      return frames;
+    }
+    if (!_SonarePlaybackWorkletProcessor.warnedBlockOverflow) {
+      _SonarePlaybackWorkletProcessor.warnedBlockOverflow = true;
+      console.warn(
+        `SonarePlaybackWorkletProcessor: requested ${frames} frames exceeds maxBlockSize ${this.maxBlockSize}; clamping.`
+      );
+    }
+    return this.maxBlockSize;
+  }
+};
+_SonarePlaybackWorkletProcessor.warnedBlockOverflow = false;
+var SonarePlaybackWorkletProcessor = _SonarePlaybackWorkletProcessor;
+function registerSonarePlaybackWorkletProcessor(name = "sonare-playback-processor") {
+  const scope = globalThis;
+  if (!scope.AudioWorkletProcessor || !scope.registerProcessor) {
+    throw new Error("AudioWorkletProcessor is not available in this context.");
+  }
+  const Base = scope.AudioWorkletProcessor;
+  class RegisteredSonarePlaybackWorkletProcessor extends Base {
+    constructor(options) {
+      super();
+      const port = this.port;
+      this.bridge = new SonarePlaybackWorkletProcessor(options?.processorOptions ?? {}, port);
+      const onMessage = (event) => {
+        if (isPlaybackMessage(event.data)) {
+          this.bridge.receiveMessage(event.data);
+        }
+      };
+      if (port?.addEventListener) {
+        port.addEventListener("message", onMessage);
+        port.start?.();
+      } else if (port) {
+        port.onmessage = onMessage;
+      }
+    }
+    process(inputs, outputs) {
+      return this.bridge.process(inputs, outputs);
+    }
+  }
+  scope.registerProcessor(name, RegisteredSonarePlaybackWorkletProcessor);
+}
+function createSonarePlaybackNode(context, options = {}) {
+  const config = configObject(options.config);
+  const factory = options.nodeFactory ?? ((ctx, name, nodeOptions) => new AudioWorkletNode(ctx, name, nodeOptions));
+  const processorOptions = {
+    config: JSON.stringify(config),
+    hrtf: options.hrtf,
+    maxBlockSize: options.maxBlockSize,
+    sampleRate: options.sampleRate ?? context.sampleRate
+  };
+  return factory(context, options.processorName ?? "sonare-playback-processor", {
+    numberOfInputs: 1,
+    numberOfOutputs: 1,
+    outputChannelCount: [outputChannelCount(config)],
+    channelCountMode: "max",
+    channelInterpretation: "discrete",
+    processorOptions
+  });
+}
+
 // src/worklet/voice-changer-processor.ts
 var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChangerWorkletProcessor {
   constructor(options = {}) {
+    // Reused so the mono fan-out never builds an array on the audio thread.
+    this.monoPlane = [new Float32Array(0)];
     this.destroyed = false;
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
-    this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 1));
+    this.channelCount = requireChannelCount(options.channelCount, 1);
     this.changer = new RealtimeVoiceChanger(options.preset ?? "neutral-monitor");
     this.changer.prepare(this.sampleRate, this.blockSize, this.channelCount);
     this.monoInput = this.changer.getMonoInputBuffer(this.blockSize);
@@ -6508,7 +8931,8 @@ var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChan
         this.monoInput.fill(0, 0, frames2);
       }
       this.changer.processPreparedMono(frames2);
-      output[0].set(this.monoOutput.subarray(0, frames2));
+      this.monoPlane[0] = this.monoOutput;
+      copyPlanesToOutput(output, this.monoPlane, frames2);
       return true;
     }
     const frames = this.ensureInterleavedCapacity(requestedFrames, requestedChannels);
@@ -6526,12 +8950,7 @@ var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChan
       }
     }
     this.changer.processPreparedPlanar(frames);
-    for (let ch = 0; ch < channels; ch++) {
-      const src = this.planarChannels[ch];
-      if (src) {
-        output[ch].set(src.subarray(0, frames));
-      }
-    }
+    copyPlanesToOutput(output, this.planarChannels, frames);
     return true;
   }
   destroy() {
@@ -6641,16 +9060,19 @@ export {
   SonareEngineCommandType,
   SonareEngineTelemetryError,
   SonareEngineTelemetryType,
+  SonarePlaybackWorkletProcessor,
   SonareRealtimeEngineNode,
   SonareRealtimeEngineWorkletProcessor,
   SonareRealtimeVoiceChangerWorkletProcessor,
   SonareWorkletProcessor,
+  StreamingMasteringChain,
   attachOpfsClipStream,
   createSonareClipPageRequestRingBuffer,
   createSonareEngineCommandRingBuffer,
   createSonareEngineTelemetryRingBuffer,
   createSonareExternalMidiRingBuffer,
   createSonareMeterRingBuffer,
+  createSonarePlaybackNode,
   createSonareScopeRingBuffer,
   createSonareSpectrumRingBuffer,
   decodeFrame,
@@ -6668,6 +9090,7 @@ export {
   readSonareMeterRingBuffer,
   readSonareScopeRingBuffer,
   readSonareSpectrumRingBuffer,
+  registerSonarePlaybackWorkletProcessor,
   registerSonareRealtimeEngineWorkletProcessor,
   registerSonareRealtimeVoiceChangerWorkletProcessor,
   registerSonareWorkletProcessor,