@libraz/libsonare 1.3.3 → 1.4.1

package/src/worklet.ts

@@ -1,14 +1,14 @@
+import { panLawCode, panModeCode } from './codes';
 import type {
   EngineAutomationPoint,
   EngineBus,
   EngineCaptureStatus,
   EngineClip,
   EngineMarker,
-  EngineMeterTelemetry,
   EngineMetronomeConfig,
   EngineMidiClipSchedule,
   EngineParameterInfo,
-  EngineTelemetry,
+  EngineScopeTelemetry,
   EngineTempoSegment,
   EngineTimeSignatureSegment,
   EngineTrackLane,
@@ -16,7 +16,8 @@ import type {
   EngineTransportState,
   EqBand,
   MixerRealtimeBuffer,
-  RealtimeVoiceChangerConfigInput,
+  PanLaw,
+  PanMode,
 } from './index';
 import {
   engineCapabilities,
@@ -26,7 +27,6 @@ import {
   RealtimeEngine,
   RealtimeVoiceChanger,
 } from './index';
-import type { AutomationCurve } from './public_types';
 import type { SonareModule } from './sonare.js';
 import type { SonareRtModule } from './sonare-rt';
 
@@ -37,104 +37,182 @@ import type { SonareRtModule } from './sonare-rt';
 // `index` module.
 export { init, isInitialized } from './index';
 
-export interface SonareWorkletProcessorOptions {
-  sceneJson: string;
-  sampleRate?: number;
-  blockSize?: number;
-  stripCount?: number;
-  meterIntervalFrames?: number;
-  meterSharedBuffer?: SharedArrayBuffer;
-  meterRingCapacity?: number;
-  spectrumIntervalFrames?: number;
-  spectrumBands?: number;
-  spectrumSharedBuffer?: SharedArrayBuffer;
-  spectrumRingCapacity?: number;
-}
-
-export interface SonareRealtimeEngineWorkletProcessorOptions {
-  runtimeTarget?: 'embind' | 'sonare-rt';
-  rtModuleUrl?: string;
-  rtWasmBinary?: ArrayBuffer | Uint8Array;
-  wasmBinary?: ArrayBuffer | Uint8Array;
-  initialSyncMessages?: SonareEngineSyncMessage[];
-  initialCommands?: SonareEngineCommandRecord[];
-  sampleRate?: number;
-  blockSize?: number;
-  channelCount?: number;
-  meterIntervalFrames?: number;
-  commandSharedBuffer?: SharedArrayBuffer;
-  commandRingCapacity?: number;
-  telemetrySharedBuffer?: SharedArrayBuffer;
-  telemetryRingCapacity?: number;
-  meterSharedBuffer?: SharedArrayBuffer;
-  meterRingCapacity?: number;
-}
-
-export interface SonareRealtimeVoiceChangerWorkletProcessorOptions {
-  preset?: RealtimeVoiceChangerConfigInput;
-  sampleRate?: number;
-  blockSize?: number;
-  channelCount?: number;
-}
-
-export interface SonareRealtimeVoiceChangerSetConfigMessage {
-  type: 'setConfig';
-  preset: RealtimeVoiceChangerConfigInput;
-}
-
-export interface SonareRealtimeVoiceChangerResetMessage {
-  type: 'reset';
-}
-
-export interface SonareRealtimeVoiceChangerDestroyMessage {
-  type: 'destroy';
-}
-
-export type SonareRealtimeVoiceChangerMessage =
-  | SonareRealtimeVoiceChangerSetConfigMessage
-  | SonareRealtimeVoiceChangerResetMessage
-  | SonareRealtimeVoiceChangerDestroyMessage;
-
-export interface SonareRealtimeEngineNodeCapabilities {
-  mode: 'sab' | 'postMessage';
-  runtimeTarget: 'embind' | 'sonare-rt';
-  sharedArrayBuffer: boolean;
-  atomics: boolean;
-  audioWorklet: boolean;
-  engineAbiVersion?: number;
-  expectedEngineAbiVersion?: number;
-  abiCompatible?: boolean;
-  degradedReason?: string;
-  readyMessage?: boolean;
-}
-
-export interface SonareRealtimeEngineNodeOptions
-  extends SonareRealtimeEngineWorkletProcessorOptions {
-  processorName?: string;
-  moduleUrl?: string | URL;
-  rtModuleUrl?: string;
-  mode?: 'auto' | 'sab' | 'postMessage';
-  engineAbiVersion?: number;
-  expectedEngineAbiVersion?: number;
-  requireAbiCompatible?: boolean;
-  nodeFactory?: (
-    context: BaseAudioContext,
-    processorName: string,
-    options: AudioWorkletNodeOptions,
-  ) => AudioWorkletNode;
-}
-
-export interface SonareRtRealtimeEngineRuntimeOptions {
-  module: SonareRtModule;
-  memory: WebAssembly.Memory;
-  sampleRate?: number;
-  blockSize?: number;
-  channelCount?: number;
-  commandSharedBuffer?: SharedArrayBuffer;
-  commandRingCapacity?: number;
-  telemetrySharedBuffer?: SharedArrayBuffer;
-  telemetryRingCapacity?: number;
-}
+import type { WorkletInput, WorkletOutput } from './worklet/audio_types';
+import {
+  isEngineCaptureRequestMessage,
+  isEngineCaptureResponseMessage,
+  isEngineCommandRecord,
+  isEngineSyncMessage,
+  isEngineTelemetryRecord,
+  isEngineTransportRequestMessage,
+  isEngineTransportResponseMessage,
+  isMeterSnapshot,
+  isRealtimeVoiceChangerMessage,
+  isWorkletMessage,
+} from './worklet/guards';
+import {
+  DEFAULT_METRONOME_CONFIG,
+  type ResolvedMetronomeConfig,
+  resolveMetronomeConfig,
+  type SonareEngineCaptureRequestMessage,
+  type SonareEngineCaptureResponseMessage,
+  type SonareEngineInstrumentSyncMessage,
+  type SonareEngineSyncCaptureMessage,
+  type SonareEngineSyncMessage,
+  type SonareEngineTransportFacade,
+  type SonareEngineTransportRequestMessage,
+  type SonareEngineTransportResponseMessage,
+  type SonareRealtimeEngineNodeCapabilities,
+  type SonareRealtimeEngineNodeOptions,
+  type SonareRealtimeEngineWorkletProcessorOptions,
+  type SonareRealtimeVoiceChangerMessage,
+  type SonareRealtimeVoiceChangerWorkletProcessorOptions,
+  type SonareRtRealtimeEngineRuntimeOptions,
+  type SonareWorkletMessage,
+  type SonareWorkletProcessorOptions,
+  type WorkletPort,
+  type WorkletTransport,
+} from './worklet/messages';
+// --- internal modules (split out of this file; bundled back into a single
+// dist/worklet.js by tsup, so the public surface is unchanged) ---
+import {
+  createSonareEngineCommandRingBuffer,
+  createSonareEngineTelemetryRingBuffer,
+  createSonareMeterRingBuffer,
+  createSonareScopeRingBuffer,
+  ENGINE_MIXER_PARAM_FADER_DB,
+  ENGINE_MIXER_PARAM_PAN,
+  encodeFrameHi,
+  encodeFrameLo,
+  engineMixerBusTarget,
+  engineMixerLaneTarget,
+  engineMixerMasterTarget,
+  engineRingFromSharedBuffer,
+  isRecord,
+  magnitudeToDb,
+  meterFromEngine,
+  meterRingFromSharedBuffer,
+  popSonareEngineCommandRingBuffer,
+  pushSonareEngineCommandRingBuffer,
+  readSonareEngineTelemetryRingBuffer,
+  readSonareMeterRingBuffer,
+  readSonareScopeRingBuffer,
+  type SharedMeterRingWriter,
+  type SharedScopeRingWriter,
+  type SharedSpectrumRingWriter,
+  SONARE_ENGINE_COMMAND_RECORD_BYTES,
+  SONARE_ENGINE_TELEMETRY_RECORD_BYTES,
+  SONARE_METER_RING_RECORD_FLOATS,
+  SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS,
+  type SonareEngineCommandRecord,
+  type SonareEngineCommandRingBuffer,
+  SonareEngineCommandType,
+  SonareEngineTelemetryError,
+  type SonareEngineTelemetryRecord,
+  type SonareEngineTelemetryRingBuffer,
+  SonareEngineTelemetryType,
+  type SonareMeterRingBuffer,
+  type SonareScopeRingBuffer,
+  type SonareWorkletMeterSnapshot,
+  type SonareWorkletScopeSnapshot,
+  type SonareWorkletSpectrumSnapshot,
+  scopeRingFromSharedBuffer,
+  spectrumRingFromSharedBuffer,
+  telemetryFromEngine,
+  toBigInt64,
+  toDb,
+  writeSonareEngineTelemetryRingBuffer,
+} from './worklet/protocol';
+
+export type {
+  SonareEngineCaptureRequestMessage,
+  SonareEngineCaptureResponseMessage,
+  SonareEngineSyncAutomationMessage,
+  SonareEngineSyncBuiltinInstrumentMessage,
+  SonareEngineSyncCaptureMessage,
+  SonareEngineSyncClipsDeltaMessage,
+  SonareEngineSyncClipsMessage,
+  SonareEngineSyncLoadSoundFontMessage,
+  SonareEngineSyncMarkersMessage,
+  SonareEngineSyncMasterStripEqBandMessage,
+  SonareEngineSyncMasterStripInsertBypassedMessage,
+  SonareEngineSyncMessage,
+  SonareEngineSyncMetronomeMessage,
+  SonareEngineSyncMidiCcMessage,
+  SonareEngineSyncMidiClipsMessage,
+  SonareEngineSyncMidiNoteMessage,
+  SonareEngineSyncMidiPanicMessage,
+  SonareEngineSyncMixerMessage,
+  SonareEngineSyncSf2InstrumentMessage,
+  SonareEngineSyncSynthInstrumentMessage,
+  SonareEngineSyncTempoMessage,
+  SonareEngineSyncTrackStripEqBandMessage,
+  SonareEngineSyncTrackStripInsertBypassedMessage,
+  SonareEngineTransportFacade,
+  SonareEngineTransportRequestMessage,
+  SonareEngineTransportResponseMessage,
+  SonareRealtimeEngineNodeCapabilities,
+  SonareRealtimeEngineNodeOptions,
+  SonareRealtimeEngineWorkletProcessorOptions,
+  SonareRealtimeVoiceChangerDestroyMessage,
+  SonareRealtimeVoiceChangerMessage,
+  SonareRealtimeVoiceChangerResetMessage,
+  SonareRealtimeVoiceChangerSetConfigMessage,
+  SonareRealtimeVoiceChangerWorkletProcessorOptions,
+  SonareRtRealtimeEngineRuntimeOptions,
+  SonareWorkletDestroyMessage,
+  SonareWorkletMessage,
+  SonareWorkletProcessorOptions,
+  SonareWorkletScheduleInsertAutomationMessage,
+  SonareWorkletSetMeterIntervalMessage,
+  SonareWorkletTransportMessage,
+} from './worklet/messages';
+export {
+  createSonareEngineCommandRingBuffer,
+  createSonareEngineTelemetryRingBuffer,
+  createSonareMeterRingBuffer,
+  createSonareScopeRingBuffer,
+  createSonareSpectrumRingBuffer,
+  decodeFrame,
+  encodeFrameHi,
+  encodeFrameLo,
+  popSonareEngineCommandRingBuffer,
+  pushSonareEngineCommandRingBuffer,
+  readSonareEngineTelemetryRingBuffer,
+  readSonareMeterRingBuffer,
+  readSonareScopeRingBuffer,
+  readSonareSpectrumRingBuffer,
+  SONARE_ENGINE_COMMAND_RECORD_BYTES,
+  SONARE_ENGINE_RING_HEADER_INTS,
+  SONARE_ENGINE_TELEMETRY_RECORD_BYTES,
+  SONARE_METER_RING_HEADER_INTS,
+  SONARE_METER_RING_RECORD_FLOATS,
+  SONARE_SCOPE_RING_HEADER_INTS,
+  SONARE_SPECTRUM_RING_HEADER_INTS,
+  type SonareEngineCommandRecord,
+  type SonareEngineCommandRingBuffer,
+  SonareEngineCommandType,
+  SonareEngineTelemetryError,
+  type SonareEngineTelemetryRecord,
+  type SonareEngineTelemetryRingBuffer,
+  type SonareEngineTelemetryRingReadResult,
+  SonareEngineTelemetryType,
+  type SonareMeterRingBuffer,
+  type SonareMeterRingReadResult,
+  type SonareScopeRingBuffer,
+  type SonareScopeRingReadResult,
+  type SonareSpectrumRingBuffer,
+  type SonareSpectrumRingReadResult,
+  type SonareWorkletMeterSnapshot,
+  type SonareWorkletScopeSnapshot,
+  type SonareWorkletSpectrumSnapshot,
+  sonareEngineCommandRingBufferByteLength,
+  sonareEngineTelemetryRingBufferByteLength,
+  sonareMeterRingBufferByteLength,
+  sonareScopeRingBufferByteLength,
+  sonareSpectrumRingBufferByteLength,
+  writeSonareEngineTelemetryRingBuffer,
+} from './worklet/protocol';
 
 export interface SonareEngineOptions extends SonareRealtimeEngineNodeOptions {
   offlineEngine?: RealtimeEngine;
@@ -142,1010 +220,11 @@ export interface SonareEngineOptions extends SonareRealtimeEngineNodeOptions {
   offlineChannelCount?: number;
 }
 
-export interface SonareEngineTransportFacade {
-  play(sampleTime?: number): boolean;
-  stop(sampleTime?: number): boolean;
-  seekPpq(ppq: number, sampleTime?: number): boolean;
-  seekSeconds(seconds: number, sampleTime?: number): boolean;
-  setTempo(bpm: number): void;
-  setTempoSegments(segments: readonly EngineTempoSegment[]): void;
-  setLoop(startPpq: number, endPpq: number, enabled?: boolean): boolean;
-}
-
 type SuspendableAudioContext = BaseAudioContext & {
   suspend?: () => Promise<void>;
   resume?: () => Promise<void>;
 };
 
-const ENGINE_MIXER_TARGET_BASE = 0x4d580000;
-const ENGINE_MIXER_PARAM_FADER_DB = 1;
-const ENGINE_MIXER_PARAM_PAN = 2;
-
-function engineMixerLaneTarget(laneIndex: number, paramKind: number): number {
-  return ENGINE_MIXER_TARGET_BASE | ((laneIndex & 0xff) << 8) | (paramKind & 0xff);
-}
-
-function engineMixerBusTarget(busIndex: number, paramKind: number): number {
-  return ENGINE_MIXER_TARGET_BASE | (((0xfe - busIndex) & 0xff) << 8) | (paramKind & 0xff);
-}
-
-function engineMixerMasterTarget(paramKind: number): number {
-  return ENGINE_MIXER_TARGET_BASE | (0xff << 8) | (paramKind & 0xff);
-}
-
-type WorkletInput = readonly (readonly Float32Array[])[];
-type WorkletOutput = Float32Array[][];
-
-export interface SonareWorkletScheduleInsertAutomationMessage {
-  type: 'scheduleInsertAutomation';
-  stripIndex: number;
-  insertIndex: number;
-  paramId: number;
-  value: number;
-  samplePos?: number;
-  curve?: AutomationCurve;
-}
-
-export interface SonareWorkletSetMeterIntervalMessage {
-  type: 'setMeterInterval';
-  frames: number;
-}
-
-export interface SonareWorkletDestroyMessage {
-  type: 'destroy';
-}
-
-export type SonareWorkletMessage =
-  | SonareWorkletScheduleInsertAutomationMessage
-  | SonareWorkletSetMeterIntervalMessage
-  | SonareWorkletDestroyMessage;
-
-export interface SonareWorkletMeterSnapshot {
-  type: 'meter';
-  targetId: number;
-  frame: number;
-  peakDbL: number;
-  peakDbR: number;
-  rmsDbL: number;
-  rmsDbR: number;
-  correlation: number;
-  truePeakDbL: number;
-  truePeakDbR: number;
-  momentaryLufs: number;
-  shortTermLufs: number;
-  integratedLufs: number;
-  gainReductionDb: number;
-}
-
-export interface SonareWorkletSpectrumSnapshot {
-  type: 'spectrum';
-  frame: number;
-  bands: Float32Array;
-}
-
-export type SonareWorkletTransportMessage =
-  | SonareWorkletMeterSnapshot
-  | SonareWorkletSpectrumSnapshot
-  | SonareEngineTelemetryRecord;
-
-export const SONARE_METER_RING_HEADER_INTS = 4;
-// Record layout: [frameLo, frameHi, targetId, peakDbL, peakDbR, rmsDbL, rmsDbR,
-// correlation, truePeakDbL, truePeakDbR, momentaryLufs, shortTermLufs,
-// integratedLufs, gainReductionDb].
-// The sample-frame index is monotonically increasing and quickly exceeds the
-// 2^24 exact-integer range of a single Float32 slot (~349 s at 48 kHz), so it is
-// stored split across two Float32 lanes (low 24 bits + high bits) for exact
-// reconstruction. See encodeFrameLo/encodeFrameHi/decodeFrame.
-export const SONARE_METER_RING_RECORD_FLOATS = 14;
-export const SONARE_SPECTRUM_RING_HEADER_INTS = 5;
-
-/** Base for splitting a frame index into two exactly-representable Float32 lanes. */
-const SONARE_FRAME_LANE_BASE = 0x1000000; // 2^24
-
-/** Low 24 bits of a frame index (exact in Float32). */
-export function encodeFrameLo(frame: number): number {
-  const f = Math.max(0, Math.floor(frame));
-  return f % SONARE_FRAME_LANE_BASE;
-}
-
-/** High bits of a frame index above 2^24 (exact in Float32 up to ~2^48). */
-export function encodeFrameHi(frame: number): number {
-  const f = Math.max(0, Math.floor(frame));
-  return Math.floor(f / SONARE_FRAME_LANE_BASE);
-}
-
-/** Reconstruct a frame index from its low/high Float32 lanes. */
-export function decodeFrame(lo: number, hi: number): number {
-  return hi * SONARE_FRAME_LANE_BASE + lo;
-}
-export const SONARE_ENGINE_RING_HEADER_INTS = 5;
-export const SONARE_ENGINE_COMMAND_RECORD_BYTES = 32;
-export const SONARE_ENGINE_TELEMETRY_RECORD_BYTES = 48;
-
-export enum SonareEngineCommandType {
-  SetParam = 0,
-  SetParamSmoothed = 1,
-  TransportPlay = 2,
-  TransportStop = 3,
-  TransportSeekSample = 4,
-  TransportSeekPpq = 5,
-  SetTempoMap = 6,
-  SetLoop = 7,
-  SwapGraph = 8,
-  SwapAutomation = 9,
-  SetSoloMute = 10,
-  AddClip = 11,
-  RemoveClip = 12,
-  ArmRecord = 13,
-  Punch = 14,
-  SetMetronome = 15,
-  SetMarker = 16,
-  SeekMarker = 17,
-}
-
-export enum SonareEngineTelemetryType {
-  ProcessBlock = 0,
-  Error = 1,
-}
-
-export enum SonareEngineTelemetryError {
-  None = 0,
-  CommandQueueOverflow = 1,
-  PendingCommandOverflow = 2,
-  BoundaryOverflow = 3,
-  TelemetryOverflow = 4,
-  CaptureOverflow = 5,
-  MaxBlockExceeded = 6,
-  UnknownTarget = 7,
-  NonRealtimeSafeParameter = 8,
-  NotPrepared = 9,
-  NonQueueableCommand = 10,
-  AutomationBindTargetOverflow = 11,
-  StaleAutomationLanes = 12,
-  SmoothedParameterCapacity = 13,
-}
-
-interface WorkletTransport {
-  postMessage?: (
-    message:
-      | SonareWorkletTransportMessage
-      | SonareEngineCaptureResponseMessage
-      | SonareEngineTransportResponseMessage,
-    transfer?: Transferable[],
-  ) => void;
-  onMeter?: (meter: SonareWorkletMeterSnapshot) => void;
-  onSpectrum?: (spectrum: SonareWorkletSpectrumSnapshot) => void;
-}
-
-interface ResolvedMetronomeConfig {
-  beatGain: number;
-  accentGain: number;
-  clickSamples: number;
-}
-
-// Fallback metronome gains/click length used by the worklet consumer until the
-// host posts a 'syncMetronome' config. Aligned with the embind setMetronome
-// defaults (src/wasm/bindings.cpp) so offline and realtime metronomes match.
-const DEFAULT_METRONOME_CONFIG: ResolvedMetronomeConfig = {
-  beatGain: 0.35,
-  accentGain: 0.7,
-  clickSamples: 96,
-};
-
-function resolveMetronomeConfig(config: EngineMetronomeConfig): ResolvedMetronomeConfig {
-  return {
-    beatGain: config.beatGain ?? DEFAULT_METRONOME_CONFIG.beatGain,
-    accentGain: config.accentGain ?? DEFAULT_METRONOME_CONFIG.accentGain,
-    clickSamples: config.clickSamples ?? DEFAULT_METRONOME_CONFIG.clickSamples,
-  };
-}
-
-export interface SonareMeterRingBuffer {
-  sharedBuffer: SharedArrayBuffer;
-  header: Int32Array;
-  records: Float32Array;
-  capacity: number;
-}
-
-export interface SonareMeterRingReadResult {
-  nextReadIndex: number;
-  meters: SonareWorkletMeterSnapshot[];
-}
-
-export interface SonareSpectrumRingBuffer {
-  sharedBuffer: SharedArrayBuffer;
-  header: Int32Array;
-  records: Float32Array;
-  capacity: number;
-  bands: number;
-}
-
-export interface SonareSpectrumRingReadResult {
-  nextReadIndex: number;
-  spectra: SonareWorkletSpectrumSnapshot[];
-}
-
-export interface SonareEngineCommandRecord {
-  type: SonareEngineCommandType | number;
-  targetId?: number;
-  sampleTime?: number | bigint;
-  argFloat?: number;
-  argInt?: number | bigint;
-}
-
-// Out-of-band control messages posted from the main-thread SonareEngine facade
-// to the worklet engine processor over node.port. Unlike SonareEngineCommandRecord
-// (a small POD POSTed/ringed every block) these carry bulk/structured payloads
-// (clip audio buffers, marker lists, metronome config) that cannot fit the
-// fixed-size SAB command record, so they are applied OUTSIDE process() — the
-// audio-thread equivalent of the engine's control-thread RtPublisher setters.
-export interface SonareEngineSyncClipsMessage {
-  type: 'syncClips';
-  clips: EngineClip[];
-}
-
-export interface SonareEngineSyncClipsDeltaMessage {
-  type: 'syncClipsDelta';
-  upserts: EngineClip[];
-  removeIds: number[];
-}
-
-export interface SonareEngineSyncMidiClipsMessage {
-  type: 'syncMidiClips';
-  clips: EngineMidiClipSchedule[];
-}
-
-export interface SonareEngineSyncMarkersMessage {
-  type: 'syncMarkers';
-  markers: EngineMarker[];
-}
-
-export interface SonareEngineSyncMetronomeMessage {
-  type: 'syncMetronome';
-  config: EngineMetronomeConfig;
-}
-
-export interface SonareEngineSyncAutomationMessage {
-  type: 'syncAutomation';
-  paramId: number;
-  points: EngineAutomationPoint[];
-}
-
-export interface SonareEngineSyncTempoMessage {
-  type: 'syncTempo';
-  bpm: number;
-  timeSignature: { numerator: number; denominator: number };
-  tempoSegments?: EngineTempoSegment[];
-  timeSignatureSegments?: EngineTimeSignatureSegment[];
-}
-
-export interface SonareEngineSyncMixerMessage {
-  type: 'syncMixer';
-  lanes: EngineTrackLane[];
-  buses?: EngineBus[];
-  trackStrips?: Array<{ trackId: number; sceneJson: string }>;
-  busStrips?: Array<{ busId: number; sceneJson: string }>;
-  masterStripJson?: string;
-}
-
-export interface SonareEngineSyncCaptureMessage {
-  type: 'syncCapture';
-  bufferFrames: number;
-  channels: number;
-  source: EngineCaptureStatus['source'];
-  recordOffsetSamples: number;
-  inputMonitor: { enabled: boolean; gain: number };
-}
-
-export interface SonareEngineSyncTrackStripEqBandMessage {
-  type: 'syncTrackStripEqBand';
-  trackId: number;
-  bandIndex: number;
-  bandJson: string;
-}
-
-export interface SonareEngineSyncMasterStripEqBandMessage {
-  type: 'syncMasterStripEqBand';
-  bandIndex: number;
-  bandJson: string;
-}
-
-export interface SonareEngineSyncTrackStripInsertBypassedMessage {
-  type: 'syncTrackStripInsertBypassed';
-  trackId: number;
-  insertIndex: number;
-  bypassed: boolean;
-  resetOnBypass: boolean;
-}
-
-export interface SonareEngineSyncMasterStripInsertBypassedMessage {
-  type: 'syncMasterStripInsertBypassed';
-  insertIndex: number;
-  bypassed: boolean;
-  resetOnBypass: boolean;
-}
-
-export interface SonareEngineSyncBuiltinInstrumentMessage {
-  type: 'syncBuiltinInstrument';
-  destinationId: number;
-  config: { destinationId?: number } & Record<string, unknown>;
-}
-
-export interface SonareEngineSyncSynthInstrumentMessage {
-  type: 'syncSynthInstrument';
-  destinationId: number;
-  patch: Record<string, unknown> | string;
-}
-
-export interface SonareEngineSyncSf2InstrumentMessage {
-  type: 'syncSf2Instrument';
-  destinationId: number;
-  config: { destinationId?: number; gain?: number; polyphony?: number };
-}
-
-export interface SonareEngineSyncLoadSoundFontMessage {
-  type: 'syncLoadSoundFont';
-  data: Uint8Array;
-}
-
-export interface SonareEngineSyncMidiNoteMessage {
-  type: 'syncMidiNoteOn' | 'syncMidiNoteOff';
-  destinationId: number;
-  group: number;
-  channel: number;
-  note: number;
-  velocity: number;
-  renderFrame: number;
-}
-
-export interface SonareEngineSyncMidiCcMessage {
-  type: 'syncMidiCc';
-  destinationId: number;
-  group: number;
-  channel: number;
-  controller: number;
-  value: number;
-  renderFrame: number;
-}
-
-export interface SonareEngineSyncMidiPanicMessage {
-  type: 'syncMidiPanic';
-  renderFrame: number;
-}
-
-type SonareEngineInstrumentSyncMessage =
-  | SonareEngineSyncBuiltinInstrumentMessage
-  | SonareEngineSyncSynthInstrumentMessage
-  | SonareEngineSyncSf2InstrumentMessage
-  | SonareEngineSyncLoadSoundFontMessage;
-
-export type SonareEngineSyncMessage =
-  | SonareEngineSyncClipsMessage
-  | SonareEngineSyncClipsDeltaMessage
-  | SonareEngineSyncMidiClipsMessage
-  | SonareEngineSyncMarkersMessage
-  | SonareEngineSyncMetronomeMessage
-  | SonareEngineSyncAutomationMessage
-  | SonareEngineSyncTempoMessage
-  | SonareEngineSyncMixerMessage
-  | SonareEngineSyncCaptureMessage
-  | SonareEngineSyncTrackStripEqBandMessage
-  | SonareEngineSyncMasterStripEqBandMessage
-  | SonareEngineSyncTrackStripInsertBypassedMessage
-  | SonareEngineSyncMasterStripInsertBypassedMessage
-  | SonareEngineSyncBuiltinInstrumentMessage
-  | SonareEngineSyncSynthInstrumentMessage
-  | SonareEngineSyncSf2InstrumentMessage
-  | SonareEngineSyncLoadSoundFontMessage
-  | SonareEngineSyncMidiNoteMessage
-  | SonareEngineSyncMidiCcMessage
-  | SonareEngineSyncMidiPanicMessage;
-
-export interface SonareEngineTelemetryRecord {
-  type: SonareEngineTelemetryType | number;
-  error: SonareEngineTelemetryError | number;
-  renderFrame: number;
-  timelineSample: number;
-  audibleTimelineSample: number;
-  graphLatencySamplesQ8: number;
-  value: number;
-}
-
-export interface SonareEngineCommandRingBuffer {
-  sharedBuffer: SharedArrayBuffer;
-  header: Int32Array;
-  view: DataView;
-  capacity: number;
-}
-
-export interface SonareEngineTelemetryRingBuffer {
-  sharedBuffer: SharedArrayBuffer;
-  header: Int32Array;
-  view: DataView;
-  capacity: number;
-}
-
-export interface SonareEngineTelemetryRingReadResult {
-  nextReadIndex: number;
-  telemetry: SonareEngineTelemetryRecord[];
-}
-
-interface SharedMeterRingWriter {
-  header: Int32Array;
-  records: Float32Array;
-  capacity: number;
-}
-
-interface SharedSpectrumRingWriter {
-  header: Int32Array;
-  records: Float32Array;
-  capacity: number;
-  bands: number;
-  recordFloats: number;
-}
-
-interface WorkletPort {
-  postMessage?: (message: unknown, transfer?: Transferable[]) => void;
-  onmessage?: (event: { data: unknown }) => void;
-  addEventListener?: (type: 'message', listener: (event: { data: unknown }) => void) => void;
-  start?: () => void;
-}
-
-export interface SonareEngineCaptureRequestMessage {
-  type: 'captureRequest';
-  requestId: number;
-  op: 'status' | 'read' | 'reset';
-}
-
-export interface SonareEngineCaptureResponseMessage {
-  type: 'captureResponse';
-  requestId: number;
-  ok: boolean;
-  status?: EngineCaptureStatus;
-  channels?: Float32Array[] | number[][];
-  error?: string;
-}
-
-export interface SonareEngineTransportRequestMessage {
-  type: 'transportRequest';
-  requestId: number;
-  op: 'state';
-}
-
-export interface SonareEngineTransportResponseMessage {
-  type: 'transportResponse';
-  requestId: number;
-  ok: boolean;
-  state?: EngineTransportState;
-  error?: string;
-}
-
-function toDb(value: number): number {
-  return value > 0 ? 20 * Math.log10(value) : Number.NEGATIVE_INFINITY;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function isWorkletMessage(value: unknown): value is SonareWorkletMessage {
-  if (!isRecord(value) || typeof value.type !== 'string') {
-    return false;
-  }
-  return (
-    value.type === 'scheduleInsertAutomation' ||
-    value.type === 'setMeterInterval' ||
-    value.type === 'destroy'
-  );
-}
-
-function isEngineCommandRecord(value: unknown): value is SonareEngineCommandRecord {
-  return isRecord(value) && typeof value.type === 'number';
-}
-
-function isEngineSyncMessage(value: unknown): value is SonareEngineSyncMessage {
-  if (!isRecord(value) || typeof value.type !== 'string') {
-    return false;
-  }
-  return (
-    value.type === 'syncClips' ||
-    value.type === 'syncClipsDelta' ||
-    value.type === 'syncMidiClips' ||
-    value.type === 'syncMarkers' ||
-    value.type === 'syncMetronome' ||
-    value.type === 'syncAutomation' ||
-    value.type === 'syncTempo' ||
-    value.type === 'syncMixer' ||
-    value.type === 'syncCapture' ||
-    value.type === 'syncTrackStripEqBand' ||
-    value.type === 'syncMasterStripEqBand' ||
-    value.type === 'syncTrackStripInsertBypassed' ||
-    value.type === 'syncMasterStripInsertBypassed' ||
-    value.type === 'syncBuiltinInstrument' ||
-    value.type === 'syncSynthInstrument' ||
-    value.type === 'syncSf2Instrument' ||
-    value.type === 'syncLoadSoundFont' ||
-    value.type === 'syncMidiNoteOn' ||
-    value.type === 'syncMidiNoteOff' ||
-    value.type === 'syncMidiCc' ||
-    value.type === 'syncMidiPanic'
-  );
-}
-
-function isEngineCaptureRequestMessage(value: unknown): value is SonareEngineCaptureRequestMessage {
-  return (
-    isRecord(value) &&
-    value.type === 'captureRequest' &&
-    typeof value.requestId === 'number' &&
-    (value.op === 'status' || value.op === 'read' || value.op === 'reset')
-  );
-}
-
-function isEngineCaptureResponseMessage(
-  value: unknown,
-): value is SonareEngineCaptureResponseMessage {
-  return (
-    isRecord(value) &&
-    value.type === 'captureResponse' &&
-    typeof value.requestId === 'number' &&
-    typeof value.ok === 'boolean'
-  );
-}
-
-function isEngineTransportRequestMessage(
-  value: unknown,
-): value is SonareEngineTransportRequestMessage {
-  return (
-    isRecord(value) &&
-    value.type === 'transportRequest' &&
-    typeof value.requestId === 'number' &&
-    value.op === 'state'
-  );
-}
-
-function isEngineTransportResponseMessage(
-  value: unknown,
-): value is SonareEngineTransportResponseMessage {
-  return (
-    isRecord(value) &&
-    value.type === 'transportResponse' &&
-    typeof value.requestId === 'number' &&
-    typeof value.ok === 'boolean'
-  );
-}
-
-function isRealtimeVoiceChangerMessage(value: unknown): value is SonareRealtimeVoiceChangerMessage {
-  if (!isRecord(value) || typeof value.type !== 'string') {
-    return false;
-  }
-  return value.type === 'setConfig' || value.type === 'reset' || value.type === 'destroy';
-}
-
-function isEngineTelemetryRecord(value: unknown): value is SonareEngineTelemetryRecord {
-  return (
-    isRecord(value) &&
-    typeof value.type === 'number' &&
-    typeof value.error === 'number' &&
-    typeof value.renderFrame === 'number' &&
-    typeof value.timelineSample === 'number' &&
-    typeof value.audibleTimelineSample === 'number' &&
-    typeof value.graphLatencySamplesQ8 === 'number' &&
-    typeof value.value === 'number'
-  );
-}
-
-function isMeterSnapshot(value: unknown): value is SonareWorkletMeterSnapshot {
-  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 === undefined)
-  );
-}
-
-export function sonareMeterRingBufferByteLength(capacity: number): number {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  return (
-    SONARE_METER_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
-    clampedCapacity * SONARE_METER_RING_RECORD_FLOATS * Float32Array.BYTES_PER_ELEMENT
-  );
-}
-
-export function createSonareMeterRingBuffer(capacity = 128): SonareMeterRingBuffer {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const sharedBuffer = new SharedArrayBuffer(sonareMeterRingBufferByteLength(clampedCapacity));
-  const ring = meterRingFromSharedBuffer(sharedBuffer, clampedCapacity);
-  Atomics.store(ring.header, 0, 0);
-  Atomics.store(ring.header, 1, clampedCapacity);
-  Atomics.store(ring.header, 2, SONARE_METER_RING_RECORD_FLOATS);
-  Atomics.store(ring.header, 3, 0);
-  return { sharedBuffer, header: ring.header, records: ring.records, capacity: ring.capacity };
-}
-
-export function readSonareMeterRingBuffer(
-  ring: SonareMeterRingBuffer,
-  readIndex = 0,
-): SonareMeterRingReadResult {
-  const writeIndex = Atomics.load(ring.header, 0);
-  const recordFloats = Atomics.load(ring.header, 2) || SONARE_METER_RING_RECORD_FLOATS;
-  const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
-  const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
-  const meters: SonareWorkletMeterSnapshot[] = [];
-  for (let index = firstReadable; index < writeIndex; index++) {
-    const offset = (index % ring.capacity) * recordFloats;
-    meters.push({
-      type: 'meter',
-      frame: decodeFrame(ring.records[offset], ring.records[offset + 1]),
-      targetId: ring.records[offset + 2],
-      peakDbL: ring.records[offset + 3],
-      peakDbR: ring.records[offset + 4],
-      rmsDbL: ring.records[offset + 5],
-      rmsDbR: ring.records[offset + 6],
-      correlation: ring.records[offset + 7],
-      truePeakDbL: ring.records[offset + 8],
-      truePeakDbR: ring.records[offset + 9],
-      momentaryLufs: ring.records[offset + 10],
-      shortTermLufs: ring.records[offset + 11],
-      integratedLufs: ring.records[offset + 12],
-      gainReductionDb: ring.records[offset + 13],
-    });
-  }
-  return { nextReadIndex: writeIndex, meters };
-}
-
-export function sonareSpectrumRingBufferByteLength(capacity: number, bands = 16): number {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const clampedBands = Math.max(1, Math.floor(bands));
-  // Record layout: [frameLo, frameHi, bandCount, band0, band1, ...]. frame is
-  // split across two Float32 lanes for exact reconstruction beyond 2^24.
-  return (
-    SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
-    clampedCapacity * (3 + clampedBands) * Float32Array.BYTES_PER_ELEMENT
-  );
-}
-
-export function createSonareSpectrumRingBuffer(
-  capacity = 128,
-  bands = 16,
-): SonareSpectrumRingBuffer {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const clampedBands = Math.max(1, Math.floor(bands));
-  const sharedBuffer = new SharedArrayBuffer(
-    sonareSpectrumRingBufferByteLength(clampedCapacity, clampedBands),
-  );
-  const ring = spectrumRingFromSharedBuffer(sharedBuffer, clampedCapacity, clampedBands);
-  Atomics.store(ring.header, 0, 0);
-  Atomics.store(ring.header, 1, clampedCapacity);
-  Atomics.store(ring.header, 2, ring.recordFloats);
-  Atomics.store(ring.header, 3, clampedBands);
-  Atomics.store(ring.header, 4, 0);
-  return {
-    sharedBuffer,
-    header: ring.header,
-    records: ring.records,
-    capacity: ring.capacity,
-    bands: ring.bands,
-  };
-}
-
-export function readSonareSpectrumRingBuffer(
-  ring: SonareSpectrumRingBuffer,
-  readIndex = 0,
-): SonareSpectrumRingReadResult {
-  const writeIndex = Atomics.load(ring.header, 0);
-  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);
-  const spectra: SonareWorkletSpectrumSnapshot[] = [];
-  for (let index = firstReadable; index < writeIndex; index++) {
-    const offset = (index % ring.capacity) * recordFloats;
-    const values = new Float32Array(bands);
-    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 };
-}
-
-export function sonareEngineCommandRingBufferByteLength(capacity: number): number {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  return (
-    SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
-    clampedCapacity * SONARE_ENGINE_COMMAND_RECORD_BYTES
-  );
-}
-
-export function sonareEngineTelemetryRingBufferByteLength(capacity: number): number {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  return (
-    SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT +
-    clampedCapacity * SONARE_ENGINE_TELEMETRY_RECORD_BYTES
-  );
-}
-
-export function createSonareEngineCommandRingBuffer(capacity = 128): SonareEngineCommandRingBuffer {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const sharedBuffer = new SharedArrayBuffer(
-    sonareEngineCommandRingBufferByteLength(clampedCapacity),
-  );
-  const ring = engineRingFromSharedBuffer(
-    sharedBuffer,
-    SONARE_ENGINE_COMMAND_RECORD_BYTES,
-    clampedCapacity,
-  );
-  return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
-}
-
-export function createSonareEngineTelemetryRingBuffer(
-  capacity = 128,
-): SonareEngineTelemetryRingBuffer {
-  const clampedCapacity = Math.max(1, Math.floor(capacity));
-  const sharedBuffer = new SharedArrayBuffer(
-    sonareEngineTelemetryRingBufferByteLength(clampedCapacity),
-  );
-  const ring = engineRingFromSharedBuffer(
-    sharedBuffer,
-    SONARE_ENGINE_TELEMETRY_RECORD_BYTES,
-    clampedCapacity,
-  );
-  return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
-}
-
-export function pushSonareEngineCommandRingBuffer(
-  ring: SonareEngineCommandRingBuffer,
-  command: SonareEngineCommandRecord,
-): boolean {
-  const writeIndex = Atomics.load(ring.header, 0);
-  const readIndex = Atomics.load(ring.header, 1);
-  if (writeIndex - readIndex >= ring.capacity) {
-    Atomics.add(ring.header, 4, 1);
-    return false;
-  }
-  writeEngineCommandRecord(
-    ring.view,
-    recordOffset(writeIndex, ring.capacity, SONARE_ENGINE_COMMAND_RECORD_BYTES),
-    command,
-  );
-  Atomics.store(ring.header, 0, writeIndex + 1);
-  return true;
-}
-
-export function popSonareEngineCommandRingBuffer(
-  ring: SonareEngineCommandRingBuffer,
-): SonareEngineCommandRecord | null {
-  const readIndex = Atomics.load(ring.header, 1);
-  const writeIndex = Atomics.load(ring.header, 0);
-  if (readIndex >= writeIndex) {
-    return null;
-  }
-  const command = readEngineCommandRecord(
-    ring.view,
-    recordOffset(readIndex, ring.capacity, SONARE_ENGINE_COMMAND_RECORD_BYTES),
-  );
-  Atomics.store(ring.header, 1, readIndex + 1);
-  return command;
-}
-
-export function writeSonareEngineTelemetryRingBuffer(
-  ring: SonareEngineTelemetryRingBuffer,
-  telemetry: SonareEngineTelemetryRecord,
-): void {
-  const writeIndex = Atomics.load(ring.header, 0);
-  writeEngineTelemetryRecord(
-    ring.view,
-    recordOffset(writeIndex, ring.capacity, SONARE_ENGINE_TELEMETRY_RECORD_BYTES),
-    telemetry,
-  );
-  Atomics.store(ring.header, 0, writeIndex + 1);
-  if (writeIndex + 1 > ring.capacity) {
-    Atomics.store(ring.header, 4, writeIndex + 1 - ring.capacity);
-  }
-}
-
-export function readSonareEngineTelemetryRingBuffer(
-  ring: SonareEngineTelemetryRingBuffer,
-  readIndex = 0,
-): SonareEngineTelemetryRingReadResult {
-  const writeIndex = Atomics.load(ring.header, 0);
-  const nextReadIndex = Math.max(0, Math.min(readIndex, writeIndex));
-  const firstReadable = Math.max(nextReadIndex, writeIndex - ring.capacity);
-  const telemetry: SonareEngineTelemetryRecord[] = [];
-  for (let index = firstReadable; index < writeIndex; index++) {
-    telemetry.push(
-      readEngineTelemetryRecord(
-        ring.view,
-        recordOffset(index, ring.capacity, SONARE_ENGINE_TELEMETRY_RECORD_BYTES),
-      ),
-    );
-  }
-  return { nextReadIndex: writeIndex, telemetry };
-}
-
-function meterRingFromSharedBuffer(
-  sharedBuffer: SharedArrayBuffer,
-  fallbackCapacity?: number,
-): SharedMeterRingWriter {
-  const headerBytes = SONARE_METER_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
-  const header = new Int32Array(sharedBuffer, 0, SONARE_METER_RING_HEADER_INTS);
-  const existingCapacity = Atomics.load(header, 1);
-  const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
-  const minBytes = sonareMeterRingBufferByteLength(capacity);
-  if (sharedBuffer.byteLength < minBytes) {
-    throw new Error('meterSharedBuffer is too small for the requested ring capacity.');
-  }
-  Atomics.store(header, 1, capacity);
-  Atomics.store(header, 2, SONARE_METER_RING_RECORD_FLOATS);
-  return {
-    header,
-    records: new Float32Array(
-      sharedBuffer,
-      headerBytes,
-      capacity * SONARE_METER_RING_RECORD_FLOATS,
-    ),
-    capacity,
-  };
-}
-
-function spectrumRingFromSharedBuffer(
-  sharedBuffer: SharedArrayBuffer,
-  fallbackCapacity?: number,
-  fallbackBands?: number,
-): SharedSpectrumRingWriter {
-  const headerBytes = SONARE_SPECTRUM_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
-  const header = new Int32Array(sharedBuffer, 0, SONARE_SPECTRUM_RING_HEADER_INTS);
-  const existingCapacity = Atomics.load(header, 1);
-  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 = 3 + bands;
-  const minBytes = sonareSpectrumRingBufferByteLength(capacity, bands);
-  if (sharedBuffer.byteLength < minBytes) {
-    throw new Error('spectrumSharedBuffer is too small for the requested ring capacity.');
-  }
-  Atomics.store(header, 1, capacity);
-  Atomics.store(header, 2, recordFloats);
-  Atomics.store(header, 3, bands);
-  return {
-    header,
-    records: new Float32Array(sharedBuffer, headerBytes, capacity * recordFloats),
-    capacity,
-    bands,
-    recordFloats,
-  };
-}
-
-function engineRingFromSharedBuffer(
-  sharedBuffer: SharedArrayBuffer,
-  recordBytes: number,
-  fallbackCapacity?: number,
-): { header: Int32Array; view: DataView; capacity: number } {
-  const headerBytes = SONARE_ENGINE_RING_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT;
-  const header = new Int32Array(sharedBuffer, 0, SONARE_ENGINE_RING_HEADER_INTS);
-  const existingCapacity = Atomics.load(header, 2);
-  const capacity = Math.max(1, Math.floor(existingCapacity || fallbackCapacity || 1));
-  const minBytes = headerBytes + capacity * recordBytes;
-  if (sharedBuffer.byteLength < minBytes) {
-    throw new Error('engine SharedArrayBuffer is too small for the requested ring capacity.');
-  }
-  Atomics.store(header, 2, capacity);
-  Atomics.store(header, 3, recordBytes);
-  return {
-    header,
-    view: new DataView(sharedBuffer, headerBytes, capacity * recordBytes),
-    capacity,
-  };
-}
-
-function recordOffset(index: number, capacity: number, recordBytes: number): number {
-  return (index % capacity) * recordBytes;
-}
-
-function toBigInt64(value: number | bigint | undefined, fallback: bigint): bigint {
-  if (typeof value === 'bigint') {
-    return value;
-  }
-  if (typeof value === 'number') {
-    return BigInt(Math.trunc(value));
-  }
-  return fallback;
-}
-
-function writeEngineCommandRecord(
-  view: DataView,
-  offset: number,
-  command: SonareEngineCommandRecord,
-): void {
-  view.setUint32(offset, command.type, true);
-  view.setUint32(offset + 4, command.targetId ?? 0, true);
-  view.setBigInt64(offset + 8, toBigInt64(command.sampleTime, -1n), true);
-  // argFloat occupies a full 8-byte Float64 slot (replacing the old Float32 +
-  // 4-byte pad) so PPQ scalars carried here keep full double precision over the
-  // SAB transport, matching the engine's double-precision seek/loop contract.
-  view.setFloat64(offset + 16, command.argFloat ?? 0, true);
-  view.setBigInt64(offset + 24, toBigInt64(command.argInt, 0n), true);
-}
-
-function readEngineCommandRecord(view: DataView, offset: number): SonareEngineCommandRecord {
-  return {
-    type: view.getUint32(offset, true),
-    targetId: view.getUint32(offset + 4, true),
-    sampleTime: Number(view.getBigInt64(offset + 8, true)),
-    argFloat: view.getFloat64(offset + 16, true),
-    argInt: Number(view.getBigInt64(offset + 24, true)),
-  };
-}
-
-function writeEngineTelemetryRecord(
-  view: DataView,
-  offset: number,
-  telemetry: SonareEngineTelemetryRecord,
-): void {
-  view.setUint32(offset, telemetry.type, true);
-  view.setUint32(offset + 4, telemetry.error, true);
-  view.setBigInt64(offset + 8, BigInt(Math.trunc(telemetry.renderFrame)), true);
-  view.setBigInt64(offset + 16, BigInt(Math.trunc(telemetry.timelineSample)), true);
-  view.setBigInt64(offset + 24, BigInt(Math.trunc(telemetry.audibleTimelineSample)), true);
-  view.setInt32(offset + 32, telemetry.graphLatencySamplesQ8, true);
-  view.setUint32(offset + 36, telemetry.value, true);
-  view.setBigInt64(offset + 40, 0n, true);
-}
-
-function readEngineTelemetryRecord(view: DataView, offset: number): SonareEngineTelemetryRecord {
-  return {
-    type: view.getUint32(offset, true),
-    error: view.getUint32(offset + 4, true),
-    renderFrame: Number(view.getBigInt64(offset + 8, true)),
-    timelineSample: Number(view.getBigInt64(offset + 16, true)),
-    audibleTimelineSample: Number(view.getBigInt64(offset + 24, true)),
-    graphLatencySamplesQ8: view.getInt32(offset + 32, true),
-    value: view.getUint32(offset + 36, true),
-  };
-}
-
-function telemetryFromEngine(telemetry: EngineTelemetry): SonareEngineTelemetryRecord {
-  return {
-    type: telemetry.type,
-    error: telemetry.error,
-    renderFrame: telemetry.renderFrame,
-    timelineSample: telemetry.timelineSample,
-    audibleTimelineSample: telemetry.audibleTimelineSample,
-    graphLatencySamplesQ8: telemetry.graphLatencySamplesQ8,
-    value: telemetry.value,
-  };
-}
-
-function meterFromEngine(meter: EngineMeterTelemetry): SonareWorkletMeterSnapshot {
-  return {
-    type: 'meter',
-    targetId: meter.targetId,
-    frame: meter.renderFrame,
-    peakDbL: meter.peakDbL,
-    peakDbR: meter.peakDbR,
-    rmsDbL: meter.rmsDbL,
-    rmsDbR: meter.rmsDbR,
-    correlation: meter.correlation,
-    truePeakDbL: meter.truePeakDbL,
-    truePeakDbR: meter.truePeakDbR,
-    momentaryLufs: meter.momentaryLufs,
-    shortTermLufs: meter.shortTermLufs,
-    integratedLufs: meter.integratedLufs,
-    gainReductionDb: meter.gainReductionDb,
-  };
-}
-
-function magnitudeToDb(value: number): number {
-  return value > 1.0e-12 ? 20 * Math.log10(value) : -120;
-}
-
 /**
  * AudioWorklet-style mixer bridge backed by the package's single `sonare.wasm`.
  *
@@ -1471,6 +550,7 @@ export class SonareRealtimeEngineWorkletProcessor {
   private commandRing?: SonareEngineCommandRingBuffer;
   private telemetryRing?: SonareEngineTelemetryRingBuffer;
   private meterRing?: SharedMeterRingWriter;
+  private scopeRing?: SharedScopeRingWriter;
   private transport?: WorkletTransport;
   private meterIntervalFrames: number;
   private lastMeterFrame = Number.NEGATIVE_INFINITY;
@@ -1514,6 +594,13 @@ export class SonareRealtimeEngineWorkletProcessor {
     this.meterRing = options.meterSharedBuffer
       ? meterRingFromSharedBuffer(options.meterSharedBuffer, options.meterRingCapacity)
       : undefined;
+    this.scopeRing = options.scopeSharedBuffer
+      ? scopeRingFromSharedBuffer(
+          options.scopeSharedBuffer,
+          options.scopeRingCapacity,
+          options.scopeBands,
+        )
+      : undefined;
     this.engine = new RealtimeEngine(this.sampleRate, this.blockSize);
     // Allocate persistent WASM-heap scratch (worst case: channelCount channels x
     // blockSize frames) and acquire the per-channel heap views once.
@@ -1522,6 +609,13 @@ export class SonareRealtimeEngineWorkletProcessor {
     for (let ch = 0; ch < this.channelCount; ch++) {
       this.channelBuffers[ch] = this.engine.getChannelBuffer(ch, this.blockSize);
     }
+    // Arm the engine's scope producer only when a scope ring was provided. The
+    // band count follows the ring's record layout so writeScopeRing never
+    // overruns its slot.
+    if (this.scopeRing) {
+      const interval = Math.max(1, Math.floor(options.scopeIntervalFrames ?? this.blockSize));
+      this.engine.configureScopeTelemetry(interval, this.scopeRing.bands);
+    }
   }
 
   process(inputs: WorkletInput, outputs: WorkletOutput): boolean {
@@ -1599,6 +693,7 @@ export class SonareRealtimeEngineWorkletProcessor {
     }
     this.publishTelemetry();
     this.publishMeters();
+    this.publishScope();
     return true;
   }
 
@@ -1686,6 +781,9 @@ export class SonareRealtimeEngineWorkletProcessor {
         if (message.masterStripJson) {
           this.engine.setMasterStripJson(message.masterStripJson);
         }
+        for (const binding of message.laneSidechains ?? []) {
+          this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
+        }
         break;
       case 'syncCapture':
         this.engine.setCaptureBuffer(message.channels, message.bufferFrames);
@@ -1714,6 +812,36 @@ export class SonareRealtimeEngineWorkletProcessor {
           message.resetOnBypass,
         );
         break;
+      case 'syncTrackStripInsertParamByName':
+        this.engine.setTrackStripInsertParamByName(
+          message.trackId,
+          message.insertIndex,
+          message.paramName,
+          message.value,
+        );
+        break;
+      case 'syncMasterStripInsertParamByName':
+        this.engine.setMasterStripInsertParamByName(
+          message.insertIndex,
+          message.paramName,
+          message.value,
+        );
+        break;
+      case 'syncTrackStripPan':
+        this.engine.setTrackStripPan(message.trackId, message.pan);
+        break;
+      case 'syncTrackStripPanLaw':
+        this.engine.setTrackStripPanLaw(message.trackId, message.panLaw);
+        break;
+      case 'syncTrackStripPanMode':
+        this.engine.setTrackStripPanMode(message.trackId, message.panMode);
+        break;
+      case 'syncTrackStripDualPan':
+        this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
+        break;
+      case 'syncTrackStripChannelDelaySamples':
+        this.engine.setTrackStripChannelDelaySamples(message.trackId, message.delaySamples);
+        break;
       case 'syncBuiltinInstrument':
         this.engine.setBuiltinInstrument(message.config, message.destinationId);
         break;
@@ -1966,6 +1094,17 @@ export class SonareRealtimeEngineWorkletProcessor {
     this.transport?.postMessage?.(record);
   }
 
+  // Drains the engine meter telemetry queue into the stereo meter ring / transport.
+  //
+  // Shared-queue contract: `drainMeterTelemetry` and `drainMeterTelemetryWide`
+  // pop the SAME single-consumer telemetry queue, so exactly ONE of them may run
+  // per engine. The live worklet path owns the queue via the stereo drain below;
+  // the worklet meter ring (SONARE_METER_RING_RECORD_FLOATS) is a fixed stereo
+  // layout carrying planes 0/1 plus the correlation/LUFS summary. Per-plane
+  // surround meters are NOT delivered over the live worklet ring — a host that
+  // needs them must use the offline `drainMeterTelemetryWide()` API on a
+  // non-worklet engine instance (do not also call it on a worklet-driven engine,
+  // or the two drains will starve each other).
   private publishMeters(): void {
     if (this.meterIntervalFrames <= 0 || (!this.transport && !this.meterRing)) {
       return;
@@ -2023,6 +1162,46 @@ export class SonareRealtimeEngineWorkletProcessor {
     // 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. Only the embind runtime publishes scope
+  // telemetry; the sonare-rt runtime owns its own transport. No allocation on
+  // the render path: records are written field-by-field into the ring.
+  private publishScope(): void {
+    const ring = this.scopeRing;
+    if (!ring) {
+      return;
+    }
+    for (const item of this.engine.drainScopeTelemetry(64)) {
+      this.writeScopeRing(ring, item);
+    }
+  }
+
+  private writeScopeRing(ring: SharedScopeRingWriter, record: EngineScopeTelemetry): void {
+    const writeIndex = Atomics.load(ring.header, 0);
+    const base = (writeIndex % ring.capacity) * ring.recordFloats;
+    ring.records[base] = encodeFrameLo(record.renderFrame);
+    ring.records[base + 1] = encodeFrameHi(record.renderFrame);
+    ring.records[base + 2] = record.targetId;
+    const bandCount = Math.min(ring.bands, record.bands.length);
+    ring.records[base + 3] = bandCount;
+    const pointCount = Math.min(ring.maxPoints, record.points.length);
+    ring.records[base + 4] = pointCount;
+    const bandsBase = base + SONARE_SCOPE_RING_RECORD_PREFIX_FLOATS;
+    for (let i = 0; i < bandCount; i++) {
+      ring.records[bandsBase + i] = record.bands[i];
+    }
+    const pointsBase = bandsBase + ring.bands;
+    for (let i = 0; i < pointCount; i++) {
+      const point = record.points[i];
+      ring.records[pointsBase + 2 * i] = point.left;
+      ring.records[pointsBase + 2 * i + 1] = point.right;
+    }
+    Atomics.store(ring.header, 0, writeIndex + 1);
+    // Like writeMeterRing, writeIndex is a free-running monotonic counter; the
+    // reader detects silent overrun via firstReadable, so the overflow slot
+    // (header[5]) stays at its initial 0.
+  }
+
   private commandRingFromSharedBuffer(
     sharedBuffer: SharedArrayBuffer,
     fallbackCapacity?: number,
@@ -2446,11 +1625,14 @@ export class SonareRealtimeEngineNode {
   readonly commandRing?: SonareEngineCommandRingBuffer;
   readonly telemetryRing?: SonareEngineTelemetryRingBuffer;
   readonly meterRing?: SonareMeterRingBuffer;
+  readonly scopeRing?: SonareScopeRingBuffer;
   readonly ready: Promise<void>;
   private telemetryReadIndex = 0;
   private meterReadIndex = 0;
+  private scopeReadIndex = 0;
   private telemetryListeners = new Set<(telemetry: SonareEngineTelemetryRecord) => void>();
   private meterListeners = new Set<(meter: SonareWorkletMeterSnapshot) => void>();
+  private scopeListeners = new Set<(scope: SonareWorkletScopeSnapshot) => void>();
   private captureRequestId = 1;
   private readonly captureRequests = new Map<
     number,
@@ -2477,12 +1659,14 @@ export class SonareRealtimeEngineNode {
     commandRing?: SonareEngineCommandRingBuffer,
     telemetryRing?: SonareEngineTelemetryRingBuffer,
     meterRing?: SonareMeterRingBuffer,
+    scopeRing?: SonareScopeRingBuffer,
   ) {
     this.node = node;
     this.capabilities = capabilities;
     this.commandRing = commandRing;
     this.telemetryRing = telemetryRing;
     this.meterRing = meterRing;
+    this.scopeRing = scopeRing;
     this.ready = new Promise((resolve, reject) => {
       this.resolveReady = resolve;
       this.rejectReady = reject;
@@ -2581,6 +1765,14 @@ export class SonareRealtimeEngineNode {
       mode === 'sab' && runtimeTarget === 'embind'
         ? createSonareMeterRingBuffer(options.meterRingCapacity ?? 128)
         : undefined;
+    // Scope ring (FFT spectrum + goniometer): opt-in, embind-only. The
+    // per-block FFT is heavier than the meter path, so it is created only when
+    // the caller requests scope telemetry via scopeIntervalFrames > 0.
+    const scopeIntervalFrames = Math.max(0, Math.floor(options.scopeIntervalFrames ?? 0));
+    const scopeRing =
+      mode === 'sab' && runtimeTarget === 'embind' && scopeIntervalFrames > 0
+        ? createSonareScopeRingBuffer(options.scopeRingCapacity ?? 64, options.scopeBands ?? 48)
+        : undefined;
     const channelCount = Math.max(1, Math.floor(options.channelCount ?? 2));
     const processorOptions: SonareRealtimeEngineWorkletProcessorOptions = {
       runtimeTarget,
@@ -2595,6 +1787,10 @@ export class SonareRealtimeEngineNode {
       telemetryRingCapacity: telemetryRing?.capacity,
       meterSharedBuffer: meterRing?.sharedBuffer,
       meterRingCapacity: meterRing?.capacity,
+      scopeSharedBuffer: scopeRing?.sharedBuffer,
+      scopeRingCapacity: scopeRing?.capacity,
+      scopeBands: scopeRing?.bands,
+      scopeIntervalFrames: scopeRing ? scopeIntervalFrames : undefined,
       wasmBinary: options.wasmBinary,
       initialSyncMessages: options.initialSyncMessages,
       initialCommands: options.initialCommands,
@@ -2628,6 +1824,7 @@ export class SonareRealtimeEngineNode {
       commandRing,
       telemetryRing,
       meterRing,
+      scopeRing,
     );
   }
 
@@ -2723,6 +1920,21 @@ export class SonareRealtimeEngineNode {
     return read.meters;
   }
 
+  // Drains scope telemetry (FFT spectrum + goniometer points) published into the
+  // SAB scope ring and forwards each record to onScope listeners. A no-op unless
+  // the node was created with scopeIntervalFrames > 0 (embind SAB mode).
+  pollScope(): SonareWorkletScopeSnapshot[] {
+    if (!this.scopeRing) {
+      return [];
+    }
+    const read = readSonareScopeRingBuffer(this.scopeRing, this.scopeReadIndex);
+    this.scopeReadIndex = read.nextReadIndex;
+    for (const scope of read.scopes) {
+      this.emitScope(scope);
+    }
+    return read.scopes;
+  }
+
   onTelemetry(callback: (telemetry: SonareEngineTelemetryRecord) => void): () => void {
     this.telemetryListeners.add(callback);
     return () => {
@@ -2737,6 +1949,13 @@ export class SonareRealtimeEngineNode {
     };
   }
 
+  onScope(callback: (scope: SonareWorkletScopeSnapshot) => void): () => void {
+    this.scopeListeners.add(callback);
+    return () => {
+      this.scopeListeners.delete(callback);
+    };
+  }
+
   destroy(): void {
     if (this.destroyed) {
       return;
@@ -2754,6 +1973,7 @@ export class SonareRealtimeEngineNode {
     this.transportRequests.clear();
     this.telemetryListeners.clear();
     this.meterListeners.clear();
+    this.scopeListeners.clear();
   }
 
   private emitTelemetry(telemetry: SonareEngineTelemetryRecord): void {
@@ -2768,6 +1988,12 @@ export class SonareRealtimeEngineNode {
     }
   }
 
+  private emitScope(scope: SonareWorkletScopeSnapshot): void {
+    for (const listener of this.scopeListeners) {
+      listener(scope);
+    }
+  }
+
   private sendCaptureRequest(
     op: SonareEngineCaptureRequestMessage['op'],
   ): Promise<SonareEngineCaptureResponseMessage> {
@@ -2811,6 +2037,11 @@ export class SonareEngine {
   private readonly markers = new Map<number, EngineMarker>();
   private readonly trackLaneIds: number[] = [];
   private readonly trackSends = new Map<number, EngineTrackSend[]>();
+  private readonly trackOutputBus = new Map<number, number>();
+  private readonly laneSidechains = new Map<
+    string,
+    { trackId: number; insertIndex: number; sourceTrackId: number }
+  >();
   private readonly buses: EngineBus[] = [];
   private readonly trackStripJson = new Map<number, string>();
   private readonly busStripJson = new Map<number, string>();
@@ -3025,6 +2256,68 @@ export class SonareEngine {
     this.scheduleParam('', laneId, ppq, value, curve);
   }
 
+  /**
+   * Replaces the automation lane for `paramId` with the given breakpoints.
+   *
+   * Unlike scheduleParam (which appends a single point), this sets the whole
+   * lane at once; an empty array clears the lane. The points are defensively
+   * copied and sorted by ppq before being mirrored to the offline engine and
+   * the live worklet engine.
+   *
+   * @param paramId Automation target id (registered parameter or a reserved
+   *   engine mixer target from automationParamId/busAutomationParamId).
+   * @param points Lane breakpoints; order does not matter.
+   */
+  setAutomationLane(paramId: number, points: ReadonlyArray<EngineAutomationPoint>): void {
+    const sorted = points.map((point) => ({ ...point })).sort((a, b) => a.ppq - b.ppq);
+    if (sorted.length === 0) {
+      this.automationLanes.delete(paramId);
+    } else {
+      this.automationLanes.set(paramId, sorted);
+    }
+    this.offlineEngine.setAutomationLane(paramId, sorted);
+    this.postSync({ type: 'syncAutomation', paramId, points: sorted });
+  }
+
+  /**
+   * Returns the automation target id for a mixer strip parameter.
+   *
+   * The id addresses the engine's reserved mixer namespace, so it can be fed
+   * straight to setAutomationLane to automate a fader or pan without
+   * registering a parameter.
+   *
+   * @param target Track id (declares a mixer lane on first use) or 'master'.
+   * @param kind Strip parameter to address.
+   * @returns Reserved engine parameter id for the strip parameter.
+   */
+  automationParamId(target: string | number, kind: 'faderDb' | 'pan'): number {
+    const paramKind = kind === 'pan' ? ENGINE_MIXER_PARAM_PAN : ENGINE_MIXER_PARAM_FADER_DB;
+    if (target === 'master') {
+      return engineMixerMasterTarget(paramKind);
+    }
+    return engineMixerLaneTarget(this.ensureTrackLane(target), paramKind);
+  }
+
+  /**
+   * Returns the automation target id for a bus fader.
+   *
+   * @param busId Bus id (declares the mixer bus on first use).
+   * @returns Reserved engine parameter id for the bus fader gain (dB).
+   */
+  busAutomationParamId(busId: number): number {
+    return engineMixerBusTarget(this.ensureBus(busId), ENGINE_MIXER_PARAM_FADER_DB);
+  }
+
+  /**
+   * Returns the number of automation lanes installed on the engine, including
+   * lanes whose breakpoint list is currently empty.
+   *
+   * @returns Engine-side automation lane count.
+   */
+  automationLaneCount(): number {
+    return this.offlineEngine.automationLaneCount();
+  }
+
   listParameters(): EngineParameterInfo[] {
     const parameters: EngineParameterInfo[] = [];
     for (let index = 0; index < this.offlineEngine.parameterCount(); index++) {
@@ -3125,11 +2418,64 @@ export class SonareEngine {
           entry.sends.map((send) => ({ ...send })),
         );
       }
+      if (entry.outputBusId !== undefined) {
+        if (entry.outputBusId === 0) {
+          this.trackOutputBus.delete(entry.trackId);
+        } else {
+          this.trackOutputBus.set(entry.trackId, entry.outputBusId);
+        }
+      }
     }
     this.trackLaneIds.splice(0, this.trackLaneIds.length, ...ids);
     this.syncMixer();
   }
 
