@libraz/libsonare 1.2.1 → 1.2.3

package/dist/worklet.js

@@ -29,6 +29,21 @@ function panLawCode(panLaw) {
       return 0;
   }
 }
+function panModeCode(panMode) {
+  if (typeof panMode === "number") {
+    return panMode;
+  }
+  switch (panMode) {
+    case "stereoPan":
+    case "stereo-pan":
+      return 1;
+    case "dualPan":
+    case "dual-pan":
+      return 2;
+    default:
+      return 0;
+  }
+}
 function meterTapCode(tap) {
   return tap === "preFader" || tap === 0 ? 0 : 1;
 }
@@ -214,6 +229,31 @@ var RealtimeEngine = class {
   process(channels) {
     return this.native.process(channels);
   }
+  /**
+   * Allocates persistent per-channel WASM-heap scratch for the zero-copy
+   * `getChannelBuffer` / `processPrepared` realtime path. Call once (off the
+   * audio thread) before driving `processPrepared` from an AudioWorklet so the
+   * render callback never allocates on the C++/JS heap.
+   */
+  prepareChannels(numChannels, maxFrames) {
+    this.native.prepareChannels(numChannels, maxFrames);
+  }
+  /**
+   * Returns a Float32Array view onto the persistent WASM-heap scratch for one
+   * channel (valid for up to `numFrames`). Fill it, call `processPrepared`, then
+   * read the same view back. Re-acquire after WASM memory growth.
+   */
+  getChannelBuffer(channel, numFrames) {
+    return this.native.getChannelBuffer(channel, numFrames);
+  }
+  /**
+   * Runs the engine in place over the prepared per-channel scratch buffers.
+   * Allocation-free: safe to call on the AudioWorklet render thread after
+   * `prepareChannels`.
+   */
+  processPrepared(numFrames) {
+    this.native.processPrepared(numFrames);
+  }
   processWithMonitor(channels) {
     return this.native.processWithMonitor(channels);
   }
@@ -236,6 +276,141 @@ var RealtimeEngine = class {
     this.native.delete();
   }
 };
