@libraz/libsonare 1.3.2 → 1.4.0

package/src/worklet.ts

@@ -1,16 +1,33 @@
+import { panLawCode, panModeCode } from './codes';
 import type {
   EngineAutomationPoint,
+  EngineBus,
+  EngineCaptureStatus,
   EngineClip,
   EngineMarker,
-  EngineMeterTelemetry,
   EngineMetronomeConfig,
+  EngineMidiClipSchedule,
   EngineParameterInfo,
-  EngineTelemetry,
+  EngineScopeTelemetry,
+  EngineTempoSegment,
+  EngineTimeSignatureSegment,
+  EngineTrackLane,
+  EngineTrackSend,
+  EngineTransportState,
+  EqBand,
   MixerRealtimeBuffer,
-  RealtimeVoiceChangerConfigInput,
+  PanLaw,
+  PanMode,
 } from './index';
-import { engineCapabilities, Mixer, RealtimeEngine, RealtimeVoiceChanger } from './index';
-import type { AutomationCurve } from './public_types';
+import {
+  engineCapabilities,
+  init as initSonareModule,
+  isInitialized,
+  Mixer,
+  RealtimeEngine,
+  RealtimeVoiceChanger,
+} from './index';
+import type { SonareModule } from './sonare.js';
 import type { SonareRtModule } from './sonare-rt';
 
 // With code-splitting disabled, the worklet bundle carries its own copy of the
@@ -20,100 +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;
-  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;
-}
-
-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;
@@ -121,739 +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;
-  setLoop(startPpq: number, endPpq: number, enabled?: boolean): boolean;
-}
-
 type SuspendableAudioContext = BaseAudioContext & {
   suspend?: () => Promise<void>;
   resume?: () => Promise<void>;
 };
 