+  /**
+   * Routes a track lane's post-fader output into a declared bus instead of
+   * the master mix (group/folder routing); busId 0 restores the master mix.
+   */
+  setTrackOutputBus(target: string | number, busId: number): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    if (busId === 0) {
+      this.trackOutputBus.delete(trackId);
+    } else {
+      this.trackOutputBus.set(trackId, busId);
+    }
+    this.syncMixer();
+  }
+
+  /**
+   * Keys one insert of a lane strip from another lane's post-strip pre-fader
+   * audio (ducking/sidechainRouter inserts). sourceTarget null removes the
+   * binding.
+   */
+  setLaneSidechain(
+    target: string | number,
+    insertIndex: number,
+    sourceTarget: string | number | null,
+  ): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    const key = `${trackId}:${insertIndex}`;
+    let sourceTrackId = 0;
+    if (sourceTarget !== null) {
+      const sourceIndex = this.ensureTrackLane(sourceTarget);
+      sourceTrackId = this.trackLaneIds[sourceIndex];
+    }
+    if (sourceTrackId === 0) {
+      this.laneSidechains.delete(key);
+    } else {
+      this.laneSidechains.set(key, { trackId, insertIndex, sourceTrackId });
+    }
+    this.offlineEngine.setLaneSidechain(trackId, insertIndex, sourceTrackId);
+    this.postSync({
+      type: 'syncMixer',
+      lanes: this.mixerLanes(),
+      laneSidechains: [{ trackId, insertIndex, sourceTrackId }],
+    });
+  }
+
   setSends(target: string | number, sends: EngineTrackSend[]): void {
     const laneIndex = this.ensureTrackLane(target);
     const trackId = this.trackLaneIds[laneIndex];
@@ -3193,6 +2539,56 @@ export class SonareEngine {
     });
   }
 