+var RealtimeVoiceChanger = class {
+  constructor(config = "neutral-monitor") {
+    if (!module) {
+      throw new Error("Module not initialized. Call init() first.");
+    }
+    this.changer = module.createRealtimeVoiceChanger(config);
+  }
+  prepare(sampleRate, maxBlockSize = 128, channels = 1) {
+    this.changer.prepare(sampleRate, maxBlockSize, channels);
+  }
+  reset() {
+    this.changer.reset();
+  }
+  setConfig(config) {
+    this.changer.setConfig(config);
+  }
+  configJson() {
+    return this.changer.configJson();
+  }
+  latencySamples() {
+    return this.changer.latencySamples();
+  }
+  processMono(samples) {
+    return this.changer.processMono(samples);
+  }
+  processMonoInto(samples, output) {
+    this.changer.processMonoInto(samples, output);
+  }
+  processInterleaved(samples, channels) {
+    return this.changer.processInterleaved(samples, channels);
+  }
+  processInterleavedInto(samples, channels, output) {
+    this.changer.processInterleavedInto(samples, channels, output);
+  }
+  /**
+   * Acquire a typed-memory view onto the WASM heap for mono input.
+   *
+   * Write your input samples into the returned `Float32Array` directly (e.g.
+   * via `input.set(source)`); no copy crosses the JS↔C++ bridge until
+   * {@link processPreparedMono} is called. The view is owned by this
+   * RealtimeVoiceChanger and becomes invalid after {@link delete}; it may
+   * also be invalidated if you later call this method with a larger
+   * `numSamples` value (the underlying buffer may be reallocated).
+   */
+  getMonoInputBuffer(numSamples) {
+    return this.changer.getMonoInputBuffer(numSamples);
+  }
+  /** Mono output view counterpart to {@link getMonoInputBuffer}. */
+  getMonoOutputBuffer(numSamples) {
+    return this.changer.getMonoOutputBuffer(numSamples);
+  }
+  /**
+   * Process the previously-acquired mono input buffer in place. The output
+   * appears in the buffer returned by {@link getMonoOutputBuffer}. No JS↔C++
+   * sample-level crossings happen on this call — it just hands control to
+   * the underlying DSP on already-on-heap data.
+   */
+  processPreparedMono(numSamples) {
+    this.changer.processPreparedMono(numSamples);
+  }
+  /** Interleaved input view (layout L0,R0,L1,R1,...). */
+  getInterleavedInputBuffer(numFrames, numChannels) {
+    return this.changer.getInterleavedInputBuffer(numFrames, numChannels);
+  }
+  /** Interleaved output view counterpart. */
+  getInterleavedOutputBuffer(numFrames, numChannels) {
+    return this.changer.getInterleavedOutputBuffer(numFrames, numChannels);
+  }
+  /**
+   * Process the previously-acquired interleaved buffer in place. Output
+   * appears in the buffer returned by {@link getInterleavedOutputBuffer}.
+   */
+  processPreparedInterleaved(numFrames, numChannels) {
+    this.changer.processPreparedInterleaved(numFrames, numChannels);
+  }
+  /**
+   * Planar-channel input/output view (one Float32Array per channel). Matches
+   * AudioWorklet's native layout; processing happens in place.
+   */
+  getPlanarChannelBuffer(channel, numFrames) {
+    return this.changer.getPlanarChannelBuffer(channel, numFrames);
+  }
+  /**
+   * Process the previously-acquired planar channel buffers in place. Each
+   * channel must have been obtained from {@link getPlanarChannelBuffer}
+   * with the same `numFrames`. Output replaces input in the same buffers.
+   */
+  processPreparedPlanar(numFrames) {
+    this.changer.processPreparedPlanar(numFrames);
+  }
+  /**
+   * Convenience factory for the mono zero-copy path: returns the input/output
+   * heap views plus a `process()` thunk wired to the same `numSamples`. The
+   * views are reused across calls and become invalid after {@link delete}.
+   */
+  createRealtimeMonoBuffer(numSamples) {
+    const input = this.getMonoInputBuffer(numSamples);
+    const output = this.getMonoOutputBuffer(numSamples);
+    return {
+      input,
+      output,
+      process: () => this.processPreparedMono(numSamples)
+    };
+  }
+  /** Same as {@link createRealtimeMonoBuffer} but for interleaved I/O. */
+  createRealtimeInterleavedBuffer(numFrames, numChannels) {
+    const input = this.getInterleavedInputBuffer(numFrames, numChannels);
+    const output = this.getInterleavedOutputBuffer(numFrames, numChannels);
+    return {
+      input,
+      output,
+      channels: numChannels,
+      process: () => this.processPreparedInterleaved(numFrames, numChannels)
+    };
+  }
+  /**
+   * Convenience factory for the planar zero-copy path. Acquires one
+   * heap-backed Float32Array per channel and returns a `process()` thunk
+   * wired to the same `numFrames`. Buffers are reused across calls and
+   * become invalid after {@link delete}.
+   */
+  createRealtimePlanarBuffer(numFrames, numChannels) {
+    const channels = [];
+    for (let ch = 0; ch < numChannels; ch++) {
+      channels.push(this.getPlanarChannelBuffer(ch, numFrames));
+    }
+    return {
+      channels,
+      process: () => this.processPreparedPlanar(numFrames)
+    };
+  }
+  delete() {
+    this.changer.delete();
+  }
+};
 var Mixer = class _Mixer {
   constructor(mixer) {
     this.mixer = mixer;
@@ -379,6 +554,26 @@ var Mixer = class _Mixer {
   vcaGroupCount() {
     return this.mixer.vcaGroupCount();
   }
+  /** Set the strip's input trim in dB. */
+  setInputTrimDb(stripIndex, db) {
+    this.mixer.setInputTrimDb(stripIndex, db);
+  }
+  /** Set the strip's fader level in dB. */
+  setFaderDb(stripIndex, db) {
+    this.mixer.setFaderDb(stripIndex, db);
+  }
+  /** Set the strip's pan position. */
+  setPan(stripIndex, pan, panMode = 0) {
+    this.mixer.setPan(stripIndex, pan, panModeCode(panMode));
+  }
+  /** Set the strip's stereo width. */
+  setWidth(stripIndex, width) {
+    this.mixer.setWidth(stripIndex, width);
+  }
+  /** Set the strip's mute state. */
+  setMuted(stripIndex, muted) {
+    this.mixer.setMuted(stripIndex, muted);
+  }
   /**
    * Set a strip's solo state. Takes effect on the next process without a
    * graph recompile.
@@ -526,8 +721,20 @@ var Mixer = class _Mixer {
 
 // src/worklet.ts
 var SONARE_METER_RING_HEADER_INTS = 4;
-var SONARE_METER_RING_RECORD_FLOATS = 6;
+var SONARE_METER_RING_RECORD_FLOATS = 7;
 var SONARE_SPECTRUM_RING_HEADER_INTS = 5;
+var SONARE_FRAME_LANE_BASE = 16777216;
+function encodeFrameLo(frame) {
+  const f = Math.max(0, Math.floor(frame));
+  return f % SONARE_FRAME_LANE_BASE;
+}
+function encodeFrameHi(frame) {
+  const f = Math.max(0, Math.floor(frame));
+  return Math.floor(f / SONARE_FRAME_LANE_BASE);
+}
+function decodeFrame(lo, hi) {
+  return hi * SONARE_FRAME_LANE_BASE + lo;
+}
 var SONARE_ENGINE_RING_HEADER_INTS = 5;
 var SONARE_ENGINE_COMMAND_RECORD_BYTES = 32;
 var SONARE_ENGINE_TELEMETRY_RECORD_BYTES = 48;
@@ -574,6 +781,18 @@ var SonareEngineTelemetryError = /* @__PURE__ */ ((SonareEngineTelemetryError2)
   SonareEngineTelemetryError2[SonareEngineTelemetryError2["SmoothedParameterCapacity"] = 13] = "SmoothedParameterCapacity";
   return SonareEngineTelemetryError2;
 })(SonareEngineTelemetryError || {});
+var DEFAULT_METRONOME_CONFIG = {
+  beatGain: 0.35,
+  accentGain: 0.7,
+  clickSamples: 96
+};
+function resolveMetronomeConfig(config) {
+  return {
+    beatGain: config.beatGain ?? DEFAULT_METRONOME_CONFIG.beatGain,
+    accentGain: config.accentGain ?? DEFAULT_METRONOME_CONFIG.accentGain,
+    clickSamples: config.clickSamples ?? DEFAULT_METRONOME_CONFIG.clickSamples
+  };
+}
 function toDb(value) {
   return value > 0 ? 20 * Math.log10(value) : Number.NEGATIVE_INFINITY;
 }
@@ -589,6 +808,18 @@ function isWorkletMessage(value) {
 function isEngineCommandRecord(value) {
   return isRecord(value) && typeof value.type === "number";
 }
+function isEngineSyncMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  return value.type === "syncClips" || value.type === "syncMarkers" || value.type === "syncMetronome" || value.type === "syncAutomation";
+}
+function isRealtimeVoiceChangerMessage(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+  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";
 }
@@ -618,7 +849,7 @@ function readSonareMeterRingBuffer(ring, readIndex = 0) {
     const offset = index % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
     meters.push({
       type: "meter",
-      frame: ring.records[offset],
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 6]),
       peakDbL: ring.records[offset + 1],
       peakDbR: ring.records[offset + 2],
       rmsDbL: ring.records[offset + 3],
@@ -631,7 +862,7 @@ function readSonareMeterRingBuffer(ring, readIndex = 0) {
 function sonareSpectrumRingBufferByteLength(capacity, bands = 16) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
   const clampedBands = Math.max(1, Math.floor(bands));
-  return SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * (2 + clampedBands) * Float32Array.BYTES_PER_ELEMENT;
+  return SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT + clampedCapacity * (3 + clampedBands) * Float32Array.BYTES_PER_ELEMENT;
 }
 function createSonareSpectrumRingBuffer(capacity = 128, bands = 16) {
   const clampedCapacity = Math.max(1, Math.floor(capacity));
@@ -655,7 +886,7 @@ function createSonareSpectrumRingBuffer(capacity = 128, bands = 16) {
 }
 function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
   const writeIndex = Atomics.load(ring.header, 0);
-  const recordFloats = Atomics.load(ring.header, 2) || 2 + ring.bands;
+  const recordFloats = Atomics.load(ring.header, 2) || 3 + ring.bands;
   const bands = Atomics.load(ring.header, 3) || ring.bands;
   const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
   const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
@@ -663,8 +894,12 @@ function readSonareSpectrumRingBuffer(ring, readIndex = 0) {
   for (let index = firstReadable; index < writeIndex; index++) {
     const offset = index % ring.capacity * recordFloats;
     const values = new Float32Array(bands);
-    values.set(ring.records.subarray(offset + 2, offset + 2 + bands));
-    spectra.push({ type: "spectrum", frame: ring.records[offset], bands: values });
+    values.set(ring.records.subarray(offset + 3, offset + 3 + bands));
+    spectra.push({
+      type: "spectrum",
+      frame: decodeFrame(ring.records[offset], ring.records[offset + 1]),
+      bands: values
+    });
   }
   return { nextReadIndex: writeIndex, spectra };
 }
@@ -783,7 +1018,7 @@ function spectrumRingFromSharedBuffer(sharedBuffer, fallbackCapacity, fallbackBa
   const existingBands = Atomics.load(header, 3);
   const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
   const bands = Math.max(1, Math.floor(existingBands || fallbackBands || 16));
-  const recordFloats = 2 + bands;
+  const recordFloats = 3 + bands;
   const minBytes = sonareSpectrumRingBufferByteLength(capacity, bands);
   if (sharedBuffer.byteLength < minBytes) {
     throw new Error("spectrumSharedBuffer is too small for the requested ring capacity.");
@@ -832,8 +1067,7 @@ function writeEngineCommandRecord(view, offset, command) {
   view.setUint32(offset, command.type, true);
   view.setUint32(offset + 4, command.targetId ?? 0, true);
   view.setBigInt64(offset + 8, toBigInt64(command.sampleTime, -1n), true);
-  view.setFloat32(offset + 16, command.argFloat ?? 0, true);
-  view.setUint32(offset + 20, 0, true);
+  view.setFloat64(offset + 16, command.argFloat ?? 0, true);
   view.setBigInt64(offset + 24, toBigInt64(command.argInt, 0n), true);
 }
 function readEngineCommandRecord(view, offset) {
@@ -841,7 +1075,7 @@ function readEngineCommandRecord(view, offset) {
     type: view.getUint32(offset, true),
     targetId: view.getUint32(offset + 4, true),
     sampleTime: Number(view.getBigInt64(offset + 8, true)),
-    argFloat: view.getFloat32(offset + 16, true),
+    argFloat: view.getFloat64(offset + 16, true),
     argInt: Number(view.getBigInt64(offset + 24, true))
   };
 }
@@ -934,35 +1168,48 @@ var SonareWorkletProcessor = class {
       return true;
     }
     const frames = leftOut.length;
-    if (frames !== this.blockSize) {
-      return false;
-    }
+    const usable = Math.min(frames, this.blockSize);
     for (let strip = 0; strip < this.realtime.leftInputs.length; strip++) {
       const input = inputs[strip];
       const left = input?.[0];
       const right = input?.[1];
       const leftTarget = this.realtime.leftInputs[strip];
       const rightTarget = this.realtime.rightInputs[strip];
-      if (left && left.length === frames) {
-        leftTarget.set(left);
-        if (right && right.length === frames) {
-          rightTarget.set(right);
+      if (left && left.length >= usable) {
+        leftTarget.set(left.subarray(0, usable));
+        if (right && right.length >= usable) {
+          rightTarget.set(right.subarray(0, usable));
         } else {
-          rightTarget.set(left);
+          rightTarget.set(left.subarray(0, usable));
         }
       } else {
         leftTarget.fill(0);
         rightTarget.fill(0);
       }
     }
-    this.realtime.process(frames);
-    leftOut.set(this.realtime.outLeft);
-    if (rightOut) {
-      rightOut.set(this.realtime.outRight);
+    this.realtime.process(usable);
+    if (usable === frames) {
+      leftOut.set(this.realtime.outLeft.subarray(0, usable));
+      if (rightOut) {
+        rightOut.set(this.realtime.outRight.subarray(0, usable));
+      }
+    } else {
+      leftOut.fill(0);
+      leftOut.set(this.realtime.outLeft.subarray(0, usable));
+      if (rightOut) {
+        rightOut.fill(0);
+        rightOut.set(this.realtime.outRight.subarray(0, usable));
+      }
     }
-    this.processedFrames += frames;
-    this.publishMeter(this.realtime.outLeft, this.realtime.outRight);
-    this.publishSpectrum(this.realtime.outLeft, this.realtime.outRight);
+    this.processedFrames += usable;
+    this.publishMeter(
+      this.realtime.outLeft.subarray(0, usable),
+      this.realtime.outRight.subarray(0, usable)
+    );
+    this.publishSpectrum(
+      this.realtime.outLeft.subarray(0, usable),
+      this.realtime.outRight.subarray(0, usable)
+    );
     return true;
   }
   receiveMessage(message) {
@@ -1048,16 +1295,14 @@ var SonareWorkletProcessor = class {
     }
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
-    ring.records[offset] = meter.frame;
+    ring.records[offset] = encodeFrameLo(meter.frame);
     ring.records[offset + 1] = meter.peakDbL;
     ring.records[offset + 2] = meter.peakDbR;
     ring.records[offset + 3] = meter.rmsDbL;
     ring.records[offset + 4] = meter.rmsDbR;
     ring.records[offset + 5] = meter.correlation;
+    ring.records[offset + 6] = encodeFrameHi(meter.frame);
     Atomics.store(ring.header, 0, writeIndex + 1);
-    if (writeIndex + 1 > ring.capacity) {
-      Atomics.store(ring.header, 3, writeIndex + 1 - ring.capacity);
-    }
   }
   publishSpectrum(left, right) {
     if (this.spectrumIntervalFrames <= 0) {
@@ -1082,7 +1327,12 @@ var SonareWorkletProcessor = class {
   }
   computeSpectrum(left, right) {
     const n = Math.max(1, Math.min(left.length, right.length));
+    const maxBand = Math.floor(n / 2);
     for (let band = 0; band < this.spectrumBands.length; band++) {
+      if (band >= maxBand) {
+        this.spectrumBands[band] = magnitudeToDb(0);
+        continue;
+      }
       const bin = band + 1;
       let real = 0;
       let imag = 0;
@@ -1102,19 +1352,20 @@ var SonareWorkletProcessor = class {
     }
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = writeIndex % ring.capacity * ring.recordFloats;
-    ring.records[offset] = frame;
-    ring.records[offset + 1] = bands.length;
-    ring.records.set(bands.subarray(0, ring.bands), offset + 2);
+    ring.records[offset] = encodeFrameLo(frame);
+    ring.records[offset + 1] = encodeFrameHi(frame);
+    ring.records[offset + 2] = bands.length;
+    ring.records.set(bands.subarray(0, ring.bands), offset + 3);
     Atomics.store(ring.header, 0, writeIndex + 1);
-    if (writeIndex + 1 > ring.capacity) {
-      Atomics.store(ring.header, 4, writeIndex + 1 - ring.capacity);
-    }
   }
 };
-var SonareRealtimeEngineWorkletProcessor = class {
+var _SonareRealtimeEngineWorkletProcessor = class _SonareRealtimeEngineWorkletProcessor {
   constructor(options = {}, transport) {
     this.closed = false;
     this.lastMeterFrame = Number.NEGATIVE_INFINITY;
+    // Latest metronome gains/click length pushed via 'syncMetronome'. The
+    // SetMetronome command only toggles enabled state; the config arrives here.
+    this.metronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
     this.sampleRate = options.sampleRate ?? 48e3;
     this.blockSize = options.blockSize ?? 128;
     this.channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
@@ -1131,7 +1382,13 @@ var SonareRealtimeEngineWorkletProcessor = class {
       options.telemetrySharedBuffer,
       options.telemetryRingCapacity
     ) : void 0;
+    this.meterRing = options.meterSharedBuffer ? meterRingFromSharedBuffer(options.meterSharedBuffer, options.meterRingCapacity) : void 0;
     this.engine = new RealtimeEngine(this.sampleRate, this.blockSize);
+    this.engine.prepareChannels(this.channelCount, this.blockSize);
+    this.channelBuffers = new Array(this.channelCount);
+    for (let ch = 0; ch < this.channelCount; ch++) {
+      this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
+    }
   }
   process(inputs, outputs) {
     if (this.closed) {
@@ -1151,22 +1408,38 @@ var SonareRealtimeEngineWorkletProcessor = class {
       return true;
     }
     this.drainCommands();
-    const channels = [];
+    let usableFrames = frames;
+    if (usableFrames > this.blockSize) {
+      if (!_SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow) {
+        _SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow = true;
+        console.warn(
+          `SonareRealtimeEngineWorkletProcessor: requested ${usableFrames} frames exceeds pre-allocated capacity ${this.blockSize}; clamping.`
+        );
+      }
+      usableFrames = this.blockSize;
+    }
+    if ((this.channelBuffers[0]?.byteLength ?? 0) === 0) {
+      this.reacquireChannelBuffers();
+    }
     const input = inputs[0];
     for (let ch = 0; ch < this.channelCount; ch++) {
+      const dst = this.channelBuffers[ch];
       const source = input?.[ch];
-      const channel = new Float32Array(frames);
-      if (source && source.length === frames) {
-        channel.set(source);
+      if (source && source.length === usableFrames) {
+        dst.set(source.subarray(0, usableFrames));
+      } else {
+        dst.fill(0, 0, usableFrames);
       }
-      channels.push(channel);
     }
-    const processed = this.engine.process(channels);
+    this.engine.processPrepared(usableFrames);
     for (let ch = 0; ch < output.length; ch++) {
       const target = output[ch];
-      const source = processed[ch] ?? processed[0];
+      const source = this.channelBuffers[ch] ?? this.channelBuffers[0];
       if (source) {
-        target.set(source.subarray(0, target.length));
+        target.set(source.subarray(0, Math.min(target.length, usableFrames)));
+        if (target.length > usableFrames) {
+          target.fill(0, usableFrames);
+        }
       } else {
         target.fill(0);
       }
@@ -1175,11 +1448,41 @@ var SonareRealtimeEngineWorkletProcessor = class {
     this.publishMeters();
     return true;
   }
+  reacquireChannelBuffers() {
+    for (let ch = 0; ch < this.channelCount; ch++) {
+      this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
+    }
+  }
   receiveCommand(command) {
     if (!this.closed) {
       this.applyCommand(command);
     }
   }
+  // Applies an out-of-band control-plane sync message. Runs on the AudioWorklet
+  // global scope but OUTSIDE process() (the message-port callback), so the
+  // bulk/allocating engine setters (setClips/setMarkers) are safe here — they
+  // never run on the realtime render path. This is the audio-thread equivalent
+  // of the engine's control-thread RtPublisher setters.
+  receiveSync(message) {
+    if (this.closed) {
+      return;
+    }
+    switch (message.type) {
+      case "syncClips":
+        this.engine.setClips(message.clips);
+        break;
+      case "syncMarkers":
+        this.engine.setMarkers(message.markers);
+        break;
+      case "syncMetronome":
+        this.metronomeConfig = resolveMetronomeConfig(message.config);
+        this.engine.setMetronome(message.config);
+        break;
+      case "syncAutomation":
+        this.engine.setAutomationLane(message.paramId, message.points);
+        break;
+    }
+  }
   destroy() {
     if (!this.closed) {
       this.engine.destroy();
@@ -1201,6 +1504,20 @@ var SonareRealtimeEngineWorkletProcessor = class {
   applyCommand(command) {
     const sampleTime = Number(command.sampleTime ?? -1);
     switch (command.type) {
+      case 0 /* SetParam */:
+        this.engine.setParameter(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Number(command.argFloat ?? 0),
+          sampleTime
+        );
+        break;
+      case 1 /* SetParamSmoothed */:
+        this.engine.setParameterSmoothed(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Number(command.argFloat ?? 0),
+          sampleTime
+        );
+        break;
       case 2 /* TransportPlay */:
         this.engine.play(sampleTime);
         break;
@@ -1229,18 +1546,21 @@ var SonareRealtimeEngineWorkletProcessor = class {
       case 14 /* Punch */:
         this.engine.setCapturePunch(
           Number(command.argInt ?? 0),
-          Math.max(0, Math.round(Number(command.argFloat ?? 0) * this.sampleRate)),
+          Math.max(0, Math.round(Number(command.argFloat ?? 0))),
           true
         );
         break;
       case 15 /* SetMetronome */:
         this.engine.setMetronome({
           enabled: Boolean(command.argInt),
-          beatGain: 0.25,
-          accentGain: 0.75,
-          clickSamples: 64
+          beatGain: this.metronomeConfig.beatGain,
+          accentGain: this.metronomeConfig.accentGain,
+          clickSamples: this.metronomeConfig.clickSamples
         });
         break;
+      case 17 /* SeekMarker */:
+        this.engine.seekMarker(Math.trunc(Number(command.targetId ?? 0)), sampleTime);
+        break;
       default:
         this.publishTelemetryRecord({
           type: 1 /* Error */,
@@ -1267,7 +1587,7 @@ var SonareRealtimeEngineWorkletProcessor = class {
     this.transport?.postMessage?.(record);
   }
   publishMeters() {
-    if (!this.transport || this.meterIntervalFrames <= 0) {
+    if (this.meterIntervalFrames <= 0 || !this.transport && !this.meterRing) {
       return;
     }
     for (const item of this.engine.drainMeterTelemetry(64)) {
@@ -1276,10 +1596,30 @@ var SonareRealtimeEngineWorkletProcessor = class {
         continue;
       }
       this.lastMeterFrame = meter.frame;
-      this.transport.onMeter?.(meter);
-      this.transport.postMessage?.(meter);
+      if (this.meterRing) {
+        this.writeMeterRing(meter);
+      } else {
+        this.transport?.onMeter?.(meter);
+        this.transport?.postMessage?.(meter);
+      }
     }
   }
+  writeMeterRing(meter) {
+    const ring = this.meterRing;
+    if (!ring) {
+      return;
+    }
+    const writeIndex = Atomics.load(ring.header, 0);
+    const offset = writeIndex % ring.capacity * SONARE_METER_RING_RECORD_FLOATS;
+    ring.records[offset] = encodeFrameLo(meter.frame);
+    ring.records[offset + 1] = meter.peakDbL;
+    ring.records[offset + 2] = meter.peakDbR;
+    ring.records[offset + 3] = meter.rmsDbL;
+    ring.records[offset + 4] = meter.rmsDbR;
+    ring.records[offset + 5] = meter.correlation;
+    ring.records[offset + 6] = encodeFrameHi(meter.frame);
+    Atomics.store(ring.header, 0, writeIndex + 1);
+  }
   commandRingFromSharedBuffer(sharedBuffer, fallbackCapacity) {
     const ring = engineRingFromSharedBuffer(
       sharedBuffer,
@@ -1297,8 +1637,11 @@ var SonareRealtimeEngineWorkletProcessor = class {
     return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
   }
 };
+_SonareRealtimeEngineWorkletProcessor.warnedChannelScratchOverflow = false;
+var SonareRealtimeEngineWorkletProcessor = _SonareRealtimeEngineWorkletProcessor;
 var SonareRtRealtimeEngineRuntime = class {
   constructor(options) {
+    this.metronomeConfig = { ...DEFAULT_METRONOME_CONFIG };
     this.closed = false;
     this.module = options.module;
     this.memory = options.memory;
@@ -1380,6 +1723,49 @@ var SonareRtRealtimeEngineRuntime = class {
     this.publishTelemetry();
     return true;
   }
+  receiveCommand(command) {
+    if (!this.closed) {
+      this.applyCommand(command);
+    }
+  }
+  // Out-of-band control sync for the sonare-rt runtime. The sonare-rt C ABI
+  // (src/wasm/rt_bindings.cpp) exposes set_metronome_enabled and seek_marker but
+  // NOT set_clips / set_markers, so clip/marker mutations cannot be applied to a
+  // live sonare-rt engine. We honor the metronome config and surface a clear
+  // telemetry error for the unsupported clip/marker paths instead of silently
+  // dropping them. The default 'embind' runtime wires all three fully.
+  receiveSync(message) {
+    if (this.closed) {
+      return;
+    }
+    switch (message.type) {
+      case "syncMetronome":
+        this.metronomeConfig = resolveMetronomeConfig(message.config);
+        this.module._sonare_rt_engine_set_metronome_enabled(
+          this.engine,
+          message.config.enabled ? 1 : 0,
+          this.metronomeConfig.beatGain,
+          this.metronomeConfig.accentGain,
+          this.metronomeConfig.clickSamples
+        );
+        break;
+      case "syncClips":
+      case "syncMarkers":
+      case "syncAutomation":
+        if (this.telemetryRing) {
+          writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
+            type: 1 /* Error */,
+            error: 7 /* UnknownTarget */,
+            renderFrame: 0,
+            timelineSample: 0,
+            audibleTimelineSample: 0,
+            graphLatencySamplesQ8: 0,
+            value: 0
+          });
+        }
+        break;
+    }
+  }
   destroy() {
     if (this.closed) {
       return;
@@ -1415,6 +1801,20 @@ var SonareRtRealtimeEngineRuntime = class {
   applyCommand(command) {
     const sampleTime = toBigInt64(command.sampleTime, -1n);
     switch (command.type) {
+      case 0 /* SetParam */:
+      case 1 /* SetParamSmoothed */:
+        if (this.telemetryRing) {
+          writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
+            type: 1 /* Error */,
+            error: 7 /* UnknownTarget */,
+            renderFrame: 0,
+            timelineSample: 0,
+            audibleTimelineSample: 0,
+            graphLatencySamplesQ8: 0,
+            value: Number(command.type)
+          });
+        }
+        break;
       case 2 /* TransportPlay */:
         this.module._sonare_rt_engine_play(this.engine, sampleTime);
         break;
@@ -1453,7 +1853,7 @@ var SonareRtRealtimeEngineRuntime = class {
         this.module._sonare_rt_engine_set_capture_punch(
           this.engine,
           toBigInt64(command.argInt, 0n),
-          BigInt(Math.trunc(Number(command.argFloat ?? 0) * this.sampleRate)),
+          BigInt(Math.max(0, Math.round(Number(command.argFloat ?? 0)))),
           1
         );
         break;
@@ -1461,9 +1861,9 @@ var SonareRtRealtimeEngineRuntime = class {
         this.module._sonare_rt_engine_set_metronome_enabled(
           this.engine,
           command.argInt ? 1 : 0,
-          0.25,
-          0.75,
-          64
+          this.metronomeConfig.beatGain,
+          this.metronomeConfig.accentGain,
+          this.metronomeConfig.clickSamples
         );
         break;
       case 17 /* SeekMarker */:
@@ -1538,8 +1938,9 @@ var SonareRtRealtimeEngineRuntime = class {
   }
 };
 var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
-  constructor(node, capabilities, commandRing, telemetryRing) {
+  constructor(node, capabilities, commandRing, telemetryRing, meterRing) {
     this.telemetryReadIndex = 0;
+    this.meterReadIndex = 0;
     this.telemetryListeners = /* @__PURE__ */ new Set();
     this.meterListeners = /* @__PURE__ */ new Set();
     this.destroyed = false;
@@ -1547,6 +1948,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     this.capabilities = capabilities;
     this.commandRing = commandRing;
     this.telemetryRing = telemetryRing;
+    this.meterRing = meterRing;
     this.ready = new Promise((resolve, reject) => {
       this.resolveReady = resolve;
       this.rejectReady = reject;
@@ -1595,6 +1997,7 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     }
     const commandRing = mode === "sab" ? createSonareEngineCommandRingBuffer(options.commandRingCapacity ?? 128) : void 0;
     const telemetryRing = mode === "sab" ? createSonareEngineTelemetryRingBuffer(options.telemetryRingCapacity ?? 128) : void 0;
+    const meterRing = mode === "sab" && runtimeTarget === "embind" ? createSonareMeterRingBuffer(options.meterRingCapacity ?? 128) : void 0;
     const channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
     const processorOptions = {
       runtimeTarget,
@@ -1606,7 +2009,9 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
       commandSharedBuffer: commandRing?.sharedBuffer,
       commandRingCapacity: commandRing?.capacity,
       telemetrySharedBuffer: telemetryRing?.sharedBuffer,
-      telemetryRingCapacity: telemetryRing?.capacity
+      telemetryRingCapacity: telemetryRing?.capacity,
+      meterSharedBuffer: meterRing?.sharedBuffer,
+      meterRingCapacity: meterRing?.capacity
     };
     const factory = options.nodeFactory ?? ((ctx, name, nodeOptions) => new AudioWorkletNode(ctx, name, nodeOptions));
     const node = factory(context, processorName, {
@@ -1629,7 +2034,8 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
         degradedReason
       },
       commandRing,
-      telemetryRing
+      telemetryRing,
+      meterRing
     );
   }
   play(sampleTime = -1) {
@@ -1673,6 +2079,20 @@ var SonareRealtimeEngineNode = class _SonareRealtimeEngineNode {
     }
     return read.telemetry;
   }
+  // Drains any meters published into the SAB meter ring (embind SAB mode) and
+  // forwards them to onMeter listeners. In postMessage mode meters arrive via
+  // node.port.onmessage instead, so this is a no-op then.
+  pollMeters() {
+    if (!this.meterRing) {
+      return [];
+    }
+    const read = readSonareMeterRingBuffer(this.meterRing, this.meterReadIndex);
+    this.meterReadIndex = read.nextReadIndex;
+    for (const meter of read.meters) {
+      this.emitMeter(meter);
+    }
+    return read.meters;
+  }
   onTelemetry(callback) {
     this.telemetryListeners.add(callback);
     return () => {
@@ -1787,10 +2207,14 @@ var SonareEngine = class _SonareEngine {
     });
   }
   setParam(nodeId, param, value) {
-    void nodeId;
-    void param;
-    void value;
-    return false;
+    const paramId = this.resolveParamId(nodeId, param);
+    this.offlineEngine.setParameter(paramId, value);
+    return this.realtimeNode.sendCommand({
+      type: 0 /* SetParam */,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: value
+    });
   }
   scheduleParam(nodeId, param, ppq, value, curve = "linear") {
     const paramId = this.resolveParamId(nodeId, param);
@@ -1799,6 +2223,7 @@ var SonareEngine = class _SonareEngine {
     lane.sort((a, b) => a.ppq - b.ppq);
     this.automationLanes.set(paramId, lane);
     this.offlineEngine.setAutomationLane(paramId, lane);
+    this.postSync({ type: "syncAutomation", paramId, points: lane });
   }
   addAutomationPoint(laneId, ppq, value, curve = "linear") {
     this.scheduleParam("", laneId, ppq, value, curve);
@@ -1814,7 +2239,9 @@ var SonareEngine = class _SonareEngine {
     void target;
     void solo;
     void mute;
-    return false;
+    throw new Error(
+      "SonareEngine.setSoloMute is not supported: solo/mute is a Mixer feature; use Mixer.setSoloed(stripIndex, ...) / Mixer.setMuted(stripIndex, ...) instead."
+    );
   }
   addClip(trackId, buffer, startPpq, opts = {}) {
     const id = opts.id ?? this.nextClipId++;
@@ -1850,11 +2277,12 @@ var SonareEngine = class _SonareEngine {
       type: 14 /* Punch */,
       sampleTime: -1,
       argInt: inSample,
-      argFloat: outPpq
+      argFloat: outSample
     });
   }
   setMetronome(opts) {
     this.offlineEngine.setMetronome(opts);
+    this.postSync({ type: "syncMetronome", config: opts });
     this.realtimeNode.sendCommand({
       type: 15 /* SetMetronome */,
       sampleTime: -1,
@@ -1869,7 +2297,11 @@ var SonareEngine = class _SonareEngine {
   }
   seekMarker(markerId) {
     this.offlineEngine.seekMarker(markerId);
-    return false;
+    return this.realtimeNode.sendCommand({
+      type: 17 /* SeekMarker */,
+      targetId: markerId,
+      sampleTime: -1
+    });
   }
   async renderOffline(totalFrames) {
     const frames = Math.max(0, Math.floor(totalFrames));
@@ -1888,6 +2320,9 @@ var SonareEngine = class _SonareEngine {
   pollTelemetry() {
     return this.realtimeNode.pollTelemetry();
   }
+  pollMeters() {
+    return this.realtimeNode.pollMeters();
+  }
   destroy() {
     if (this.destroyed) {
       return;
@@ -1899,10 +2334,23 @@ var SonareEngine = class _SonareEngine {
     this.offlineEngine.destroy();
   }
   syncClips() {
-    this.offlineEngine.setClips(Array.from(this.clips.values()));
+    const clips = Array.from(this.clips.values());
+    this.offlineEngine.setClips(clips);
+    this.postSync({ type: "syncClips", clips });
   }
   syncMarkers() {
-    this.offlineEngine.setMarkers(Array.from(this.markers.values()).sort((a, b) => a.ppq - b.ppq));
+    const markers = Array.from(this.markers.values()).sort((a, b) => a.ppq - b.ppq);
+    this.offlineEngine.setMarkers(markers);
+    this.postSync({ type: "syncMarkers", markers });
+  }
+  // Posts an out-of-band control-sync message to the worklet engine processor.
+  // Sync messages use a string `type` so the worklet's message handler routes
+  // them to receiveSync() (numeric `type` is reserved for SonareEngineCommandRecord).
+  postSync(message) {
+    if (this.destroyed) {
+      return;
+    }
+    this.realtimeNode.node.port.postMessage(message);
   }
   resolveParamId(nodeId, param) {
     if (typeof param === "number") {
@@ -1931,6 +2379,156 @@ var SonareEngine = class _SonareEngine {
     return Math.max(0, Math.round(ppq * 60 / 120 * this.sampleRate));
   }
 };
+var _SonareRealtimeVoiceChangerWorkletProcessor = class _SonareRealtimeVoiceChangerWorkletProcessor {
+  constructor(options = {}) {
+    this.destroyed = false;
+    this.sampleRate = options.sampleRate ?? 48e3;
+    this.blockSize = options.blockSize ?? 128;
+    this.channelCount = Math.max(1, Math.floor(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);
+    this.monoOutput = this.changer.getMonoOutputBuffer(this.blockSize);
+    this.planarChannels = [];
+    if (this.channelCount > 1) {
+      for (let ch = 0; ch < this.channelCount; ch++) {
+        this.planarChannels.push(this.changer.getPlanarChannelBuffer(ch, this.blockSize));
+      }
+    }
+  }
+  /**
+   * Handles a control-plane message from the main thread. Runs on the
+   * AudioWorklet global scope but OUTSIDE of `process()` (i.e. outside the
+   * realtime audio callback), so it is safe to perform JSON parsing and
+   * DSP coefficient recomputation here. `setConfig` MUST NOT be deferred
+   * into `process()` because that would block the audio thread for longer
+   * than one render quantum (e.g. 128 samples / 44.1 kHz = ~2.9 ms).
+   */
+  receiveMessage(message) {
+    if (this.destroyed) {
+      return;
+    }
+    if (message.type === "setConfig") {
+      this.changer.setConfig(message.preset);
+    } else if (message.type === "reset") {
+      this.changer.reset();
+    } else if (message.type === "destroy") {
+      this.destroy();
+    }
+  }
+  process(inputs, outputs) {
+    const output = outputs[0];
+    if (this.destroyed || !output || output.length === 0) {
+      return !this.destroyed;
+    }
+    if (this.monoInput.byteLength === 0) {
+      this.reacquireBuffers();
+    }
+    const input = inputs[0];
+    const requestedFrames = output[0]?.length ?? 0;
+    const requestedChannels = Math.min(this.channelCount, output.length);
+    if (requestedFrames === 0 || requestedChannels === 0) {
+      return true;
+    }
+    if (requestedChannels === 1) {
+      const frames2 = this.ensureMonoCapacity(requestedFrames);
+      const source = input?.[0];
+      if (source) {
+        this.monoInput.set(source.subarray(0, frames2));
+      } else {
+        this.monoInput.fill(0, 0, frames2);
+      }
+      this.changer.processMonoInto(
+        this.monoInput.subarray(0, frames2),
+        this.monoOutput.subarray(0, frames2)
+      );
+      output[0].set(this.monoOutput.subarray(0, frames2));
+      return true;
+    }
+    const frames = this.ensureInterleavedCapacity(requestedFrames, requestedChannels);
+    const channels = requestedChannels;
+    for (let ch = 0; ch < channels; ch++) {
+      const src = input?.[ch];
+      const dst = this.planarChannels[ch];
+      if (!dst) {
+        continue;
+      }
+      if (src) {
+        dst.set(src.subarray(0, frames));
+      } else {
+        dst.fill(0, 0, frames);
+      }
+    }
+    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));
+      }
+    }
+    return true;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.changer.delete();
+  }
+  // Re-acquires the cached WASM-heap views after a memory-growth detachment.
+  // The underlying C++ vectors are pre-warmed (ensure_*_capacity ran at prepare
+  // time), so getMono*/getPlanar* return fresh views onto the SAME storage
+  // without reallocating it.
+  reacquireBuffers() {
+    this.monoInput = this.changer.getMonoInputBuffer(this.blockSize);
+    this.monoOutput = this.changer.getMonoOutputBuffer(this.blockSize);
+    if (this.channelCount > 1) {
+      for (let ch = 0; ch < this.channelCount; ch++) {
+        this.planarChannels[ch] = this.changer.getPlanarChannelBuffer(ch, this.blockSize);
+      }
+    }
+  }
+  /**
+   * Returns the number of frames we can actually process given the
+   * pre-allocated capacity. If the host requests more frames than the
+   * worst-case block size declared at construction time, we clamp to the
+   * available capacity and warn once — we MUST NOT reallocate on the
+   * realtime audio thread.
+   */
+  ensureMonoCapacity(frames) {
+    const capacity = this.monoInput.length;
+    if (frames <= capacity) {
+      return frames;
+    }
+    if (!_SonareRealtimeVoiceChangerWorkletProcessor.warnedMonoOverflow) {
+      _SonareRealtimeVoiceChangerWorkletProcessor.warnedMonoOverflow = true;
+      console.warn(
+        `SonareRealtimeVoiceChangerWorkletProcessor: requested ${frames} mono frames exceeds pre-allocated capacity ${capacity}; clamping. Increase blockSize at construction time to avoid this.`
+      );
+    }
+    return capacity;
+  }
+  /**
+   * Same contract as ensureMonoCapacity but for the planar per-channel
+   * scratch. Returns the number of frames that fit in the available capacity.
+   */
+  ensureInterleavedCapacity(frames, channels) {
+    const capacity = this.planarChannels[0]?.length ?? 0;
+    if (frames <= capacity) {
+      return frames;
+    }
+    if (!_SonareRealtimeVoiceChangerWorkletProcessor.warnedInterleavedOverflow) {
+      _SonareRealtimeVoiceChangerWorkletProcessor.warnedInterleavedOverflow = true;
+      console.warn(
+        `SonareRealtimeVoiceChangerWorkletProcessor: requested ${frames}x${channels} planar frames exceeds pre-allocated capacity ${capacity}; clamping. Increase blockSize or channelCount at construction time to avoid this.`
+      );
+    }
+    return capacity;
+  }
+};
+_SonareRealtimeVoiceChangerWorkletProcessor.warnedMonoOverflow = false;
+_SonareRealtimeVoiceChangerWorkletProcessor.warnedInterleavedOverflow = false;
+var SonareRealtimeVoiceChangerWorkletProcessor = _SonareRealtimeVoiceChangerWorkletProcessor;
 function registerSonareWorkletProcessor(name = "sonare-worklet-processor") {
   const scope = globalThis;
   if (!scope.AudioWorkletProcessor || !scope.registerProcessor) {
@@ -1962,6 +2560,35 @@ function registerSonareWorkletProcessor(name = "sonare-worklet-processor") {
   }
   scope.registerProcessor(name, RegisteredSonareWorkletProcessor);
 }
+function registerSonareRealtimeVoiceChangerWorkletProcessor(name = "sonare-realtime-voice-changer-processor") {
+  const scope = globalThis;
+  if (!scope.AudioWorkletProcessor || !scope.registerProcessor) {
+    throw new Error("AudioWorkletProcessor is not available in this context.");
+  }
+  const Base = scope.AudioWorkletProcessor;
+  class RegisteredSonareRealtimeVoiceChangerWorkletProcessor extends Base {
+    constructor(options) {
+      super();
+      const port = this.port;
+      this.bridge = new SonareRealtimeVoiceChangerWorkletProcessor(options?.processorOptions ?? {});
+      const onMessage = (event) => {
+        if (isRealtimeVoiceChangerMessage(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, RegisteredSonareRealtimeVoiceChangerWorkletProcessor);
+}
 function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-engine-processor") {
   const scope = globalThis;
   if (!scope.AudioWorkletProcessor || !scope.registerProcessor) {
@@ -1984,6 +2611,10 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
       const onMessage = (event) => {
         if (isEngineCommandRecord(event.data)) {
           this.bridge?.receiveCommand(event.data);
+          this.rtBridge?.receiveCommand(event.data);
+        } else if (isEngineSyncMessage(event.data)) {
+          this.bridge?.receiveSync(event.data);
+          this.rtBridge?.receiveSync(event.data);
         }
       };
       if (port?.addEventListener) {
@@ -2011,13 +2642,14 @@ function registerSonareRealtimeEngineWorkletProcessor(name = "sonare-realtime-en
         if (!options.rtModuleUrl) {
           throw new Error("rtModuleUrl is required for sonare-rt AudioWorklet runtime.");
         }
+        const rtModuleUrl = options.rtModuleUrl;
         const memory = new WebAssembly.Memory({ initial: 1024, maximum: 1024, shared: true });
         const globalFactory = globalThis.SonareRtModuleFactory;
-        const moduleFactory = globalFactory ? { default: globalFactory } : await import(options.rtModuleUrl);
+        const moduleFactory = globalFactory ? { default: globalFactory } : await import(rtModuleUrl);
         const module2 = await moduleFactory.default({
           wasmMemory: memory,
           wasmBinary: options.rtWasmBinary,
-          locateFile: (path) => options.rtModuleUrl.replace(/[^/]*$/, path)
+          locateFile: (path) => rtModuleUrl.replace(/[^/]*$/, path)
         });
         this.rtBridge = new SonareRtRealtimeEngineRuntime({
           module: module2,
@@ -2054,12 +2686,16 @@ export {
   SonareEngineTelemetryType,
   SonareRealtimeEngineNode,
   SonareRealtimeEngineWorkletProcessor,
+  SonareRealtimeVoiceChangerWorkletProcessor,
   SonareRtRealtimeEngineRuntime,
   SonareWorkletProcessor,
   createSonareEngineCommandRingBuffer,
   createSonareEngineTelemetryRingBuffer,
   createSonareMeterRingBuffer,
   createSonareSpectrumRingBuffer,
+  decodeFrame,
+  encodeFrameHi,
+  encodeFrameLo,
   init,
   isInitialized,
   popSonareEngineCommandRingBuffer,
@@ -2068,6 +2704,7 @@ export {
   readSonareMeterRingBuffer,
   readSonareSpectrumRingBuffer,
   registerSonareRealtimeEngineWorkletProcessor,
+  registerSonareRealtimeVoiceChangerWorkletProcessor,
   registerSonareWorkletProcessor,
   sonareEngineCommandRingBufferByteLength,
   sonareEngineTelemetryRingBufferByteLength,