-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';
-  frame: number;
-  peakDbL: number;
-  peakDbR: number;
-  rmsDbL: number;
-  rmsDbR: number;
-  correlation: 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, peakDbL, peakDbR, rmsDbL, rmsDbR, correlation, frameHi].
-// 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 = 7;
-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) => 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 SonareEngineSyncMarkersMessage {
-  type: 'syncMarkers';
-  markers: EngineMarker[];
-}
-
-export interface SonareEngineSyncMetronomeMessage {
-  type: 'syncMetronome';
-  config: EngineMetronomeConfig;
-}
-
-export interface SonareEngineSyncAutomationMessage {
-  type: 'syncAutomation';
-  paramId: number;
-  points: EngineAutomationPoint[];
-}
-
-export type SonareEngineSyncMessage =
-  | SonareEngineSyncClipsMessage
-  | SonareEngineSyncMarkersMessage
-  | SonareEngineSyncMetronomeMessage
-  | SonareEngineSyncAutomationMessage;
-
-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) => void;
-  onmessage?: (event: { data: unknown }) => void;
-  addEventListener?: (type: 'message', listener: (event: { data: unknown }) => void) => void;
-  start?: () => void;
-}
-
-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 === 'syncMarkers' ||
-    value.type === 'syncMetronome' ||
-    value.type === 'syncAutomation'
-  );
-}
-
-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'
-  );
-}
-
-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 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) * SONARE_METER_RING_RECORD_FLOATS;
-    meters.push({
-      type: 'meter',
-      frame: decodeFrame(ring.records[offset], ring.records[offset + 6]),
-      peakDbL: ring.records[offset + 1],
-      peakDbR: ring.records[offset + 2],
-      rmsDbL: ring.records[offset + 3],
-      rmsDbR: ring.records[offset + 4],
-      correlation: ring.records[offset + 5],
-    });
-  }
-  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',
-    frame: meter.renderFrame,
-    peakDbL: meter.peakDbL,
-    peakDbR: meter.peakDbR,
-    rmsDbL: meter.rmsDbL,
-    rmsDbR: meter.rmsDbR,
-    correlation: meter.correlation,
-  };
-}
-
-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`.
  *
@@ -1041,12 +412,19 @@ export class SonareWorkletProcessor {
     const denominator = Math.sqrt(sumL * sumR);
     const meter: SonareWorkletMeterSnapshot = {
       type: 'meter',
+      targetId: 0,
       frame: this.processedFrames,
       peakDbL: toDb(peakL),
       peakDbR: toDb(peakR),
       rmsDbL: toDb(rmsL),
       rmsDbR: toDb(rmsR),
       correlation: denominator > 0 ? sumLR / denominator : 0,
+      truePeakDbL: toDb(peakL),
+      truePeakDbR: toDb(peakR),
+      momentaryLufs: Number.NaN,
+      shortTermLufs: Number.NaN,
+      integratedLufs: Number.NaN,
+      gainReductionDb: Number.NaN,
     };
     this.transport.onMeter?.(meter);
     if (this.meterRing) {
@@ -1064,12 +442,19 @@ export class SonareWorkletProcessor {
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = (writeIndex % ring.capacity) * SONARE_METER_RING_RECORD_FLOATS;
     ring.records[offset] = encodeFrameLo(meter.frame);
-    ring.records[offset + 1] = meter.peakDbL;
-    ring.records[offset + 2] = meter.peakDbR;
-    ring.records[offset + 3] = meter.rmsDbL;
-    ring.records[offset + 4] = meter.rmsDbR;
-    ring.records[offset + 5] = meter.correlation;
-    ring.records[offset + 6] = encodeFrameHi(meter.frame);
+    ring.records[offset + 1] = encodeFrameHi(meter.frame);
+    ring.records[offset + 2] = meter.targetId;
+    ring.records[offset + 3] = meter.peakDbL;
+    ring.records[offset + 4] = meter.peakDbR;
+    ring.records[offset + 5] = meter.rmsDbL;
+    ring.records[offset + 6] = meter.rmsDbR;
+    ring.records[offset + 7] = meter.correlation;
+    ring.records[offset + 8] = meter.truePeakDbL;
+    ring.records[offset + 9] = meter.truePeakDbR;
+    ring.records[offset + 10] = meter.momentaryLufs;
+    ring.records[offset + 11] = meter.shortTermLufs;
+    ring.records[offset + 12] = meter.integratedLufs;
+    ring.records[offset + 13] = meter.gainReductionDb;
     Atomics.store(ring.header, 0, writeIndex + 1);
     // writeIndex is a free-running monotonic counter, so an overflow guard here
     // would fire on essentially every write past the first `capacity` records
@@ -1165,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;
@@ -1179,6 +565,7 @@ export class SonareRealtimeEngineWorkletProcessor {
   // allocated per render quantum (the old engine.process() round-tripped fresh
   // arrays on both heaps every block, an RT-safety hazard).
   private channelBuffers: Float32Array[];
+  private readonly liveClips = new Map<number, EngineClip>();
 
   constructor(
     options: SonareRealtimeEngineWorkletProcessorOptions = {},
@@ -1207,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.
@@ -1215,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 {
@@ -1292,6 +693,7 @@ export class SonareRealtimeEngineWorkletProcessor {
     }
     this.publishTelemetry();
     this.publishMeters();
+    this.publishScope();
     return true;
   }
 
@@ -1318,8 +720,28 @@ export class SonareRealtimeEngineWorkletProcessor {
     }
     switch (message.type) {
       case 'syncClips':
+        this.liveClips.clear();
+        for (const clip of message.clips) {
+          if (clip.id !== undefined) {
+            this.liveClips.set(clip.id, clip);
+          }
+        }
         this.engine.setClips(message.clips);
         break;
+      case 'syncClipsDelta':
+        for (const clipId of message.removeIds) {
+          this.liveClips.delete(clipId);
+        }
+        for (const clip of message.upserts) {
+          if (clip.id !== undefined) {
+            this.liveClips.set(clip.id, clip);
+          }
+        }
+        this.engine.setClips(Array.from(this.liveClips.values()));
+        break;
+      case 'syncMidiClips':
+        this.engine.setMidiClips(message.clips);
+        break;
       case 'syncMarkers':
         this.engine.setMarkers(message.markers);
         break;
@@ -1330,6 +752,219 @@ export class SonareRealtimeEngineWorkletProcessor {
       case 'syncAutomation':
         this.engine.setAutomationLane(message.paramId, message.points);
         break;
+      case 'syncTempo':
+        if (message.tempoSegments) {
+          this.engine.setTempoSegments(message.tempoSegments);
+        } else {
+          this.engine.setTempo(message.bpm);
+        }
+        if (message.timeSignatureSegments) {
+          this.engine.setTimeSignatureSegments(message.timeSignatureSegments);
+        } else {
+          this.engine.setTimeSignature(
+            message.timeSignature.numerator,
+            message.timeSignature.denominator,
+          );
+        }
+        break;
+      case 'syncMixer':
+        if (message.buses) {
+          this.engine.setTrackBuses(message.buses);
+        }
+        this.engine.setTrackLanes(message.lanes);
+        for (const strip of message.trackStrips ?? []) {
+          this.engine.setTrackStripJson(strip.trackId, strip.sceneJson);
+        }
+        for (const strip of message.busStrips ?? []) {
+          this.engine.setBusStripJson(strip.busId, strip.sceneJson);
+        }
+        if (message.masterStripJson) {
+          this.engine.setMasterStripJson(message.masterStripJson);
+        }
+        for (const binding of message.laneSidechains ?? []) {
+          this.engine.setLaneSidechain(binding.trackId, binding.insertIndex, binding.sourceTrackId);
+        }
+        break;
+      case 'syncCapture':
+        this.engine.setCaptureBuffer(message.channels, message.bufferFrames);
+        this.engine.setCaptureSource(message.source);
+        this.engine.setRecordOffsetSamples(message.recordOffsetSamples);
+        this.engine.setInputMonitor(message.inputMonitor.enabled, message.inputMonitor.gain);
+        break;
+      case 'syncTrackStripEqBand':
+        this.engine.setTrackStripEqBandJson(message.trackId, message.bandIndex, message.bandJson);
+        break;
+      case 'syncMasterStripEqBand':
+        this.engine.setMasterStripEqBandJson(message.bandIndex, message.bandJson);
+        break;
+      case 'syncTrackStripInsertBypassed':
+        this.engine.setTrackStripInsertBypassed(
+          message.trackId,
+          message.insertIndex,
+          message.bypassed,
+          message.resetOnBypass,
+        );
+        break;
+      case 'syncMasterStripInsertBypassed':
+        this.engine.setMasterStripInsertBypassed(
+          message.insertIndex,
+          message.bypassed,
+          message.resetOnBypass,
+        );
+        break;
+      case 'syncTrackStripInsertParamByName':
+        this.engine.setTrackStripInsertParamByName(
+          message.trackId,
+          message.insertIndex,
+          message.paramName,
+          message.value,
+        );
+        break;
+      case 'syncMasterStripInsertParamByName':
+        this.engine.setMasterStripInsertParamByName(
+          message.insertIndex,
+          message.paramName,
+          message.value,
+        );
+        break;
+      case 'syncTrackStripPan':
+        this.engine.setTrackStripPan(message.trackId, message.pan);
+        break;
+      case 'syncTrackStripPanLaw':
+        this.engine.setTrackStripPanLaw(message.trackId, message.panLaw);
+        break;
+      case 'syncTrackStripPanMode':
+        this.engine.setTrackStripPanMode(message.trackId, message.panMode);
+        break;
+      case 'syncTrackStripDualPan':
+        this.engine.setTrackStripDualPan(message.trackId, message.leftPan, message.rightPan);
+        break;
+      case 'syncTrackStripChannelDelaySamples':
+        this.engine.setTrackStripChannelDelaySamples(message.trackId, message.delaySamples);
+        break;
+      case 'syncBuiltinInstrument':
+        this.engine.setBuiltinInstrument(message.config, message.destinationId);
+        break;
+      case 'syncSynthInstrument':
+        this.engine.setSynthInstrument(message.patch, message.destinationId);
+        break;
+      case 'syncLoadSoundFont':
+        this.engine.loadSoundFont(message.data);
+        break;
+      case 'syncSf2Instrument':
+        this.engine.setSf2Instrument(message.config, message.destinationId);
+        break;
+      case 'syncMidiNoteOn':
+        this.engine.pushMidiNoteOn(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.note,
+          message.velocity,
+          message.renderFrame,
+        );
+        break;
+      case 'syncMidiNoteOff':
+        this.engine.pushMidiNoteOff(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.note,
+          message.velocity,
+          message.renderFrame,
+        );
+        break;
+      case 'syncMidiCc':
+        this.engine.pushMidiCc(
+          message.destinationId,
+          message.group,
+          message.channel,
+          message.controller,
+          message.value,
+          message.renderFrame,
+        );
+        break;
+      case 'syncMidiPanic':
+        this.engine.pushMidiPanic(message.renderFrame);
+        break;
+    }
+  }
+
+  receiveCaptureRequest(message: SonareEngineCaptureRequestMessage): void {
+    if (this.closed) {
+      return;
+    }
+    try {
+      if (message.op === 'status') {
+        const status = this.engine.captureStatus();
+        this.transport?.postMessage?.({
+          type: 'captureResponse',
+          requestId: message.requestId,
+          ok: true,
+          status: {
+            capturedFrames: status.capturedFrames,
+            overflowCount: status.overflowCount,
+            armed: status.armed,
+            punchEnabled: status.punchEnabled,
+            source: status.source,
+            recordOffsetSamples: status.recordOffsetSamples,
+          },
+        } satisfies SonareEngineCaptureResponseMessage);
+        return;
+      }
+      if (message.op === 'read') {
+        const captured = this.engine.capturedAudio();
+        const channels: number[][] = [];
+        for (let ch = 0; ch < captured.length; ch++) {
+          const source = captured[ch];
+          const copy: number[] = [];
+          for (let i = 0; i < source.length; i++) {
+            copy.push(Number(source[i]));
+          }
+          channels.push(copy);
+        }
+        this.transport?.postMessage?.({
+          type: 'captureResponse',
+          requestId: message.requestId,
+          ok: true,
+          channels,
+        } satisfies SonareEngineCaptureResponseMessage);
+        return;
+      }
+      this.engine.resetCapture();
+      this.transport?.postMessage?.({
+        type: 'captureResponse',
+        requestId: message.requestId,
+        ok: true,
+      } satisfies SonareEngineCaptureResponseMessage);
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: 'captureResponse',
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      } satisfies SonareEngineCaptureResponseMessage);
+    }
+  }
+
+  receiveTransportRequest(message: SonareEngineTransportRequestMessage): void {
+    if (this.closed) {
+      return;
+    }
+    try {
+      this.transport?.postMessage?.({
+        type: 'transportResponse',
+        requestId: message.requestId,
+        ok: true,
+        state: this.engine.getTransportState(),
+      } satisfies SonareEngineTransportResponseMessage);
+    } catch (error) {
+      this.transport?.postMessage?.({
+        type: 'transportResponse',
+        requestId: message.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      } satisfies SonareEngineTransportResponseMessage);
     }
   }
 
@@ -1423,6 +1058,14 @@ export class SonareRealtimeEngineWorkletProcessor {
         // (RtPublisher-style swap), so a queued kSeekMarker resolves correctly.
         this.engine.seekMarker(Math.trunc(Number(command.targetId ?? 0)), sampleTime);
         break;
+      case SonareEngineCommandType.SetSoloMute:
+        this.engine.setSoloMute(
+          Math.trunc(Number(command.targetId ?? 0)),
+          Boolean((Number(command.argInt ?? 0) & 0x2) !== 0),
+          Boolean((Number(command.argInt ?? 0) & 0x1) !== 0),
+          sampleTime,
+        );
+        break;
       default:
         this.publishTelemetryRecord({
           type: SonareEngineTelemetryType.Error,
@@ -1451,16 +1094,32 @@ 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;
     }
     for (const item of this.engine.drainMeterTelemetry(64)) {
       const meter = meterFromEngine(item);
-      if (meter.frame - this.lastMeterFrame < this.meterIntervalFrames) {
+      if (
+        meter.frame !== this.lastMeterFrame &&
+        meter.frame - this.lastMeterFrame < this.meterIntervalFrames
+      ) {
         continue;
       }
-      this.lastMeterFrame = meter.frame;
+      if (meter.frame !== this.lastMeterFrame) {
+        this.lastMeterFrame = meter.frame;
+      }
       // Prefer the lock-free SAB meter ring (matching the telemetry path and
       // SonareWorkletProcessor); only fall back to structured-clone postMessage
       // when no ring was provided, so we do not allocate/post from the audio
@@ -1482,12 +1141,19 @@ export class SonareRealtimeEngineWorkletProcessor {
     const writeIndex = Atomics.load(ring.header, 0);
     const offset = (writeIndex % ring.capacity) * SONARE_METER_RING_RECORD_FLOATS;
     ring.records[offset] = encodeFrameLo(meter.frame);
-    ring.records[offset + 1] = meter.peakDbL;
-    ring.records[offset + 2] = meter.peakDbR;
-    ring.records[offset + 3] = meter.rmsDbL;
-    ring.records[offset + 4] = meter.rmsDbR;
-    ring.records[offset + 5] = meter.correlation;
-    ring.records[offset + 6] = encodeFrameHi(meter.frame);
+    ring.records[offset + 1] = encodeFrameHi(meter.frame);
+    ring.records[offset + 2] = meter.targetId;
+    ring.records[offset + 3] = meter.peakDbL;
+    ring.records[offset + 4] = meter.peakDbR;
+    ring.records[offset + 5] = meter.rmsDbL;
+    ring.records[offset + 6] = meter.rmsDbR;
+    ring.records[offset + 7] = meter.correlation;
+    ring.records[offset + 8] = meter.truePeakDbL;
+    ring.records[offset + 9] = meter.truePeakDbR;
+    ring.records[offset + 10] = meter.momentaryLufs;
+    ring.records[offset + 11] = meter.shortTermLufs;
+    ring.records[offset + 12] = meter.integratedLufs;
+    ring.records[offset + 13] = meter.gainReductionDb;
     Atomics.store(ring.header, 0, writeIndex + 1);
     // writeIndex is a free-running monotonic counter, so an overflow guard here
     // would fire on essentially every write past the first `capacity` records
@@ -1496,16 +1162,56 @@ export class SonareRealtimeEngineWorkletProcessor {
     // writeIndex - capacity), so header slot 3 is left at its initial 0.
   }
 
-  private commandRingFromSharedBuffer(
-    sharedBuffer: SharedArrayBuffer,
-    fallbackCapacity?: number,
-  ): SonareEngineCommandRingBuffer {
-    const ring = engineRingFromSharedBuffer(
-      sharedBuffer,
-      SONARE_ENGINE_COMMAND_RECORD_BYTES,
-      fallbackCapacity,
-    );
-    return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
+  // 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,
+  ): SonareEngineCommandRingBuffer {
+    const ring = engineRingFromSharedBuffer(
+      sharedBuffer,
+      SONARE_ENGINE_COMMAND_RECORD_BYTES,
+      fallbackCapacity,
+    );
+    return { sharedBuffer, header: ring.header, view: ring.view, capacity: ring.capacity };
   }
 
   private telemetryRingFromSharedBuffer(
@@ -1657,12 +1363,32 @@ export class SonareRtRealtimeEngineRuntime {
           this.metronomeConfig.clickSamples,
         );
         break;
+      case 'syncTempo':
+        this.module._sonare_rt_engine_set_tempo(this.engine, message.bpm);
+        break;
       case 'syncClips':
+      case 'syncClipsDelta':
+      case 'syncMidiClips':
       case 'syncMarkers':
       case 'syncAutomation':
+      case 'syncMixer':
+      case 'syncCapture':
+      case 'syncTrackStripEqBand':
+      case 'syncMasterStripEqBand':
+      case 'syncTrackStripInsertBypassed':
+      case 'syncMasterStripInsertBypassed':
+      case 'syncBuiltinInstrument':
+      case 'syncSynthInstrument':
+      case 'syncSf2Instrument':
+      case 'syncLoadSoundFont':
+      case 'syncMidiNoteOn':
+      case 'syncMidiNoteOff':
+      case 'syncMidiCc':
+      case 'syncMidiPanic':
         // The sonare-rt C ABI exposes no set_clips / set_markers /
-        // set_automation_lane, so these mutations cannot reach a live sonare-rt
-        // engine. Surface a clear telemetry error rather than silently dropping.
+        // set_automation_lane / set_track_lanes, so these mutations cannot
+        // reach a live sonare-rt engine. Surface a clear telemetry error rather
+        // than silently dropping.
         if (this.telemetryRing) {
           writeSonareEngineTelemetryRingBuffer(this.telemetryRing, {
             type: SonareEngineTelemetryType.Error,
@@ -1678,6 +1404,30 @@ export class SonareRtRealtimeEngineRuntime {
     }
   }
 
+  receiveCaptureRequest(message: SonareEngineCaptureRequestMessage, port?: WorkletPort): void {
+    if (this.closed) {
+      return;
+    }
+    port?.postMessage?.({
+      type: 'captureResponse',
+      requestId: message.requestId,
+      ok: false,
+      error: 'Capture read-back is not supported by the sonare-rt runtime.',
+    } satisfies SonareEngineCaptureResponseMessage);
+  }
+
+  receiveTransportRequest(message: SonareEngineTransportRequestMessage, port?: WorkletPort): void {
+    if (this.closed) {
+      return;
+    }
+    port?.postMessage?.({
+      type: 'transportResponse',
+      requestId: message.requestId,
+      ok: false,
+      error: 'Transport state read-back is not supported by the sonare-rt runtime.',
+    } satisfies SonareEngineTransportResponseMessage);
+  }
+
   destroy(): void {
     if (this.closed) {
       return;
@@ -1875,11 +1625,30 @@ 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,
+    {
+      resolve: (response: SonareEngineCaptureResponseMessage) => void;
+      reject: (reason?: unknown) => void;
+    }
+  >();
+  private transportRequestId = 1;
+  private readonly transportRequests = new Map<
+    number,
+    {
+      resolve: (response: SonareEngineTransportResponseMessage) => void;
+      reject: (reason?: unknown) => void;
+    }
+  >();
   private resolveReady!: () => void;
   private rejectReady!: (reason?: unknown) => void;
   private destroyed = false;
@@ -1890,21 +1659,43 @@ 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;
     });
-    if (capabilities.runtimeTarget !== 'sonare-rt') {
+    if (!capabilities.readyMessage) {
       this.resolveReady();
     }
     this.node.port.onmessage = (event: MessageEvent<unknown>) => {
-      if (isEngineTelemetryRecord(event.data)) {
+      if (isEngineCaptureResponseMessage(event.data)) {
+        const pending = this.captureRequests.get(event.data.requestId);
+        if (pending) {
+          this.captureRequests.delete(event.data.requestId);
+          if (event.data.ok) {
+            pending.resolve(event.data);
+          } else {
+            pending.reject(new Error(event.data.error ?? 'Capture request failed'));
+          }
+        }
+      } else if (isEngineTransportResponseMessage(event.data)) {
+        const pending = this.transportRequests.get(event.data.requestId);
+        if (pending) {
+          this.transportRequests.delete(event.data.requestId);
+          if (event.data.ok) {
+            pending.resolve(event.data);
+          } else {
+            pending.reject(new Error(event.data.error ?? 'Transport request failed'));
+          }
+        }
+      } else if (isEngineTelemetryRecord(event.data)) {
         this.emitTelemetry(event.data);
       } else if (isMeterSnapshot(event.data)) {
         this.emitMeter(event.data);
@@ -1974,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,
@@ -1988,6 +1787,13 @@ 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,
     };
     const factory =
       options.nodeFactory ??
@@ -2011,10 +1817,14 @@ export class SonareRealtimeEngineNode {
         expectedEngineAbiVersion: detectedCapabilities?.expectedEngineAbiVersion,
         abiCompatible: detectedCapabilities?.abiCompatible,
         degradedReason,
+        readyMessage:
+          runtimeTarget === 'sonare-rt' ||
+          (runtimeTarget === 'embind' && moduleUrl !== undefined && !options.nodeFactory),
       },
       commandRing,
       telemetryRing,
       meterRing,
+      scopeRing,
     );
   }
 
@@ -2053,6 +1863,36 @@ export class SonareRealtimeEngineNode {
     return true;
   }
 
+  requestCaptureStatus(): Promise<EngineCaptureStatus> {
+    return this.sendCaptureRequest('status').then((response) => {
+      if (!response.status) {
+        throw new Error('Capture status response is missing status.');
+      }
+      return response.status;
+    });
+  }
+
+  requestCapturedAudio(): Promise<Float32Array[]> {
+    return this.sendCaptureRequest('read').then((response) =>
+      (response.channels ?? []).map((channel) =>
+        channel instanceof Float32Array ? channel : new Float32Array(channel),
+      ),
+    );
+  }
+
+  requestCaptureReset(): Promise<void> {
+    return this.sendCaptureRequest('reset').then(() => undefined);
+  }
+
+  requestTransportState(): Promise<EngineTransportState> {
+    return this.sendTransportRequest().then((response) => {
+      if (!response.state) {
+        throw new Error('Transport state response is missing state.');
+      }
+      return response.state;
+    });
+  }
+
   pollTelemetry(): SonareEngineTelemetryRecord[] {
     if (!this.telemetryRing) {
       return [];
@@ -2080,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 () => {
@@ -2094,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;
@@ -2101,8 +1963,17 @@ export class SonareRealtimeEngineNode {
     this.destroyed = true;
     this.node.port.postMessage({ type: SonareEngineCommandType.TransportStop, sampleTime: -1 });
     this.node.disconnect();
+    for (const pending of this.captureRequests.values()) {
+      pending.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    this.captureRequests.clear();
+    for (const pending of this.transportRequests.values()) {
+      pending.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    this.transportRequests.clear();
     this.telemetryListeners.clear();
     this.meterListeners.clear();
+    this.scopeListeners.clear();
   }
 
   private emitTelemetry(telemetry: SonareEngineTelemetryRecord): void {
@@ -2116,6 +1987,38 @@ export class SonareRealtimeEngineNode {
       listener(meter);
     }
   }
+
+  private emitScope(scope: SonareWorkletScopeSnapshot): void {
+    for (const listener of this.scopeListeners) {
+      listener(scope);
+    }
+  }
+
+  private sendCaptureRequest(
+    op: SonareEngineCaptureRequestMessage['op'],
+  ): Promise<SonareEngineCaptureResponseMessage> {
+    if (this.destroyed) {
+      return Promise.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    const requestId = this.captureRequestId++;
+    const promise = new Promise<SonareEngineCaptureResponseMessage>((resolve, reject) => {
+      this.captureRequests.set(requestId, { resolve, reject });
+    });
+    this.node.port.postMessage({ type: 'captureRequest', requestId, op });
+    return promise;
+  }
+
+  private sendTransportRequest(): Promise<SonareEngineTransportResponseMessage> {
+    if (this.destroyed) {
+      return Promise.reject(new Error('Realtime engine node is destroyed.'));
+    }
+    const requestId = this.transportRequestId++;
+    const promise = new Promise<SonareEngineTransportResponseMessage>((resolve, reject) => {
+      this.transportRequests.set(requestId, { resolve, reject });
+    });
+    this.node.port.postMessage({ type: 'transportRequest', requestId, op: 'state' });
+    return promise;
+  }
 }
 
 export class SonareEngine {
@@ -2130,9 +2033,31 @@ export class SonareEngine {
   private readonly offlineChannelCount: number;
   private readonly automationLanes = new Map<number, EngineAutomationPoint[]>();
   private readonly clips = new Map<number, EngineClip>();
+  private readonly midiClips = new Map<number, EngineMidiClipSchedule>();
   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>();
+  private masterStripJson: string | undefined;
+  private captureConfig: Omit<SonareEngineSyncCaptureMessage, 'type'> | undefined;
+  private tempoBpm = 120;
+  private timeSignature = { numerator: 4, denominator: 4 };
+  private tempoSegments: EngineTempoSegment[] = [{ startPpq: 0, bpm: 120 }];
+  private timeSignatureSegments: EngineTimeSignatureSegment[] = [
+    { startPpq: 0, numerator: 4, denominator: 4 },
+  ];
+  private latestTransportState: EngineTransportState | undefined;
   private nextClipId = 1;
   private nextMarkerId = 1;
+  private transportPlaying = false;
+  private readonly pendingInstrumentSync: SonareEngineInstrumentSyncMessage[] = [];
   private destroyed = false;
 
   private constructor(
@@ -2152,8 +2077,21 @@ export class SonareEngine {
     this.offlineBlockSize = offlineBlockSize;
     this.offlineChannelCount = offlineChannelCount;
     this.transport = {
-      play: (sampleTime = -1) => this.realtimeNode.play(sampleTime),
-      stop: (sampleTime = -1) => this.realtimeNode.stop(sampleTime),
+      play: (sampleTime = -1) => {
+        const ok = this.realtimeNode.play(sampleTime);
+        if (ok) {
+          this.transportPlaying = true;
+        }
+        return ok;
+      },
+      stop: (sampleTime = -1) => {
+        const ok = this.realtimeNode.stop(sampleTime);
+        if (ok) {
+          this.transportPlaying = false;
+          this.flushPendingInstrumentSync();
+        }
+        return ok;
+      },
       seekPpq: (ppq, sampleTime = -1) => {
         this.offlineEngine.seekPpq(ppq, sampleTime);
         return this.realtimeNode.seekPpq(ppq, sampleTime);
@@ -2164,6 +2102,7 @@ export class SonareEngine {
         return this.realtimeNode.seekSample(timelineSample, sampleTime);
       },
       setTempo: (bpm) => this.setTempo(bpm),
+      setTempoSegments: (segments) => this.setTempoSegments(segments),
       setLoop: (startPpq, endPpq, enabled = true) => this.setLoop(startPpq, endPpq, enabled),
     };
   }
@@ -2205,7 +2144,10 @@ export class SonareEngine {
   }
 
   setTempo(bpm: number): void {
+    this.tempoBpm = bpm;
+    this.tempoSegments = [{ startPpq: 0, bpm }];
     this.offlineEngine.setTempo(bpm);
+    this.postTempoSync();
     this.realtimeNode.sendCommand({
       type: SonareEngineCommandType.SetTempoMap,
       sampleTime: -1,
@@ -2213,6 +2155,30 @@ export class SonareEngine {
     });
   }
 
+  setTempoSegments(segments: readonly EngineTempoSegment[]): void {
+    this.tempoSegments = segments.map((segment) => ({ ...segment }));
+    this.tempoBpm = this.tempoSegments[0]?.bpm ?? this.tempoBpm;
+    this.offlineEngine.setTempoSegments(this.tempoSegments);
+    this.postTempoSync();
+  }
+
+  setTimeSignature(numerator: number, denominator: number): void {
+    this.timeSignature = { numerator, denominator };
+    this.timeSignatureSegments = [{ startPpq: 0, numerator, denominator }];
+    this.offlineEngine.setTimeSignature(numerator, denominator);
+    this.postTempoSync();
+  }
+
+  setTimeSignatureSegments(segments: readonly EngineTimeSignatureSegment[]): void {
+    this.timeSignatureSegments = segments.map((segment) => ({ ...segment }));
+    const first = this.timeSignatureSegments[0];
+    if (first) {
+      this.timeSignature = { numerator: first.numerator, denominator: first.denominator };
+    }
+    this.offlineEngine.setTimeSignatureSegments(this.timeSignatureSegments);
+    this.postTempoSync();
+  }
+
   setLoop(startPpq: number, endPpq: number, enabled = true): boolean {
     this.offlineEngine.setLoop(startPpq, endPpq, enabled);
     // Transport precision contract: the SAB command record carries exactly one
@@ -2233,6 +2199,20 @@ export class SonareEngine {
     });
   }
 
+  countInEndSample(startSample: number, bars: number): number {
+    return this.offlineEngine.countInEndSample(startSample, bars);
+  }
+
+  async getTransportState(): Promise<EngineTransportState> {
+    const state = await this.realtimeNode.requestTransportState();
+    this.latestTransportState = state;
+    return state;
+  }
+
+  cachedTransportState(): EngineTransportState | undefined {
+    return this.latestTransportState;
+  }
+
   setParam(nodeId: string, param: string | number, value: number): boolean {
     const paramId = this.resolveParamId(nodeId, param);
     // Mirror the change into the offline engine so a subsequent offline render
@@ -2276,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++) {
@@ -2285,19 +2327,355 @@ export class SonareEngine {
   }
 
   setSoloMute(target: string | number, solo: boolean, mute: boolean): boolean {
-    void target;
-    void solo;
-    void mute;
-    // Per-track solo/mute is a Mixer concept (strip-indexed setSoloed/setMuted),
-    // not an engine command: the WASM SonareEngine facade does not own a Mixer
-    // node, so there is no realtime transport for solo/mute on this surface.
-    // Throw a clear error instead of silently returning false (a silent no-op
-    // would leave callers believing the change took effect). Apply solo/mute
-    // directly on a Mixer instance (Mixer.setSoloed/Mixer.setMuted) instead.
-    throw new Error(
-      'SonareEngine.setSoloMute is not supported: solo/mute is a Mixer feature; ' +
-        'use Mixer.setSoloed(stripIndex, ...) / Mixer.setMuted(stripIndex, ...) instead.',
+    const laneIndex = this.ensureTrackLane(target);
+    this.offlineEngine.setSoloMute(laneIndex, solo, mute);
+    return this.realtimeNode.sendCommand({
+      type: SonareEngineCommandType.SetSoloMute,
+      targetId: laneIndex,
+      sampleTime: -1,
+      argInt: (mute ? 0x1 : 0) | (solo ? 0x2 : 0),
+    });
+  }
+
+  setStripGain(target: string | number, db: number): boolean {
+    if (target === 'master') {
+      const paramId = engineMixerMasterTarget(ENGINE_MIXER_PARAM_FADER_DB);
+      this.offlineEngine.setParameter(paramId, db);
+      return this.realtimeNode.sendCommand({
+        type: SonareEngineCommandType.SetParamSmoothed,
+        targetId: paramId,
+        sampleTime: -1,
+        argFloat: db,
+      });
+    }
+    const laneIndex = this.ensureTrackLane(target);
+    const paramId = engineMixerLaneTarget(laneIndex, ENGINE_MIXER_PARAM_FADER_DB);
+    this.offlineEngine.setParameter(paramId, db);
+    return this.realtimeNode.sendCommand({
+      type: SonareEngineCommandType.SetParamSmoothed,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: db,
+    });
+  }
+
+  setStripPan(target: string | number, pan: number): boolean {
+    if (target === 'master') {
+      const paramId = engineMixerMasterTarget(ENGINE_MIXER_PARAM_PAN);
+      this.offlineEngine.setParameter(paramId, pan);
+      return this.realtimeNode.sendCommand({
+        type: SonareEngineCommandType.SetParamSmoothed,
+        targetId: paramId,
+        sampleTime: -1,
+        argFloat: pan,
+      });
+    }
+    const laneIndex = this.ensureTrackLane(target);
+    const paramId = engineMixerLaneTarget(laneIndex, ENGINE_MIXER_PARAM_PAN);
+    this.offlineEngine.setParameter(paramId, pan);
+    return this.realtimeNode.sendCommand({
+      type: SonareEngineCommandType.SetParamSmoothed,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: pan,
+    });
+  }
+
+  /**
+   * Declares the mixer track lanes in an explicit order.
+   *
+   * Lane indices are append-only: once a track id occupies a lane, its index
+   * stays fixed for the engine's lifetime. The given list must therefore start
+   * with the already-declared lane ids in their current order and may only
+   * append new track ids after them. Entries carrying `sends` replace that
+   * track's send list; entries without `sends` leave existing sends untouched.
+   *
+   * @param lanes Track ids or lane descriptors in the desired lane order.
+   */
+  setTrackLanes(lanes: ReadonlyArray<number | EngineTrackLane>): void {
+    const entries = lanes.map((lane) => (typeof lane === 'number' ? { trackId: lane } : lane));
+    const ids: number[] = [];
+    for (const entry of entries) {
+      if (!Number.isInteger(entry.trackId) || entry.trackId <= 0) {
+        throw new Error(`Invalid track id for mixer lane: ${String(entry.trackId)}`);
+      }
+      ids.push(entry.trackId);
+    }
+    if (new Set(ids).size !== ids.length) {
+      throw new Error('Duplicate track id in mixer lane list');
+    }
+    for (let index = 0; index < this.trackLaneIds.length; index++) {
+      if (ids[index] !== this.trackLaneIds[index]) {
+        throw new Error(
+          'Mixer lanes are append-only: keep existing lanes in order and only append new track ids',
+        );
+      }
+    }
+    for (const entry of entries) {
+      if (entry.sends) {
+        this.trackSends.set(
+          entry.trackId,
+          entry.sends.map((send) => ({ ...send })),
+        );
+      }
+      if (entry.outputBusId !== 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];
+    this.trackSends.set(
+      trackId,
+      sends.map((send) => ({ ...send })),
     );
+    this.syncMixer();
+  }
+
+  setTrackBuses(buses: EngineBus[]): void {
+    this.buses.splice(0, this.buses.length, ...buses.map((bus) => ({ ...bus })));
+    this.syncMixer();
+  }
+
+  setBusGain(busId: number, db: number): boolean {
+    const busIndex = this.ensureBus(busId);
+    this.buses[busIndex] = { ...this.buses[busIndex], busId, gainDb: db };
+    this.offlineEngine.setTrackBuses(this.buses);
+    const paramId = engineMixerBusTarget(busIndex, ENGINE_MIXER_PARAM_FADER_DB);
+    this.offlineEngine.setParameter(paramId, db);
+    return this.realtimeNode.sendCommand({
+      type: SonareEngineCommandType.SetParamSmoothed,
+      targetId: paramId,
+      sampleTime: -1,
+      argFloat: db,
+    });
+  }
+
+  setTrackStripJson(target: string | number, sceneJson: string): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripJson(trackId, sceneJson);
+    this.trackStripJson.set(trackId, sceneJson);
+    this.syncMixer();
+  }
+
+  setTrackStripEqBand(target: string | number, bandIndex: number, band: EqBand | string): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    const bandJson = typeof band === 'string' ? band : JSON.stringify(band);
+    this.offlineEngine.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+    this.postSync({ type: 'syncTrackStripEqBand', trackId, bandIndex, bandJson });
+  }
+
+  setTrackStripInsertBypassed(
+    target: string | number,
+    insertIndex: number,
+    bypassed: boolean,
+    resetOnBypass = false,
+  ): void {
+    const laneIndex = this.ensureTrackLane(target);
+    const trackId = this.trackLaneIds[laneIndex];
+    this.offlineEngine.setTrackStripInsertBypassed(trackId, insertIndex, bypassed, resetOnBypass);
+    this.postSync({
+      type: 'syncTrackStripInsertBypassed',
+      trackId,
+      insertIndex,
+      bypassed,
+      resetOnBypass,
+    });
+  }
+
+  setTrackStripInsertParamByName(
+    target: 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);
+      return;
+    }
+    this.setTrackStripEqBand(target, bandIndex, band);
+  }
+
+  setStripInsertBypassed(
+    target: string | number,
+    insertIndex: number,
+    bypassed: boolean,
+    resetOnBypass = false,
+  ): void {
+    if (target === 'master') {
+      this.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+      return;
+    }
+    this.setTrackStripInsertBypassed(target, insertIndex, bypassed, resetOnBypass);
+  }
+
+  setStripInserts(target: string | number, sceneJson: string): void {
+    if (target === 'master') {
+      this.setMasterStripJson(sceneJson);
+      return;
+    }
+    this.setTrackStripJson(target, sceneJson);
+  }
+
+  setBusStripJson(busId: number, sceneJson: string): void {
+    this.ensureBus(busId);
+    this.offlineEngine.setBusStripJson(busId, sceneJson);
+    this.busStripJson.set(busId, sceneJson);
+    this.syncMixer();
+  }
+
+  setMasterStripJson(sceneJson: string): void {
+    this.offlineEngine.setMasterStripJson(sceneJson);
+    this.masterStripJson = sceneJson;
+    this.syncMixer();
+  }
+
+  setMasterStripEqBand(bandIndex: number, band: EqBand | string): void {
+    const bandJson = typeof band === 'string' ? band : JSON.stringify(band);
+    this.offlineEngine.setMasterStripEqBandJson(bandIndex, bandJson);
+    this.postSync({ type: 'syncMasterStripEqBand', bandIndex, bandJson });
+  }
+
+  setMasterStripInsertBypassed(
+    insertIndex: number,
+    bypassed: boolean,
+    resetOnBypass = false,
+  ): void {
+    this.offlineEngine.setMasterStripInsertBypassed(insertIndex, bypassed, resetOnBypass);
+    this.postSync({
+      type: 'syncMasterStripInsertBypassed',
+      insertIndex,
+      bypassed,
+      resetOnBypass,
+    });
+  }
+
+  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);
   }
 
   addClip(
@@ -2312,19 +2690,152 @@ export class SonareEngine {
       id,
       channels: buffer,
       startPpq,
+      trackId: this.resolveTargetId(trackId),
     };
+    this.ensureTrackLane(trackId);
     this.clips.set(id, clip);
-    this.syncClips();
-    void trackId;
+    this.syncClipsDelta([clip], []);
     return id;
   }
 
   removeClip(clipId: number): void {
     this.clips.delete(clipId);
-    this.syncClips();
+    this.syncClipsDelta([], [clipId]);
+  }
+
+  setMidiClips(clips: readonly EngineMidiClipSchedule[]): void {
+    this.midiClips.clear();
+    for (const clip of clips) {
+      const id = clip.id ?? this.nextClipId++;
+      this.midiClips.set(id, { ...clip, id, events: clip.events.map((event) => ({ ...event })) });
+    }
+    this.syncMidiClips();
+  }
+
+  setBuiltinInstrument(
+    trackId: string | number,
+    config: { destinationId?: number } & Record<string, unknown> = {},
+  ): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setBuiltinInstrument(config, destinationId);
+    this.postInstrumentSync({ type: 'syncBuiltinInstrument', destinationId, config });
+  }
+
+  setSynthInstrument(trackId: string | number, patch: Record<string, unknown> | string = {}): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setSynthInstrument(patch, destinationId);
+    this.postInstrumentSync({ type: 'syncSynthInstrument', destinationId, patch });
+  }
+
+  loadSoundFont(data: Uint8Array): void {
+    this.offlineEngine.loadSoundFont(data);
+    this.postInstrumentSync({ type: 'syncLoadSoundFont', data });
+  }
+
+  setSf2Instrument(
+    trackId: string | number,
+    config: { destinationId?: number; gain?: number; polyphony?: number } = {},
+  ): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.setSf2Instrument(config, destinationId);
+    this.postInstrumentSync({ type: 'syncSf2Instrument', destinationId, config });
+  }
+
+  pushMidiNoteOn(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    note: number,
+    velocity: number,
+    renderFrame = -1,
+  ): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiNoteOn(destinationId, group, channel, note, velocity, renderFrame);
+    this.postSync({
+      type: 'syncMidiNoteOn',
+      destinationId,
+      group,
+      channel,
+      note,
+      velocity,
+      renderFrame,
+    });
+  }
+
+  pushMidiNoteOff(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    note: number,
+    velocity = 0,
+    renderFrame = -1,
+  ): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiNoteOff(destinationId, group, channel, note, velocity, renderFrame);
+    this.postSync({
+      type: 'syncMidiNoteOff',
+      destinationId,
+      group,
+      channel,
+      note,
+      velocity,
+      renderFrame,
+    });
+  }
+
+  pushMidiCc(
+    trackId: string | number,
+    group: number,
+    channel: number,
+    controller: number,
+    value: number,
+    renderFrame = -1,
+  ): void {
+    const destinationId = this.resolveTargetId(trackId);
+    this.offlineEngine.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
+    this.postSync({
+      type: 'syncMidiCc',
+      destinationId,
+      group,
+      channel,
+      controller,
+      value,
+      renderFrame,
+    });
+  }
+
+  pushMidiPanic(renderFrame = -1): void {
+    this.offlineEngine.pushMidiPanic(renderFrame);
+    this.postSync({ type: 'syncMidiPanic', renderFrame });
+  }
+
+  configureCapture(options: {
+    bufferFrames: number;
+    channels?: number;
+    source?: EngineCaptureStatus['source'];
+    recordOffsetSamples?: number;
+    inputMonitor?: { enabled: boolean; gain?: number };
+  }): void {
+    const bufferFrames = Math.trunc(options.bufferFrames);
+    const channels = Math.trunc(options.channels ?? this.offlineChannelCount);
+    const source = options.source ?? 'output';
+    const recordOffsetSamples = Math.trunc(options.recordOffsetSamples ?? 0);
+    const inputMonitor = {
+      enabled: Boolean(options.inputMonitor?.enabled),
+      gain: options.inputMonitor?.gain ?? 1,
+    };
+    this.offlineEngine.setCaptureBuffer(channels, bufferFrames);
+    this.offlineEngine.setCaptureSource(source);
+    this.offlineEngine.setRecordOffsetSamples(recordOffsetSamples);
+    this.offlineEngine.setInputMonitor(inputMonitor.enabled, inputMonitor.gain);
+    this.captureConfig = { bufferFrames, channels, source, recordOffsetSamples, inputMonitor };
+    this.postSync({ type: 'syncCapture', ...this.captureConfig });
   }
 
   armRecord(trackId: string | number, enabled: boolean): boolean {
+    if (enabled && !this.captureConfig) {
+      throw new Error('Capture buffer is not configured');
+    }
     this.offlineEngine.armCapture(enabled);
     return this.realtimeNode.sendCommand({
       type: SonareEngineCommandType.ArmRecord,
@@ -2335,8 +2846,8 @@ export class SonareEngine {
   }
 
   punch(inPpq: number, outPpq: number): boolean {
-    const inSample = this.ppqToApproxSample(inPpq);
-    const outSample = this.ppqToApproxSample(outPpq);
+    const inSample = this.offlineEngine.sampleAtPpq(inPpq);
+    const outSample = this.offlineEngine.sampleAtPpq(outPpq);
     this.offlineEngine.setCapturePunch(inSample, outSample, true);
     // Carry BOTH endpoints as already-converted SAMPLES so the realtime engine
     // agrees with the offline engine. The previous code sent the raw PPQ out
@@ -2351,6 +2862,19 @@ export class SonareEngine {
     });
   }
 
+  captureStatus(): Promise<EngineCaptureStatus> {
+    return this.realtimeNode.requestCaptureStatus();
+  }
+
+  capturedAudio(): Promise<Float32Array[]> {
+    return this.realtimeNode.requestCapturedAudio();
+  }
+
+  async resetCapture(): Promise<void> {
+    this.offlineEngine.resetCapture();
+    await this.realtimeNode.requestCaptureReset();
+  }
+
   setMetronome(opts: EngineMetronomeConfig): void {
     this.offlineEngine.setMetronome(opts);
     // The full config (beatGain/accentGain/clickSamples/clickSeconds) cannot fit
@@ -2371,6 +2895,59 @@ export class SonareEngine {
     return id;
   }
 
+  /**
+   * Replaces the whole marker set in one call.
+   *
+   * Entries without an `id` are assigned fresh ids; entries carrying an `id`
+   * keep it (ids must be positive and unique within the list). Returns the
+   * resolved markers in the order given, so a caller can map its own marker
+   * identities to the engine ids used by `seekMarker`/`setLoopFromMarkers`.
+   *
+   * @param markers The full marker list (an empty list clears all markers).
+   * @returns The markers with their resolved engine ids.
+   */
+  setMarkers(markers: ReadonlyArray<{ ppq: number; name?: string; id?: number }>): EngineMarker[] {
+    const resolved: EngineMarker[] = [];
+    const seen = new Set<number>();
+    for (const marker of markers) {
+      if (!Number.isFinite(marker.ppq)) {
+        throw new Error(`Invalid marker ppq: ${String(marker.ppq)}`);
+      }
+      if (marker.id !== undefined) {
+        if (!Number.isInteger(marker.id) || marker.id <= 0) {
+          throw new Error(`Invalid marker id: ${String(marker.id)}`);
+        }
+        if (seen.has(marker.id)) {
+          throw new Error(`Duplicate marker id: ${marker.id}`);
+        }
+      }
+      const id = marker.id ?? this.nextMarkerId++;
+      seen.add(id);
+      if (id >= this.nextMarkerId) {
+        this.nextMarkerId = id + 1;
+      }
+      resolved.push({ id, ppq: marker.ppq, name: marker.name ?? '' });
+    }
+    this.markers.clear();
+    for (const marker of resolved) {
+      this.markers.set(marker.id, marker);
+    }
+    this.syncMarkers();
+    return resolved.map((marker) => ({ ...marker }));
+  }
+
+  markerCount(): number {
+    return this.offlineEngine.markerCount();
+  }
+
+  markerByIndex(index: number): EngineMarker {
+    return this.offlineEngine.markerByIndex(index);
+  }
+
+  marker(markerId: number): EngineMarker {
+    return this.offlineEngine.marker(markerId);
+  }
+
   seekMarker(markerId: number): boolean {
     this.offlineEngine.seekMarker(markerId);
     // Forward to the live worklet engine. Its marker set is kept in sync via the
@@ -2384,6 +2961,13 @@ export class SonareEngine {
     });
   }
 
+  setLoopFromMarkers(startMarkerId: number, endMarkerId: number): boolean {
+    this.offlineEngine.setLoopFromMarkers(startMarkerId, endMarkerId);
+    const start = this.offlineEngine.marker(startMarkerId);
+    const end = this.offlineEngine.marker(endMarkerId);
+    return this.setLoop(start.ppq, end.ppq, true);
+  }
+
   async renderOffline(totalFrames: number): Promise<Float32Array[]> {
     const frames = Math.max(0, Math.floor(totalFrames));
     const inputs: Float32Array[] = [];
@@ -2397,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);
   }
@@ -2409,6 +2997,10 @@ export class SonareEngine {
     return this.realtimeNode.pollMeters();
   }
 
+  pollScope(): SonareWorkletScopeSnapshot[] {
+    return this.realtimeNode.pollScope();
+  }
+
   destroy(): void {
     if (this.destroyed) {
       return;
@@ -2420,14 +3012,58 @@ export class SonareEngine {
     this.offlineEngine.destroy();
   }
 
-  private syncClips(): void {
+  private syncClipsDelta(upserts: EngineClip[], removeIds: number[]): void {
     const clips = Array.from(this.clips.values());
     this.offlineEngine.setClips(clips);
-    // Push the full clip set to the live worklet engine over the message port.
-    // Clip audio buffers are too large for the fixed-size SAB command record, so
-    // they ride a structured-clone 'syncClips' message applied OUTSIDE the audio
-    // render callback (the audio-thread equivalent of an RtPublisher swap).
-    this.postSync({ type: 'syncClips', clips });
+    this.postSync({
+      type: 'syncClipsDelta',
+      upserts,
+      removeIds,
+    });
+  }
+
+  private syncMidiClips(): void {
+    const clips = Array.from(this.midiClips.values());
+    this.offlineEngine.setMidiClips(clips);
+    this.postSync({ type: 'syncMidiClips', clips });
+  }
+
+  private mixerLanes(): EngineTrackLane[] {
+    return this.trackLaneIds.map((trackId) => {
+      const sends = this.trackSends.get(trackId);
+      const outputBusId = this.trackOutputBus.get(trackId);
+      return {
+        trackId,
+        ...(sends && sends.length > 0 ? { sends: sends.map((send) => ({ ...send })) } : {}),
+        ...(outputBusId !== undefined ? { outputBusId } : {}),
+      };
+    });
+  }
+
+  private syncMixer(): void {
+    const lanes = this.mixerLanes();
+    const buses = this.buses.map((bus) => ({ ...bus }));
+    this.offlineEngine.setTrackBuses(buses);
+    if (lanes.length > 0) {
+      this.offlineEngine.setTrackLanes(lanes);
+    }
+    const trackStrips = Array.from(this.trackStripJson, ([trackId, sceneJson]) => ({
+      trackId,
+      sceneJson,
+    }));
+    const busStrips = Array.from(this.busStripJson, ([busId, sceneJson]) => ({
+      busId,
+      sceneJson,
+    }));
+    this.postSync({
+      type: 'syncMixer',
+      lanes,
+      buses,
+      trackStrips,
+      laneSidechains: Array.from(this.laneSidechains.values()),
+      busStrips,
+      masterStripJson: this.masterStripJson,
+    });
   }
 
   private syncMarkers(): void {
@@ -2436,6 +3072,37 @@ export class SonareEngine {
     this.postSync({ type: 'syncMarkers', markers });
   }
 
+  private postInstrumentSync(message: SonareEngineInstrumentSyncMessage): void {
+    if (this.destroyed) {
+      return;
+    }
+    if (this.transportPlaying) {
+      this.pendingInstrumentSync.push(message);
+      return;
+    }
+    this.postSync(message);
+  }
+
+  private flushPendingInstrumentSync(): void {
+    if (this.destroyed || this.pendingInstrumentSync.length === 0) {
+      return;
+    }
+    const pending = this.pendingInstrumentSync.splice(0);
+    for (const message of pending) {
+      this.postSync(message);
+    }
+  }
+
+  private postTempoSync(): void {
+    this.postSync({
+      type: 'syncTempo',
+      bpm: this.tempoBpm,
+      timeSignature: { ...this.timeSignature },
+      tempoSegments: this.tempoSegments.map((segment) => ({ ...segment })),
+      timeSignatureSegments: this.timeSignatureSegments.map((segment) => ({ ...segment })),
+    });
+  }
+
   // Posts an out-of-band control-sync message to the worklet engine processor.
   // Sync messages use a string `type` so the worklet's message handler routes
   // them to receiveSync() (numeric `type` is reserved for SonareEngineCommandRecord).
@@ -2465,16 +3132,40 @@ export class SonareEngine {
     return Number.isFinite(parsed) ? parsed : 0;
   }
 
+  private ensureTrackLane(target: string | number): number {
+    const trackId = this.resolveTargetId(target);
+    if (!Number.isInteger(trackId) || trackId <= 0) {
+      throw new Error(`Invalid track id for mixer lane: ${String(target)}`);
+    }
+    const existing = this.trackLaneIds.indexOf(trackId);
+    if (existing >= 0) {
+      return existing;
+    }
+    this.trackLaneIds.push(trackId);
+    this.syncMixer();
+    return this.trackLaneIds.length - 1;
+  }
+
+  private ensureBus(busId: number): number {
+    const resolved = Math.trunc(busId);
+    if (!Number.isInteger(resolved) || resolved <= 0) {
+      throw new Error(`Invalid bus id for mixer bus: ${String(busId)}`);
+    }
+    const existing = this.buses.findIndex((bus) => bus.busId === resolved);
+    if (existing >= 0) {
+      return existing;
+    }
+    this.buses.push({ busId: resolved });
+    this.syncMixer();
+    return this.buses.length - 1;
+  }
+
   private curveCode(curve: number | 'linear' | 'exponential'): number {
     if (typeof curve === 'number') {
       return curve;
     }
     return curve === 'exponential' ? 1 : 0;
   }
-
-  private ppqToApproxSample(ppq: number): number {
-    return Math.max(0, Math.round(((ppq * 60) / 120) * this.sampleRate));
-  }
 }
 
 export class SonareRealtimeVoiceChangerWorkletProcessor {
@@ -2768,6 +3459,7 @@ export function registerSonareRealtimeEngineWorkletProcessor(
   class RegisteredSonareRealtimeEngineWorkletProcessor extends Base {
     private bridge?: SonareRealtimeEngineWorkletProcessor;
     private rtBridge?: SonareRtRealtimeEngineRuntime;
+    private readonly pendingMessages: unknown[] = [];
     readonly port?: WorkletPort;
 
     constructor(options?: { processorOptions?: SonareRealtimeEngineWorkletProcessorOptions }) {
@@ -2777,18 +3469,27 @@ export function registerSonareRealtimeEngineWorkletProcessor(
       if (processorOptions.runtimeTarget === 'sonare-rt') {
         void this.initializeSonareRt(processorOptions, port);
       } else {
-        this.bridge = new SonareRealtimeEngineWorkletProcessor(processorOptions, {
-          postMessage: (message) => port?.postMessage?.(message),
-          onMeter: (meter) => port?.postMessage?.(meter),
-        });
+        void this.initializeEmbind(processorOptions, port);
       }
       const onMessage = (event: { data: unknown }) => {
+        if (!this.bridge && !this.rtBridge) {
+          if (this.pendingMessages.length < 1024) {
+            this.pendingMessages.push(event.data);
+          }
+          return;
+        }
         if (isEngineCommandRecord(event.data)) {
           this.bridge?.receiveCommand(event.data);
           this.rtBridge?.receiveCommand(event.data);
         } else if (isEngineSyncMessage(event.data)) {
           this.bridge?.receiveSync(event.data);
           this.rtBridge?.receiveSync(event.data);
+        } else if (isEngineCaptureRequestMessage(event.data)) {
+          this.bridge?.receiveCaptureRequest(event.data);
+          this.rtBridge?.receiveCaptureRequest(event.data, port);
+        } else if (isEngineTransportRequestMessage(event.data)) {
+          this.bridge?.receiveTransportRequest(event.data);
+          this.rtBridge?.receiveTransportRequest(event.data, port);
         }
       };
       if (port?.addEventListener) {
@@ -2813,6 +3514,75 @@ export function registerSonareRealtimeEngineWorkletProcessor(
       return true;
     }
 
+    private replayPendingMessages(port?: WorkletPort): void {
+      const messages = this.pendingMessages.splice(0);
+      for (const data of messages) {
+        if (isEngineCommandRecord(data)) {
+          this.bridge?.receiveCommand(data);
+          this.rtBridge?.receiveCommand(data);
+        } else if (isEngineSyncMessage(data)) {
+          this.bridge?.receiveSync(data);
+          this.rtBridge?.receiveSync(data);
+        } else if (isEngineCaptureRequestMessage(data)) {
+          this.bridge?.receiveCaptureRequest(data);
+          this.rtBridge?.receiveCaptureRequest(data, port);
+        } else if (isEngineTransportRequestMessage(data)) {
+          this.bridge?.receiveTransportRequest(data);
+          this.rtBridge?.receiveTransportRequest(data, port);
+        }
+      }
+    }
+
+    private async initializeEmbind(
+      options: SonareRealtimeEngineWorkletProcessorOptions,
+      port?: WorkletPort,
+    ): Promise<void> {
+      try {
+        const initPromise = (
+          globalThis as typeof globalThis & { SonareEmbindInitPromise?: Promise<void> }
+        ).SonareEmbindInitPromise;
+        if (initPromise) {
+          await initPromise;
+        }
+        if (!isInitialized()) {
+          type EmbindModuleFactory = (options?: {
+            locateFile?: (path: string, prefix: string) => string;
+            wasmBinary?: ArrayBuffer | Uint8Array;
+          }) => Promise<SonareModule>;
+          const moduleFactory = (
+            globalThis as typeof globalThis & {
+              SonareEmbindModuleFactory?: EmbindModuleFactory;
+            }
+          ).SonareEmbindModuleFactory;
+          if (!moduleFactory) {
+            throw new Error('embind realtime engine module is not initialized.');
+          }
+          await initSonareModule({
+            locateFile: (path) => path,
+            wasmBinary: options.wasmBinary,
+            moduleFactory,
+          });
+        }
+        this.bridge = new SonareRealtimeEngineWorkletProcessor(options, {
+          postMessage: (message) => port?.postMessage?.(message),
+          onMeter: (meter) => port?.postMessage?.(meter),
+        });
+        for (const message of options.initialSyncMessages ?? []) {
+          this.bridge.receiveSync(message);
+        }
+        for (const command of options.initialCommands ?? []) {
+          this.bridge.receiveCommand(command);
+        }
+        this.replayPendingMessages(port);
+        port?.postMessage?.({ type: 'ready', runtimeTarget: 'embind' });
+      } catch (error) {
+        port?.postMessage?.({
+          type: 'error',
+          message: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
     private async initializeSonareRt(
       options: SonareRealtimeEngineWorkletProcessorOptions,
       port?: WorkletPort,
@@ -2857,6 +3627,7 @@ export function registerSonareRealtimeEngineWorkletProcessor(
           telemetrySharedBuffer: options.telemetrySharedBuffer,
           telemetryRingCapacity: options.telemetryRingCapacity,
         });
+        this.replayPendingMessages(port);
         port?.postMessage?.({ type: 'ready', runtimeTarget: 'sonare-rt' });
       } catch (error) {
         port?.postMessage?.({