+  setTrackStripInsertParamByName(
+    target: string | number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
+    this.postSync({
+      type: 'syncTrackStripInsertParamByName',
+      trackId,
+      insertIndex,
+      paramName,
+      value,
+    });
+  }
+
+  setTrackStripPan(target: string | number, pan: number): void {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripPan(trackId, pan);
+    this.postSync({ type: 'syncTrackStripPan', trackId, pan });
+  }
+
+  setTrackStripPanLaw(target: string | number, panLaw: PanLaw | number): void {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    const code = panLawCode(panLaw);
+    this.offlineEngine.setTrackStripPanLaw(trackId, code);
+    this.postSync({ type: 'syncTrackStripPanLaw', trackId, panLaw: code });
+  }
+
+  setTrackStripPanMode(target: string | number, panMode: PanMode | number): void {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    const code = panModeCode(panMode);
+    this.offlineEngine.setTrackStripPanMode(trackId, code);
+    this.postSync({ type: 'syncTrackStripPanMode', trackId, panMode: code });
+  }
+
+  setTrackStripDualPan(target: string | number, leftPan: number, rightPan: number): void {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripDualPan(trackId, leftPan, rightPan);
+    this.postSync({ type: 'syncTrackStripDualPan', trackId, leftPan, rightPan });
+  }
+
+  setTrackStripChannelDelaySamples(target: string | number, delaySamples: number): void {
+    const trackId = this.trackLaneIds[this.ensureTrackLane(target)];
+    this.offlineEngine.setTrackStripChannelDelaySamples(trackId, delaySamples);
+    this.postSync({ type: 'syncTrackStripChannelDelaySamples', trackId, delaySamples });
+  }
+
   setStripEq(target: string | number, bandIndex: number, band: EqBand | string): void {
     if (target === 'master') {
       this.setMasterStripEqBand(bandIndex, band);
@@ -3255,6 +2651,29 @@ export class SonareEngine {
     });
   }
 
+  setMasterStripInsertParamByName(insertIndex: number, paramName: string, value: number): void {
+    this.offlineEngine.setMasterStripInsertParamByName(insertIndex, paramName, value);
+    this.postSync({
+      type: 'syncMasterStripInsertParamByName',
+      insertIndex,
+      paramName,
+      value,
+    });
+  }
+
+  setStripInsertParamByName(
+    target: string | number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ): void {
+    if (target === 'master') {
+      this.setMasterStripInsertParamByName(insertIndex, paramName, value);
+      return;
+    }
+    this.setTrackStripInsertParamByName(target, insertIndex, paramName, value);
+  }
+
   setMasterChain(sceneJson: string): void {
     this.setMasterStripJson(sceneJson);
   }
@@ -3562,6 +2981,10 @@ export class SonareEngine {
     return this.realtimeNode.onMeter(callback);
   }
 
+  onScope(callback: (scope: SonareWorkletScopeSnapshot) => void): () => void {
+    return this.realtimeNode.onScope(callback);
+  }
+
   onTelemetry(callback: (telemetry: SonareEngineTelemetryRecord) => void): () => void {
     return this.realtimeNode.onTelemetry(callback);
   }
@@ -3574,6 +2997,10 @@ export class SonareEngine {
     return this.realtimeNode.pollMeters();
   }
 
+  pollScope(): SonareWorkletScopeSnapshot[] {
+    return this.realtimeNode.pollScope();
+  }
+
   destroy(): void {
     if (this.destroyed) {
       return;
@@ -3601,13 +3028,20 @@ export class SonareEngine {
     this.postSync({ type: 'syncMidiClips', clips });
   }
 
-  private syncMixer(): void {
-    const lanes = this.trackLaneIds.map((trackId) => {
+  private mixerLanes(): EngineTrackLane[] {
+    return this.trackLaneIds.map((trackId) => {
       const sends = this.trackSends.get(trackId);
-      return sends && sends.length > 0
-        ? { trackId, sends: sends.map((send) => ({ ...send })) }
-        : { trackId };
+      const outputBusId = this.trackOutputBus.get(trackId);
+      return {
+        trackId,
+        ...(sends && sends.length > 0 ? { sends: sends.map((send) => ({ ...send })) } : {}),
+        ...(outputBusId !== undefined ? { outputBusId } : {}),
+      };
     });
+  }
+
+  private syncMixer(): void {
+    const lanes = this.mixerLanes();
     const buses = this.buses.map((bus) => ({ ...bus }));
     this.offlineEngine.setTrackBuses(buses);
     if (lanes.length > 0) {
@@ -3626,6 +3060,7 @@ export class SonareEngine {
       lanes,
       buses,
       trackStrips,
+      laneSidechains: Array.from(this.laneSidechains.values()),
       busStrips,
       masterStripJson: this.masterStripJson,
     });