@libraz/libsonare 1.3.2 → 1.4.0

package/dist/worklet.d.ts

@@ -1,9 +1,16 @@
-import { ProgressCallback, WasmNnlsChromaResult, WasmFourierTempogramResult, WasmCyclicTempogramResult, WasmFrameResult, WasmTempogramResult, WasmTrimResult, WasmDecomposeResult, WasmHpssWithResidualResult, WasmLufsResult, WasmMatrix2dResult, WasmEngineAutomationPoint, WasmEngineBounceOptions, WasmEngineBounceResult, WasmEngineCaptureStatus, WasmEngineClip, WasmEngineFreezeOptions, WasmEngineFreezeResult, WasmEngineGraphSpec, WasmEngineMarker, WasmEngineMeterTelemetry, WasmEngineMetronomeConfig, WasmEngineParameterInfo, WasmEngineTelemetry, WasmEngineTransportState, WasmClipPageRequest, WasmEngineProcessWithMonitorResult } from './sonare.js';
+import { ProgressCallback, WasmNnlsChromaResult, WasmFourierTempogramResult, WasmCyclicTempogramResult, WasmFrameResult, WasmTempogramResult, WasmTrimResult, WasmDecomposeResult, WasmHpssWithResidualResult, WasmLufsResult, WasmMatrix2dResult, WasmEngineAutomationPoint, WasmEngineBounceOptions, WasmEngineBounceResult, WasmEngineCaptureStatus, WasmEngineClip, WasmEngineFreezeOptions, WasmEngineFreezeResult, WasmEngineGraphSpec, WasmEngineMarker, WasmEngineMeterTelemetry, WasmEngineMeterTelemetryWide, WasmEngineMetronomeConfig, WasmEngineParameterInfo, WasmEngineScopeTelemetry, WasmEngineTelemetry, WasmEngineTempoSegment, WasmEngineTimeSignatureSegment, WasmEngineTransportState, WasmClipPageRequest, WasmEngineProcessWithMonitorResult, SonareModule } from './sonare.js';
 
 /**
  * Per-call validation options accepted by guarded wrappers. Empty-buffer
  * checks are always performed; pass `{ validate: false }` to opt out of the
  * O(n) NaN/Inf scan on hot paths.
+ *
+ * `{ validate: false }` only skips this JS-side pre-scan (which raises a
+ * `RangeError` naming the exact offending index). It is NOT a way to push
+ * non-finite samples into the core: the native layer always re-validates the
+ * buffer (see `validate_offline_audio_input` in the C++ core), matching the C
+ * ABI / Node / Python surfaces, so an NaN/Inf buffer still throws — just with a
+ * generic native message instead of the indexed JS one.
  */
 interface ValidateOptions {
     validate?: boolean;
@@ -227,6 +234,36 @@ interface NoteStretchOptions {
     /** Stretch ratio (0.5 = double duration, 2.0 = half duration). Default 1. */
     stretchRatio?: number;
 }
+/** How a `spectralEdit` region op modifies the masked bins. */
+type SpectralEditMode = 'gain' | 'attenuate' | 'mute' | 'heal';
+/** Analysis/synthesis window used by `spectralEdit`. */
+type SpectralEditWindow = 'hann' | 'hamming' | 'blackman' | 'rectangular';
+/** One time x frequency rectangle edit op for `spectralEdit`. */
+interface SpectralRegionOp {
+    /** Region time start (input samples); clamped to [0, length]. Default 0. */
+    startSample?: number;
+    /** Region time end, exclusive (input samples); clamped to [0, length]. Default = signal length. */
+    endSample?: number;
+    /** Region frequency low edge in Hz; clamped to [0, nyquist]. Default 0. */
+    lowHz?: number;
+    /** Region frequency high edge in Hz; <=0 or >= nyquist means nyquist. Default 0. */
+    highHz?: number;
+    /** Linear gain in dB for 'gain'/'attenuate'; ignored by 'mute'/'heal'. Default 0. */
+    gainDb?: number;
+    /** Edit mode. Default 'gain'. */
+    mode?: SpectralEditMode;
+}
+/** STFT + heal parameters for `spectralEdit`. All fields are optional. */
+interface SpectralEditOptions {
+    /** FFT size; must be a power of two (>= 2). Default 2048. */
+    nFft?: number;
+    /** Hop length; must satisfy 0 < hop <= nFft/2. Default 512. */
+    hopLength?: number;
+    /** Analysis + synthesis window. Default 'hann'. */
+    window?: SpectralEditWindow;
+    /** Neighbour frames each side used by 'heal' (>= 1). Default 2. */
+    healRadiusFrames?: number;
+}
 /**
  * Detected beat
  */
@@ -490,6 +527,23 @@ interface MasteringResult {
 }
 type MasteringProcessorParams = Record<string, number | boolean>;
 type PanMode = 'balance' | 'stereoPan' | 'stereo-pan' | 'dualPan' | 'dual-pan' | number;
+/**
+ * Surround pan position for a strip feeding a >2-channel bus. Phase 1 honors
+ * `azimuth`/`divergence`/`lfe`; `elevation`/`distance` are reserved. All fields
+ * are optional and default to a centered point source.
+ */
+interface SurroundPan {
+    /** -180..180 deg, 0 = front-center, positive = right. */
+    azimuth?: number;
+    /** Reserved (no height beds in phase 1). */
+    elevation?: number;
+    /** 0 = point source, 1 = spread across the front. */
+    divergence?: number;
+    /** 0..1 scalar send into the LFE plane. */
+    lfe?: number;
+    /** Reserved (focus/spread), defaults to 1. */
+    distance?: number;
+}
 interface MixOptions {
     inputTrimDb?: number | number[];
     faderDb?: number | number[];
@@ -1079,6 +1133,21 @@ declare function voiceChangeRealtime(samples: Float32Array, options?: VoiceChang
  * @returns Normalized audio
  */
 declare function normalize(samples: Float32Array, sampleRate: number, targetDb?: number, options?: ValidateOptions): Float32Array;
+/**
+ * Apply region-based spectral edits (gain/attenuate/mute/heal) to mono audio.
+ *
+ * Each op is a time x frequency rectangle applied in array order over a single
+ * STFT buffer, so a later op observes the result of earlier ops. The output has
+ * the same length and sample rate as the input; an empty `ops` list is an
+ * identity transform (within the iSTFT's own tolerance).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param ops - Region edit ops applied in order ({@link SpectralRegionOp})
+ * @param options - STFT + heal configuration ({@link SpectralEditOptions})
+ * @returns Edited audio
+ */
+declare function spectralEdit(samples: Float32Array, sampleRate: number, ops?: SpectralRegionOp[], options?: SpectralEditOptions & ValidateOptions): Float32Array;
 /**
  * Apply mastering loudness normalization with a true-peak ceiling.
  *
@@ -1106,6 +1175,62 @@ declare function masteringInsertNames(): string[];
  * @param name - Insert processor name (see {@link masteringInsertNames}).
  */
 declare function masteringInsertParamNames(name: string): string[];
+/** One realtime-automatable parameter of an insert processor. */
+interface MasteringInsertParamInfo {
+    /** JSON-key parameter name, as used in scene insert params. */
+    name: string;
+    /** Integer param id for realtime automation lanes / MIDI-CC binding. */
+    id: number;
+    /** Whether the param can be changed live from the audio thread. */
+    rtSafe: boolean;
+}
+/**
+ * Returns the realtime-automatable parameter descriptors for an insert / FX
+ * processor: each entry maps a JSON-key parameter name to the integer id used by
+ * realtime automation and reports whether it is realtime-safe. Unlike
+ * {@link masteringInsertParamNames} (every construction key), this lists only the
+ * realtime-controllable subset — the keys accepted by
+ * {@link RealtimeEngine.setTrackStripInsertParamByName}. Returns an empty array
+ * for an unknown name or a processor with no automatable parameters.
+ *
+ * @param name - Insert processor name (see {@link masteringInsertNames}).
+ */
+declare function masteringInsertParamInfo(name: string): MasteringInsertParamInfo[];
+/**
+ * How a processor handles a buffer with more than two channels (a surround
+ * bed). "multichannel" processes every plane in one call; "stereoPairOnly"
+ * operates on the front L/R pair and passes any surround planes through dry.
+ * "perChannel"/"passthrough" are reserved and unused by the current catalog.
+ */
+type MasteringChannelPolicy = 'multichannel' | 'stereoPairOnly' | 'perChannel' | 'passthrough';
+/** One processor's realtime/offline/pair classification in the catalog. */
+interface MasteringProcessorCatalogEntry {
+    /** Processor id (the name used for scene inserts / named processors). */
+    id: string;
+    /**
+     * Primary classification, by precedence pair > realtime > offline: "pair" for
+     * two-input match.* processors, "realtime" for ids that build as a realtime
+     * scene insert, "offline" for whole-file-only processors.
+     */
+    kind: 'realtime' | 'offline' | 'pair';
+    /** True exactly for ids that always succeed as a realtime scene insert. */
+    realtimeInsertable: boolean;
+    /** True for processors with no mono implementation (stereo-only). */
+    stereoOnly: boolean;
+    /**
+     * How the mixer wraps the processor on a >2-channel (surround) bus insert:
+     * "multichannel" (one full-buffer call) or "stereoPairOnly" (front L/R pair,
+     * surround planes passed through dry).
+     */
+    channelPolicy: MasteringChannelPolicy;
+}
+/**
+ * Returns the machine-readable classification catalog for every named processor
+ * id, merging the offline registry, the realtime insert factory, and the pair
+ * registry. Lets a host filter a processor picker by realtime insertability
+ * instead of offering ids the realtime strip would reject.
+ */
+declare function masteringProcessorCatalog(): MasteringProcessorCatalogEntry[];
 declare function masteringPairProcessorNames(): PairProcessor[];
 declare function masteringPairAnalysisNames(): PairAnalysis[];
 declare function masteringStereoAnalysisNames(): StereoAnalysis[];
@@ -1670,7 +1795,9 @@ declare function tempogramRatio(tempogramData: Float32Array, winLength?: number,
  * Measure loudness (EBU R128 / ITU-R BS.1770).
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param sampleRate - Sample rate in Hz. The default (22050) is non-standard for
+ *   audio; pass the buffer's actual rate, as K-weighting is sample-rate
+ *   dependent and a wrong rate yields wrong loudness.
  * @returns Loudness measurement result
  */
 declare function lufs(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): LufsResult;
@@ -1678,7 +1805,8 @@ declare function lufs(samples: Float32Array, sampleRate?: number, options?: Vali
  * Compute the momentary loudness (LUFS) over time.
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param sampleRate - Sample rate in Hz. The default (22050) is non-standard and
+ *   K-weighting is sample-rate dependent; pass the buffer's actual rate.
  * @returns Momentary LUFS values over time
  */
 declare function momentaryLufs(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): Float32Array;
@@ -1686,7 +1814,8 @@ declare function momentaryLufs(samples: Float32Array, sampleRate?: number, optio
  * Compute the short-term loudness (LUFS) over time.
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param sampleRate - Sample rate in Hz. The default (22050) is non-standard and
+ *   K-weighting is sample-rate dependent; pass the buffer's actual rate.
  * @returns Short-term LUFS values over time
  */
 declare function shortTermLufs(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): Float32Array;
@@ -1883,10 +2012,16 @@ declare function hpssWithResidual(samples: Float32Array, sampleRate?: number, ke
  * Channel-weighted multichannel integrated loudness + LRA (ITU-R BS.1770 /
  * EBU R128) from an interleaved buffer of `frames * channels` samples. The
  * per-channel frame count is derived from the buffer length and `channels`.
+ *
+ * Pass the buffer's actual `sampleRate`: the default (22050) is non-standard for
+ * audio, and K-weighting is sample-rate dependent, so a wrong rate yields wrong
+ * loudness.
  */
 declare function lufsInterleaved(samples: Float32Array, channels: number, sampleRate?: number, options?: ValidateOptions): WasmLufsResult;
 /**
- * Standards-compliant EBU R128 loudness range (LRA) in LU.
+ * Standards-compliant EBU R128 loudness range (LRA) in LU. Pass the buffer's
+ * actual `sampleRate`: the default (22050) is non-standard and K-weighting is
+ * sample-rate dependent.
  */
 declare function ebur128LoudnessRange(samples: Float32Array, sampleRate?: number): number;
 /**
@@ -2097,6 +2232,9 @@ declare function mfccToAudio(mfccCoefficients: Float32Array, nMfcc: number, nFra
  */
 declare function chroma(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, options?: GuardedOptions$1): ChromaResult;
 
+type WorkletInput = readonly (readonly Float32Array[])[];
+type WorkletOutput = Float32Array[][];
+
 interface SonareRtModule {
   _malloc(size: number): number;
   _free(ptr: number): void;
@@ -2154,133 +2292,31 @@ interface SonareRtModule {
   ): number;
 }
 
-interface SonareWorkletProcessorOptions {
-    sceneJson: string;
-    sampleRate?: number;
-    blockSize?: number;
-    stripCount?: number;
-    meterIntervalFrames?: number;
-    meterSharedBuffer?: SharedArrayBuffer;
-    meterRingCapacity?: number;
-    spectrumIntervalFrames?: number;
-    spectrumBands?: number;
-    spectrumSharedBuffer?: SharedArrayBuffer;
-    spectrumRingCapacity?: number;
-}
-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;
-}
-interface SonareRealtimeVoiceChangerWorkletProcessorOptions {
-    preset?: RealtimeVoiceChangerConfigInput;
-    sampleRate?: number;
-    blockSize?: number;
-    channelCount?: number;
-}
-interface SonareRealtimeVoiceChangerSetConfigMessage {
-    type: 'setConfig';
-    preset: RealtimeVoiceChangerConfigInput;
-}
-interface SonareRealtimeVoiceChangerResetMessage {
-    type: 'reset';
-}
-interface SonareRealtimeVoiceChangerDestroyMessage {
-    type: 'destroy';
-}
-type SonareRealtimeVoiceChangerMessage = SonareRealtimeVoiceChangerSetConfigMessage | SonareRealtimeVoiceChangerResetMessage | SonareRealtimeVoiceChangerDestroyMessage;
-interface SonareRealtimeEngineNodeCapabilities {
-    mode: 'sab' | 'postMessage';
-    runtimeTarget: 'embind' | 'sonare-rt';
-    sharedArrayBuffer: boolean;
-    atomics: boolean;
-    audioWorklet: boolean;
-    engineAbiVersion?: number;
-    expectedEngineAbiVersion?: number;
-    abiCompatible?: boolean;
-    degradedReason?: string;
-}
-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;
-}
-interface SonareRtRealtimeEngineRuntimeOptions {
-    module: SonareRtModule;
-    memory: WebAssembly.Memory;
-    sampleRate?: number;
-    blockSize?: number;
-    channelCount?: number;
-    commandSharedBuffer?: SharedArrayBuffer;
-    commandRingCapacity?: number;
-    telemetrySharedBuffer?: SharedArrayBuffer;
-    telemetryRingCapacity?: number;
-}
-interface SonareEngineOptions extends SonareRealtimeEngineNodeOptions {
-    offlineEngine?: RealtimeEngine;
-    offlineBlockSize?: number;
-    offlineChannelCount?: number;
-}
-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 WorkletInput = readonly (readonly Float32Array[])[];
-type WorkletOutput = Float32Array[][];
-interface SonareWorkletScheduleInsertAutomationMessage {
-    type: 'scheduleInsertAutomation';
-    stripIndex: number;
-    insertIndex: number;
-    paramId: number;
-    value: number;
-    samplePos?: number;
-    curve?: AutomationCurve;
-}
-interface SonareWorkletSetMeterIntervalMessage {
-    type: 'setMeterInterval';
-    frames: number;
-}
-interface SonareWorkletDestroyMessage {
-    type: 'destroy';
-}
-type SonareWorkletMessage = SonareWorkletScheduleInsertAutomationMessage | SonareWorkletSetMeterIntervalMessage | SonareWorkletDestroyMessage;
 interface SonareWorkletMeterSnapshot {
     type: 'meter';
+    targetId: number;
     frame: number;
     peakDbL: number;
     peakDbR: number;
     rmsDbL: number;
     rmsDbR: number;
     correlation: number;
+    truePeakDbL: number;
+    truePeakDbR: number;
+    momentaryLufs: number;
+    shortTermLufs: number;
+    integratedLufs: number;
+    gainReductionDb: number;
 }
 interface SonareWorkletSpectrumSnapshot {
     type: 'spectrum';
     frame: number;
     bands: Float32Array;
 }
-type SonareWorkletTransportMessage = SonareWorkletMeterSnapshot | SonareWorkletSpectrumSnapshot | SonareEngineTelemetryRecord;
 declare const SONARE_METER_RING_HEADER_INTS = 4;
-declare const SONARE_METER_RING_RECORD_FLOATS = 7;
+declare const SONARE_METER_RING_RECORD_FLOATS = 14;
 declare const SONARE_SPECTRUM_RING_HEADER_INTS = 5;
+declare const SONARE_SCOPE_RING_HEADER_INTS = 6;
 /** Low 24 bits of a frame index (exact in Float32). */
 declare function encodeFrameLo(frame: number): number;
 /** High bits of a frame index above 2^24 (exact in Float32 up to ~2^48). */
@@ -2330,11 +2366,6 @@ declare enum SonareEngineTelemetryError {
     StaleAutomationLanes = 12,
     SmoothedParameterCapacity = 13
 }
-interface WorkletTransport {
-    postMessage?: (message: SonareWorkletTransportMessage) => void;
-    onMeter?: (meter: SonareWorkletMeterSnapshot) => void;
-    onSpectrum?: (spectrum: SonareWorkletSpectrumSnapshot) => void;
-}
 interface SonareMeterRingBuffer {
     sharedBuffer: SharedArrayBuffer;
     header: Int32Array;
@@ -2356,6 +2387,34 @@ interface SonareSpectrumRingReadResult {
     nextReadIndex: number;
     spectra: SonareWorkletSpectrumSnapshot[];
 }
+/**
+ * A single target-addressed scope record drained from the realtime engine's
+ * scope ring: an FFT magnitude spectrum plus a decimated goniometer/vectorscope
+ * point cloud. Unlike {@link SonareWorkletSpectrumSnapshot} (the legacy
+ * coarse-DFT meter spectrum), this carries a `targetId` (master/lane/bus) and a
+ * stereo point cloud, mirroring the engine's `ScopeTelemetryRecord`.
+ */
+interface SonareWorkletScopeSnapshot {
+    type: 'scope';
+    targetId: number;
+    frame: number;
+    /** Linear-band magnitudes in dB (length = the configured band count). */
+    bands: Float32Array;
+    /** Interleaved stereo goniometer points: [l0, r0, l1, r1, ...]. */
+    points: Float32Array;
+}
+interface SonareScopeRingBuffer {
+    sharedBuffer: SharedArrayBuffer;
+    header: Int32Array;
+    records: Float32Array;
+    capacity: number;
+    bands: number;
+    maxPoints: number;
+}
+interface SonareScopeRingReadResult {
+    nextReadIndex: number;
+    scopes: SonareWorkletScopeSnapshot[];
+}
 interface SonareEngineCommandRecord {
     type: SonareEngineCommandType | number;
     targetId?: number;
@@ -2363,24 +2422,6 @@ interface SonareEngineCommandRecord {
     argFloat?: number;
     argInt?: number | bigint;
 }
-interface SonareEngineSyncClipsMessage {
-    type: 'syncClips';
-    clips: EngineClip[];
-}
-interface SonareEngineSyncMarkersMessage {
-    type: 'syncMarkers';
-    markers: EngineMarker[];
-}
-interface SonareEngineSyncMetronomeMessage {
-    type: 'syncMetronome';
-    config: EngineMetronomeConfig;
-}
-interface SonareEngineSyncAutomationMessage {
-    type: 'syncAutomation';
-    paramId: number;
-    points: EngineAutomationPoint[];
-}
-type SonareEngineSyncMessage = SonareEngineSyncClipsMessage | SonareEngineSyncMarkersMessage | SonareEngineSyncMetronomeMessage | SonareEngineSyncAutomationMessage;
 interface SonareEngineTelemetryRecord {
     type: SonareEngineTelemetryType | number;
     error: SonareEngineTelemetryError | number;
@@ -2412,6 +2453,9 @@ declare function readSonareMeterRingBuffer(ring: SonareMeterRingBuffer, readInde
 declare function sonareSpectrumRingBufferByteLength(capacity: number, bands?: number): number;
 declare function createSonareSpectrumRingBuffer(capacity?: number, bands?: number): SonareSpectrumRingBuffer;
 declare function readSonareSpectrumRingBuffer(ring: SonareSpectrumRingBuffer, readIndex?: number): SonareSpectrumRingReadResult;
+declare function sonareScopeRingBufferByteLength(capacity: number, bands?: number, maxPoints?: number): number;
+declare function createSonareScopeRingBuffer(capacity?: number, bands?: number, maxPoints?: number): SonareScopeRingBuffer;
+declare function readSonareScopeRingBuffer(ring: SonareScopeRingBuffer, readIndex?: number): SonareScopeRingReadResult;
 declare function sonareEngineCommandRingBufferByteLength(capacity: number): number;
 declare function sonareEngineTelemetryRingBufferByteLength(capacity: number): number;
 declare function createSonareEngineCommandRingBuffer(capacity?: number): SonareEngineCommandRingBuffer;
@@ -2420,6 +2464,343 @@ declare function pushSonareEngineCommandRingBuffer(ring: SonareEngineCommandRing
 declare function popSonareEngineCommandRingBuffer(ring: SonareEngineCommandRingBuffer): SonareEngineCommandRecord | null;
 declare function writeSonareEngineTelemetryRingBuffer(ring: SonareEngineTelemetryRingBuffer, telemetry: SonareEngineTelemetryRecord): void;
 declare function readSonareEngineTelemetryRingBuffer(ring: SonareEngineTelemetryRingBuffer, readIndex?: number): SonareEngineTelemetryRingReadResult;
+
+interface SonareWorkletProcessorOptions {
+    sceneJson: string;
+    sampleRate?: number;
+    blockSize?: number;
+    stripCount?: number;
+    meterIntervalFrames?: number;
+    meterSharedBuffer?: SharedArrayBuffer;
+    meterRingCapacity?: number;
+    spectrumIntervalFrames?: number;
+    spectrumBands?: number;
+    spectrumSharedBuffer?: SharedArrayBuffer;
+    spectrumRingCapacity?: number;
+}
+interface SonareRealtimeEngineWorkletProcessorOptions {
+    runtimeTarget?: 'embind' | 'sonare-rt';
+    rtModuleUrl?: string;
+    rtWasmBinary?: ArrayBuffer | Uint8Array;
+    wasmBinary?: ArrayBuffer | Uint8Array;
+    initialSyncMessages?: SonareEngineSyncMessage[];
+    initialCommands?: SonareEngineCommandRecord[];
+    sampleRate?: number;
+    blockSize?: number;
+    channelCount?: number;
+    meterIntervalFrames?: number;
+    commandSharedBuffer?: SharedArrayBuffer;
+    commandRingCapacity?: number;
+    telemetrySharedBuffer?: SharedArrayBuffer;
+    telemetryRingCapacity?: number;
+    meterSharedBuffer?: SharedArrayBuffer;
+    meterRingCapacity?: number;
+    scopeIntervalFrames?: number;
+    scopeBands?: number;
+    scopeSharedBuffer?: SharedArrayBuffer;
+    scopeRingCapacity?: number;
+}
+interface SonareRealtimeVoiceChangerWorkletProcessorOptions {
+    preset?: RealtimeVoiceChangerConfigInput;
+    sampleRate?: number;
+    blockSize?: number;
+    channelCount?: number;
+}
+interface SonareRealtimeVoiceChangerSetConfigMessage {
+    type: 'setConfig';
+    preset: RealtimeVoiceChangerConfigInput;
+}
+interface SonareRealtimeVoiceChangerResetMessage {
+    type: 'reset';
+}
+interface SonareRealtimeVoiceChangerDestroyMessage {
+    type: 'destroy';
+}
+type SonareRealtimeVoiceChangerMessage = SonareRealtimeVoiceChangerSetConfigMessage | SonareRealtimeVoiceChangerResetMessage | SonareRealtimeVoiceChangerDestroyMessage;
+interface SonareRealtimeEngineNodeCapabilities {
+    mode: 'sab' | 'postMessage';
+    runtimeTarget: 'embind' | 'sonare-rt';
+    sharedArrayBuffer: boolean;
+    atomics: boolean;
+    audioWorklet: boolean;
+    engineAbiVersion?: number;
+    expectedEngineAbiVersion?: number;
+    abiCompatible?: boolean;
+    degradedReason?: string;
+    readyMessage?: boolean;
+}
+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;
+}
+interface SonareRtRealtimeEngineRuntimeOptions {
+    module: SonareRtModule;
+    memory: WebAssembly.Memory;
+    sampleRate?: number;
+    blockSize?: number;
+    channelCount?: number;
+    commandSharedBuffer?: SharedArrayBuffer;
+    commandRingCapacity?: number;
+    telemetrySharedBuffer?: SharedArrayBuffer;
+    telemetryRingCapacity?: number;
+}
+interface SonareEngineTransportFacade {
+    play(sampleTime?: number): boolean;
+    stop(sampleTime?: number): boolean;
+    seekPpq(ppq: number, sampleTime?: number): boolean;
+    seekSeconds(seconds: number, sampleTime?: number): boolean;
+    setTempo(bpm: number): void;
+    setTempoSegments(segments: readonly EngineTempoSegment[]): void;
+    setLoop(startPpq: number, endPpq: number, enabled?: boolean): boolean;
+}
+interface SonareWorkletScheduleInsertAutomationMessage {
+    type: 'scheduleInsertAutomation';
+    stripIndex: number;
+    insertIndex: number;
+    paramId: number;
+    value: number;
+    samplePos?: number;
+    curve?: AutomationCurve;
+}
+interface SonareWorkletSetMeterIntervalMessage {
+    type: 'setMeterInterval';
+    frames: number;
+}
+interface SonareWorkletDestroyMessage {
+    type: 'destroy';
+}
+type SonareWorkletMessage = SonareWorkletScheduleInsertAutomationMessage | SonareWorkletSetMeterIntervalMessage | SonareWorkletDestroyMessage;
+type SonareWorkletTransportMessage = SonareWorkletMeterSnapshot | SonareWorkletSpectrumSnapshot | SonareEngineTelemetryRecord;
+interface WorkletTransport {
+    postMessage?: (message: SonareWorkletTransportMessage | SonareEngineCaptureResponseMessage | SonareEngineTransportResponseMessage, transfer?: Transferable[]) => void;
+    onMeter?: (meter: SonareWorkletMeterSnapshot) => void;
+    onSpectrum?: (spectrum: SonareWorkletSpectrumSnapshot) => void;
+}
+interface SonareEngineSyncClipsMessage {
+    type: 'syncClips';
+    clips: EngineClip[];
+}
+interface SonareEngineSyncClipsDeltaMessage {
+    type: 'syncClipsDelta';
+    upserts: EngineClip[];
+    removeIds: number[];
+}
+interface SonareEngineSyncMidiClipsMessage {
+    type: 'syncMidiClips';
+    clips: EngineMidiClipSchedule[];
+}
+interface SonareEngineSyncMarkersMessage {
+    type: 'syncMarkers';
+    markers: EngineMarker[];
+}
+interface SonareEngineSyncMetronomeMessage {
+    type: 'syncMetronome';
+    config: EngineMetronomeConfig;
+}
+interface SonareEngineSyncAutomationMessage {
+    type: 'syncAutomation';
+    paramId: number;
+    points: EngineAutomationPoint[];
+}
+interface SonareEngineSyncTempoMessage {
+    type: 'syncTempo';
+    bpm: number;
+    timeSignature: {
+        numerator: number;
+        denominator: number;
+    };
+    tempoSegments?: EngineTempoSegment[];
+    timeSignatureSegments?: EngineTimeSignatureSegment[];
+}
+interface SonareEngineSyncMixerMessage {
+    type: 'syncMixer';
+    lanes: EngineTrackLane[];
+    buses?: EngineBus[];
+    trackStrips?: Array<{
+        trackId: number;
+        sceneJson: string;
+    }>;
+    busStrips?: Array<{
+        busId: number;
+        sceneJson: string;
+    }>;
+    masterStripJson?: string;
+    /** Lane insert sidechain bindings (replayed after lanes/strips). */
+    laneSidechains?: Array<{
+        trackId: number;
+        insertIndex: number;
+        sourceTrackId: number;
+    }>;
+}
+interface SonareEngineSyncCaptureMessage {
+    type: 'syncCapture';
+    bufferFrames: number;
+    channels: number;
+    source: EngineCaptureStatus['source'];
+    recordOffsetSamples: number;
+    inputMonitor: {
+        enabled: boolean;
+        gain: number;
+    };
+}
+interface SonareEngineSyncTrackStripEqBandMessage {
+    type: 'syncTrackStripEqBand';
+    trackId: number;
+    bandIndex: number;
+    bandJson: string;
+}
+interface SonareEngineSyncMasterStripEqBandMessage {
+    type: 'syncMasterStripEqBand';
+    bandIndex: number;
+    bandJson: string;
+}
+interface SonareEngineSyncTrackStripInsertBypassedMessage {
+    type: 'syncTrackStripInsertBypassed';
+    trackId: number;
+    insertIndex: number;
+    bypassed: boolean;
+    resetOnBypass: boolean;
+}
+interface SonareEngineSyncMasterStripInsertBypassedMessage {
+    type: 'syncMasterStripInsertBypassed';
+    insertIndex: number;
+    bypassed: boolean;
+    resetOnBypass: boolean;
+}
+interface SonareEngineSyncTrackStripInsertParamByNameMessage {
+    type: 'syncTrackStripInsertParamByName';
+    trackId: number;
+    insertIndex: number;
+    paramName: string;
+    value: number;
+}
+interface SonareEngineSyncMasterStripInsertParamByNameMessage {
+    type: 'syncMasterStripInsertParamByName';
+    insertIndex: number;
+    paramName: string;
+    value: number;
+}
+interface SonareEngineSyncTrackStripPanMessage {
+    type: 'syncTrackStripPan';
+    trackId: number;
+    pan: number;
+}
+interface SonareEngineSyncTrackStripPanLawMessage {
+    type: 'syncTrackStripPanLaw';
+    trackId: number;
+    panLaw: number;
+}
+interface SonareEngineSyncTrackStripPanModeMessage {
+    type: 'syncTrackStripPanMode';
+    trackId: number;
+    panMode: number;
+}
+interface SonareEngineSyncTrackStripDualPanMessage {
+    type: 'syncTrackStripDualPan';
+    trackId: number;
+    leftPan: number;
+    rightPan: number;
+}
+interface SonareEngineSyncTrackStripChannelDelaySamplesMessage {
+    type: 'syncTrackStripChannelDelaySamples';
+    trackId: number;
+    delaySamples: number;
+}
+interface SonareEngineSyncBuiltinInstrumentMessage {
+    type: 'syncBuiltinInstrument';
+    destinationId: number;
+    config: {
+        destinationId?: number;
+    } & Record<string, unknown>;
+}
+interface SonareEngineSyncSynthInstrumentMessage {
+    type: 'syncSynthInstrument';
+    destinationId: number;
+    patch: Record<string, unknown> | string;
+}
+interface SonareEngineSyncSf2InstrumentMessage {
+    type: 'syncSf2Instrument';
+    destinationId: number;
+    config: {
+        destinationId?: number;
+        gain?: number;
+        polyphony?: number;
+    };
+}
+interface SonareEngineSyncLoadSoundFontMessage {
+    type: 'syncLoadSoundFont';
+    data: Uint8Array;
+}
+interface SonareEngineSyncMidiNoteMessage {
+    type: 'syncMidiNoteOn' | 'syncMidiNoteOff';
+    destinationId: number;
+    group: number;
+    channel: number;
+    note: number;
+    velocity: number;
+    renderFrame: number;
+}
+interface SonareEngineSyncMidiCcMessage {
+    type: 'syncMidiCc';
+    destinationId: number;
+    group: number;
+    channel: number;
+    controller: number;
+    value: number;
+    renderFrame: number;
+}
+interface SonareEngineSyncMidiPanicMessage {
+    type: 'syncMidiPanic';
+    renderFrame: number;
+}
+type SonareEngineSyncMessage = SonareEngineSyncClipsMessage | SonareEngineSyncClipsDeltaMessage | SonareEngineSyncMidiClipsMessage | SonareEngineSyncMarkersMessage | SonareEngineSyncMetronomeMessage | SonareEngineSyncAutomationMessage | SonareEngineSyncTempoMessage | SonareEngineSyncMixerMessage | SonareEngineSyncCaptureMessage | SonareEngineSyncTrackStripEqBandMessage | SonareEngineSyncMasterStripEqBandMessage | SonareEngineSyncTrackStripInsertBypassedMessage | SonareEngineSyncMasterStripInsertBypassedMessage | SonareEngineSyncTrackStripInsertParamByNameMessage | SonareEngineSyncMasterStripInsertParamByNameMessage | SonareEngineSyncTrackStripPanMessage | SonareEngineSyncTrackStripPanLawMessage | SonareEngineSyncTrackStripPanModeMessage | SonareEngineSyncTrackStripDualPanMessage | SonareEngineSyncTrackStripChannelDelaySamplesMessage | SonareEngineSyncBuiltinInstrumentMessage | SonareEngineSyncSynthInstrumentMessage | SonareEngineSyncSf2InstrumentMessage | SonareEngineSyncLoadSoundFontMessage | SonareEngineSyncMidiNoteMessage | SonareEngineSyncMidiCcMessage | SonareEngineSyncMidiPanicMessage;
+interface WorkletPort {
+    postMessage?: (message: unknown, transfer?: Transferable[]) => void;
+    onmessage?: (event: {
+        data: unknown;
+    }) => void;
+    addEventListener?: (type: 'message', listener: (event: {
+        data: unknown;
+    }) => void) => void;
+    start?: () => void;
+}
+interface SonareEngineCaptureRequestMessage {
+    type: 'captureRequest';
+    requestId: number;
+    op: 'status' | 'read' | 'reset';
+}
+interface SonareEngineCaptureResponseMessage {
+    type: 'captureResponse';
+    requestId: number;
+    ok: boolean;
+    status?: EngineCaptureStatus;
+    channels?: Float32Array[] | number[][];
+    error?: string;
+}
+interface SonareEngineTransportRequestMessage {
+    type: 'transportRequest';
+    requestId: number;
+    op: 'state';
+}
+interface SonareEngineTransportResponseMessage {
+    type: 'transportResponse';
+    requestId: number;
+    ok: boolean;
+    state?: EngineTransportState;
+    error?: string;
+}
+
+interface SonareEngineOptions extends SonareRealtimeEngineNodeOptions {
+    offlineEngine?: RealtimeEngine;
+    offlineBlockSize?: number;
+    offlineChannelCount?: number;
+}
 /**
  * AudioWorklet-style mixer bridge backed by the package's single `sonare.wasm`.
  *
@@ -2471,16 +2852,20 @@ declare class SonareRealtimeEngineWorkletProcessor {
     private commandRing?;
     private telemetryRing?;
     private meterRing?;
+    private scopeRing?;
     private transport?;
     private meterIntervalFrames;
     private lastMeterFrame;
     private metronomeConfig;
     private channelBuffers;
+    private readonly liveClips;
     constructor(options?: SonareRealtimeEngineWorkletProcessorOptions, transport?: WorkletTransport);
     process(inputs: WorkletInput, outputs: WorkletOutput): boolean;
     private reacquireChannelBuffers;
     receiveCommand(command: SonareEngineCommandRecord): void;
     receiveSync(message: SonareEngineSyncMessage): void;
+    receiveCaptureRequest(message: SonareEngineCaptureRequestMessage): void;
+    receiveTransportRequest(message: SonareEngineTransportRequestMessage): void;
     destroy(): void;
     private drainCommands;
     private applyCommand;
@@ -2488,6 +2873,8 @@ declare class SonareRealtimeEngineWorkletProcessor {
     private publishTelemetryRecord;
     private publishMeters;
     private writeMeterRing;
+    private publishScope;
+    private writeScopeRing;
     private commandRingFromSharedBuffer;
     private telemetryRingFromSharedBuffer;
 }
@@ -2510,6 +2897,8 @@ declare class SonareRtRealtimeEngineRuntime {
     process(inputs: WorkletInput, outputs: WorkletOutput): boolean;
     receiveCommand(command: SonareEngineCommandRecord): void;
     receiveSync(message: SonareEngineSyncMessage): void;
+    receiveCaptureRequest(message: SonareEngineCaptureRequestMessage, port?: WorkletPort): void;
+    receiveTransportRequest(message: SonareEngineTransportRequestMessage, port?: WorkletPort): void;
     destroy(): void;
     private writeChannelPointers;
     private drainCommands;
@@ -2524,11 +2913,18 @@ declare class SonareRealtimeEngineNode {
     readonly commandRing?: SonareEngineCommandRingBuffer;
     readonly telemetryRing?: SonareEngineTelemetryRingBuffer;
     readonly meterRing?: SonareMeterRingBuffer;
+    readonly scopeRing?: SonareScopeRingBuffer;
     readonly ready: Promise<void>;
     private telemetryReadIndex;
     private meterReadIndex;
+    private scopeReadIndex;
     private telemetryListeners;
     private meterListeners;
+    private scopeListeners;
+    private captureRequestId;
+    private readonly captureRequests;
+    private transportRequestId;
+    private readonly transportRequests;
     private resolveReady;
     private rejectReady;
     private destroyed;
@@ -2539,13 +2935,22 @@ declare class SonareRealtimeEngineNode {
     seekSample(timelineSample: number, sampleTime?: number): boolean;
     seekPpq(ppq: number, sampleTime?: number): boolean;
     sendCommand(command: SonareEngineCommandRecord): boolean;
+    requestCaptureStatus(): Promise<EngineCaptureStatus>;
+    requestCapturedAudio(): Promise<Float32Array[]>;
+    requestCaptureReset(): Promise<void>;
+    requestTransportState(): Promise<EngineTransportState>;
     pollTelemetry(): SonareEngineTelemetryRecord[];
     pollMeters(): SonareWorkletMeterSnapshot[];
+    pollScope(): SonareWorkletScopeSnapshot[];
     onTelemetry(callback: (telemetry: SonareEngineTelemetryRecord) => void): () => void;
     onMeter(callback: (meter: SonareWorkletMeterSnapshot) => void): () => void;
+    onScope(callback: (scope: SonareWorkletScopeSnapshot) => void): () => void;
     destroy(): void;
     private emitTelemetry;
     private emitMeter;
+    private emitScope;
+    private sendCaptureRequest;
+    private sendTransportRequest;
 }
 declare class SonareEngine {
     readonly node: AudioWorkletNode;
@@ -2559,41 +2964,207 @@ declare class SonareEngine {
     private readonly offlineChannelCount;
     private readonly automationLanes;
     private readonly clips;
+    private readonly midiClips;
     private readonly markers;
+    private readonly trackLaneIds;
+    private readonly trackSends;
+    private readonly trackOutputBus;
+    private readonly laneSidechains;
+    private readonly buses;
+    private readonly trackStripJson;
+    private readonly busStripJson;
+    private masterStripJson;
+    private captureConfig;
+    private tempoBpm;
+    private timeSignature;
+    private tempoSegments;
+    private timeSignatureSegments;
+    private latestTransportState;
     private nextClipId;
     private nextMarkerId;
+    private transportPlaying;
+    private readonly pendingInstrumentSync;
     private destroyed;
     private constructor();
     static create(context: BaseAudioContext, options?: SonareEngineOptions): Promise<SonareEngine>;
     suspend(): Promise<void>;
     resume(): Promise<void>;
     setTempo(bpm: number): void;
+    setTempoSegments(segments: readonly EngineTempoSegment[]): void;
+    setTimeSignature(numerator: number, denominator: number): void;
+    setTimeSignatureSegments(segments: readonly EngineTimeSignatureSegment[]): void;
     setLoop(startPpq: number, endPpq: number, enabled?: boolean): boolean;
+    countInEndSample(startSample: number, bars: number): number;
+    getTransportState(): Promise<EngineTransportState>;
+    cachedTransportState(): EngineTransportState | undefined;
     setParam(nodeId: string, param: string | number, value: number): boolean;
     scheduleParam(nodeId: string, param: string | number, ppq: number, value: number, curve?: number | 'linear' | 'exponential'): void;
     addAutomationPoint(laneId: string | number, ppq: number, value: number, curve?: number | 'linear' | 'exponential'): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
     listParameters(): EngineParameterInfo[];
     setSoloMute(target: string | number, solo: boolean, mute: boolean): boolean;
+    setStripGain(target: string | number, db: number): boolean;
+    setStripPan(target: string | number, pan: number): boolean;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    setSends(target: string | number, sends: EngineTrackSend[]): void;
+    setTrackBuses(buses: EngineBus[]): void;
+    setBusGain(busId: number, db: number): boolean;
+    setTrackStripJson(target: string | number, sceneJson: string): void;
+    setTrackStripEqBand(target: string | number, bandIndex: number, band: EqBand | string): void;
+    setTrackStripInsertBypassed(target: string | number, insertIndex: number, bypassed: boolean, resetOnBypass?: boolean): void;
+    setTrackStripInsertParamByName(target: string | number, insertIndex: number, paramName: string, value: number): void;
+    setTrackStripPan(target: string | number, pan: number): void;
+    setTrackStripPanLaw(target: string | number, panLaw: PanLaw | number): void;
+    setTrackStripPanMode(target: string | number, panMode: PanMode | number): void;
+    setTrackStripDualPan(target: string | number, leftPan: number, rightPan: number): void;
+    setTrackStripChannelDelaySamples(target: string | number, delaySamples: number): void;
+    setStripEq(target: string | number, bandIndex: number, band: EqBand | string): void;
+    setStripInsertBypassed(target: string | number, insertIndex: number, bypassed: boolean, resetOnBypass?: boolean): void;
+    setStripInserts(target: string | number, sceneJson: string): void;
+    setBusStripJson(busId: number, sceneJson: string): void;
+    setMasterStripJson(sceneJson: string): void;
+    setMasterStripEqBand(bandIndex: number, band: EqBand | string): void;
+    setMasterStripInsertBypassed(insertIndex: number, bypassed: boolean, resetOnBypass?: boolean): void;
+    setMasterStripInsertParamByName(insertIndex: number, paramName: string, value: number): void;
+    setStripInsertParamByName(target: string | number, insertIndex: number, paramName: string, value: number): void;
+    setMasterChain(sceneJson: string): void;
     addClip(trackId: string | number, buffer: Float32Array[], startPpq: number, opts?: Partial<Omit<EngineClip, 'channels' | 'startPpq'>>): number;
     removeClip(clipId: number): void;
+    setMidiClips(clips: readonly EngineMidiClipSchedule[]): void;
+    setBuiltinInstrument(trackId: string | number, config?: {
+        destinationId?: number;
+    } & Record<string, unknown>): void;
+    setSynthInstrument(trackId: string | number, patch?: Record<string, unknown> | string): void;
+    loadSoundFont(data: Uint8Array): void;
+    setSf2Instrument(trackId: string | number, config?: {
+        destinationId?: number;
+        gain?: number;
+        polyphony?: number;
+    }): void;
+    pushMidiNoteOn(trackId: string | number, group: number, channel: number, note: number, velocity: number, renderFrame?: number): void;
+    pushMidiNoteOff(trackId: string | number, group: number, channel: number, note: number, velocity?: number, renderFrame?: number): void;
+    pushMidiCc(trackId: string | number, group: number, channel: number, controller: number, value: number, renderFrame?: number): void;
+    pushMidiPanic(renderFrame?: number): void;
+    configureCapture(options: {
+        bufferFrames: number;
+        channels?: number;
+        source?: EngineCaptureStatus['source'];
+        recordOffsetSamples?: number;
+        inputMonitor?: {
+            enabled: boolean;
+            gain?: number;
+        };
+    }): void;
     armRecord(trackId: string | number, enabled: boolean): boolean;
     punch(inPpq: number, outPpq: number): boolean;
+    captureStatus(): Promise<EngineCaptureStatus>;
+    capturedAudio(): Promise<Float32Array[]>;
+    resetCapture(): Promise<void>;
     setMetronome(opts: EngineMetronomeConfig): void;
     addMarker(ppq: number, name?: string): number;
+    /**
+     * 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[];
+    markerCount(): number;
+    markerByIndex(index: number): EngineMarker;
+    marker(markerId: number): EngineMarker;
     seekMarker(markerId: number): boolean;
+    setLoopFromMarkers(startMarkerId: number, endMarkerId: number): boolean;
     renderOffline(totalFrames: number): Promise<Float32Array[]>;
     onMeter(callback: (meter: SonareWorkletMeterSnapshot) => void): () => void;
+    onScope(callback: (scope: SonareWorkletScopeSnapshot) => void): () => void;
     onTelemetry(callback: (telemetry: SonareEngineTelemetryRecord) => void): () => void;
     pollTelemetry(): SonareEngineTelemetryRecord[];
     pollMeters(): SonareWorkletMeterSnapshot[];
+    pollScope(): SonareWorkletScopeSnapshot[];
     destroy(): void;
-    private syncClips;
+    private syncClipsDelta;
+    private syncMidiClips;
+    private mixerLanes;
+    private syncMixer;
     private syncMarkers;
+    private postInstrumentSync;
+    private flushPendingInstrumentSync;
+    private postTempoSync;
     private postSync;
     private resolveParamId;
     private resolveTargetId;
+    private ensureTrackLane;
+    private ensureBus;
     private curveCode;
-    private ppqToApproxSample;
 }
 declare class SonareRealtimeVoiceChangerWorkletProcessor {
     private static warnedMonoOverflow;
@@ -2829,6 +3400,32 @@ interface ProjectBounceOptions {
     /** Host-instrument PDC (latency) fed to the compiler. */
     instrumentLatencySamples?: number;
 }
+/**
+ * Marker kind ordinals. Mirrors `SonareMarkerKind` in `src/sonare_c_types.h`;
+ * the values are part of the ABI and must not be renumbered.
+ */
+declare const MarkerKind: {
+    readonly marker: 0;
+    readonly text: 1;
+    readonly lyric: 2;
+    readonly cuePoint: 3;
+    readonly keySignature: 4;
+};
+/** A project timeline marker with its kind and (for key signatures) the key. */
+interface ProjectMarker {
+    /** Stable marker id (0 when allocating a new id via {@link Project.setMarkerEx}). */
+    id: number;
+    /** Marker position in PPQ (quarter notes). */
+    ppq: number;
+    /** Marker label. */
+    name?: string;
+    /** {@link MarkerKind} ordinal (default 0 = marker). */
+    kind?: number;
+    /** Key signature only: -7..7 (sharps positive). */
+    keyFifths?: number;
+    /** Key signature only: false = major, true = minor. */
+    keyMinor?: boolean;
+}
 /** Oscillator waveform for the built-in synth. */
 type BuiltinSynthWaveform = 'sine' | 'saw' | 'sawtooth' | 'square' | 'triangle' | 0 | 1 | 2 | 3;
 /**
@@ -3366,6 +3963,14 @@ declare class Project {
      * Routes through an undoable edit command.
      */
     setTrackMidiDestination(trackId: number, destinationId: number): void;
+    /** Set a track's linear playback gain (1.0 = unity; >= 0) via an undoable edit. */
+    setTrackGain(trackId: number, gain: number): void;
+    /** Set a track's mute flag via an undoable edit (a muted track is silent). */
+    setTrackMute(trackId: number, mute: boolean): void;
+    /** Set a track's solo flag via an undoable edit (when any track is soloed, only soloed tracks sound). */
+    setTrackSolo(trackId: number, solo: boolean): void;
+    /** Set a track's stereo balance in [-1, +1] (0 = center) via an undoable edit. */
+    setTrackPan(trackId: number, pan: number): void;
     /** Undo the most recent edit. */
     undo(): void;
     /** Redo the most recently undone edit. */
@@ -3547,6 +4152,16 @@ declare class Project {
      * stable marker id (the allocated id when 0 was passed).
      */
     setMarker(markerId: number, ppq: number, name: string): number;
+    /**
+     * Add or replace a marker from a full {@link ProjectMarker}, including its
+     * {@link MarkerKind} and (for key signatures) the key. Pass `id` 0 to allocate
+     * a new id; returns the stable marker id.
+     */
+    setMarkerEx(marker: ProjectMarker): number;
+    /** Read a project marker by index (0-based, in stored order). */
+    markerByIndex(index: number): ProjectMarker;
+    /** Number of markers in the project. */
+    markerCount(): number;
     /** Number of tracks in the project. */
     trackCount(): number;
     /** Number of audio sources registered on the project. */
@@ -3585,7 +4200,70 @@ type EngineFreezeOptions = WasmEngineFreezeOptions;
 type EngineFreezeResult = WasmEngineFreezeResult;
 type EngineTelemetry = WasmEngineTelemetry;
 type EngineMeterTelemetry = WasmEngineMeterTelemetry;
+type EngineMeterTelemetryWide = WasmEngineMeterTelemetryWide;
+type EngineScopeTelemetry = WasmEngineScopeTelemetry;
 type EngineTransportState = WasmEngineTransportState;
+type EngineTempoSegment = WasmEngineTempoSegment;
+type EngineTimeSignatureSegment = WasmEngineTimeSignatureSegment;
+interface EngineTrackSend {
+    busId: number;
+    levelDb?: number;
+    enabled?: boolean;
+    /**
+     * Pre/post-fader tap point. Defaults to post-fader when omitted, matching the
+     * historical lane-send behavior and the scene-JSON default.
+     */
+    sendTiming?: SendTiming | number;
+}
+interface EngineTrackLane {
+    trackId: number;
+    sends?: EngineTrackSend[];
+    /**
+     * Bus the lane's post-fader output sums into instead of the master mix
+     * (group/folder routing); 0 or absent keeps the lane on the master mix.
+     */
+    outputBusId?: number;
+    /**
+     * Input channel layout of the source feeding this lane (`SonareChannelLayout`:
+     * 0 mono, 1 stereo, 2 5.1, 3 7.1). Absent defaults to stereo. Stored but inert
+     * until the surround DSP path lands.
+     */
+    sourceChannelLayout?: number;
+}
+interface EngineBus {
+    busId: number;
+    gainDb?: number;
+    /**
+     * Channel layout of the bus (`SonareChannelLayout`: 0 mono, 1 stereo, 2 5.1,
+     * 3 7.1). A surround layout makes this a surround group bus: lanes routed to
+     * it are surround-panned and it sums into the master plane-by-plane. Defaults
+     * to stereo.
+     */
+    channelLayout?: number;
+}
+interface EngineMidiEvent {
+    renderFrame: number;
+    word0?: number;
+    word1?: number;
+    word2?: number;
+    word3?: number;
+    wordCount?: number;
+    group?: number;
+    sysexHandle?: number;
+    data0?: number;
+    data1?: number;
+}
+interface EngineMidiClipSchedule {
+    id?: number;
+    trackId?: number;
+    destinationId?: number;
+    startSample?: number;
+    startPpq?: number;
+    lengthSamples?: number;
+    loop?: boolean;
+    loopLengthSamples?: number;
+    events: EngineMidiEvent[];
+}
 declare const EXPECTED_ENGINE_ABI_VERSION = 3;
 /** Options for {@link RealtimeEngine.bindMidiCc}. All fields are optional. */
 interface MidiCcBindOptions {
@@ -3606,13 +4284,14 @@ interface EngineCapabilities {
 declare function engineCapabilities(): EngineCapabilities;
 declare class RealtimeEngine {
     private native;
-    private nativeExt;
     constructor(sampleRate?: number, maxBlockSize?: number, commandCapacity?: number, telemetryCapacity?: number);
     prepare(sampleRate: number, maxBlockSize: number, commandCapacity?: number, telemetryCapacity?: number): void;
     /** Queue a sample-accurate parameter change (engine kSetParam). */
     setParameter(paramId: number, value: number, renderFrame?: number): void;
     /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
     setParameterSmoothed(paramId: number, value: number, renderFrame?: number): void;
+    setSoloMute(laneIndex: number, solo: boolean, mute: boolean, renderFrame?: number): void;
+    setMidiClips(clips: readonly EngineMidiClipSchedule[]): void;
     setBuiltinInstrument(config?: {
         destinationId?: number;
     } & Record<string, unknown>, destinationId?: number): void;
@@ -3691,9 +4370,19 @@ declare class RealtimeEngine {
     play(renderFrame?: number): void;
     stop(renderFrame?: number): void;
     seekSample(timelineSample: number, renderFrame?: number): void;
+    /**
+     * Snaps every in-flight parameter ramp (engine-level smoothed params, mixer
+     * lane fader/pan/gate, bus gains) to its target value. Offline renders call
+     * this after a priming process() block so the first audible block renders at
+     * settled values instead of ramping in from defaults.
+     */
+    settleParameters(): void;
     seekPpq(ppq: number, renderFrame?: number): void;
     setTempo(bpm: number): void;
+    setTempoSegments(segments: readonly EngineTempoSegment[]): void;
     setTimeSignature(numerator: number, denominator: number): void;
+    setTimeSignatureSegments(segments: readonly EngineTimeSignatureSegment[]): void;
+    sampleAtPpq(ppq: number): number;
     setLoop(startPpq: number, endPpq: number, enabled?: boolean): void;
     addParameter(info: EngineParameterInfo): void;
     parameterCount(): number;
@@ -3715,6 +4404,45 @@ declare class RealtimeEngine {
     graphConnectionCount(): number;
     setClips(clips: EngineClip[]): void;
     clipCount(): number;
+    setTrackLanes(lanes: Array<number | EngineTrackLane>): void;
+    /**
+     * Keys one insert of a lane strip from another lane's post-strip audio
+     * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+     */
+    setLaneSidechain(trackId: number, insertIndex: number, sourceTrackId: number): void;
+    setTrackBuses(buses: EngineBus[]): void;
+    setBusStripJson(busId: number, sceneJson: string): void;
+    setTrackStripJson(trackId: number, sceneJson: string): void;
+    setTrackStripEqBand(trackId: number, bandIndex: number, band: EqBand | string): void;
+    setTrackStripEqBandJson(trackId: number, bandIndex: number, bandJson: string): void;
+    setTrackStripInsertBypassed(trackId: number, insertIndex: number, bypassed: boolean, resetOnBypass?: boolean): void;
+    setMasterStripJson(sceneJson: string): void;
+    setMasterStripEqBand(bandIndex: number, band: EqBand | string): void;
+    setMasterStripEqBandJson(bandIndex: number, bandJson: string): void;
+    setMasterStripInsertBypassed(insertIndex: number, bypassed: boolean, resetOnBypass?: boolean): void;
+    /**
+     * Changes one track-strip insert parameter in realtime, addressed by the
+     * processor's JSON-key parameter name (see {@link masteringInsertParamInfo}).
+     * Applied at the next block head via the engine command queue; safe during
+     * playback. Throws if the track, insert, or name is unknown, the param is not
+     * realtime-safe, or the command queue is full.
+     */
+    setTrackStripInsertParamByName(trackId: number, insertIndex: number, paramName: string, value: number): void;
+    /** Master-strip counterpart of {@link setTrackStripInsertParamByName}. */
+    setMasterStripInsertParamByName(insertIndex: number, paramName: string, value: number): void;
+    /** Sets a track lane strip's pan position in realtime (glitch-free). */
+    setTrackStripPan(trackId: number, pan: number): void;
+    /** Sets a track lane strip's pan law in realtime. */
+    setTrackStripPanLaw(trackId: number, panLaw: PanLaw | number): void;
+    /** Sets a track lane strip's pan mode in realtime. */
+    setTrackStripPanMode(trackId: number, panMode: PanMode | number): void;
+    /** Sets a track lane strip's dual-pan left/right positions in realtime. */
+    setTrackStripDualPan(trackId: number, leftPan: number, rightPan: number): void;
+    /**
+     * Sets a track lane strip's inter-channel alignment delay (whole samples).
+     * Adjusts strip latency, so PDC and reported graph latency are refreshed.
+     */
+    setTrackStripChannelDelaySamples(trackId: number, delaySamples: number): void;
     createClipPageProvider(numChannels: number, numSamples: number, pageFrames: number): ClipPageProvider;
     supplyClipPage(providerId: number, pageIndex: number, channels: Float32Array[]): void;
     clearClipPage(providerId: number, pageIndex: number): void;
@@ -3755,6 +4483,24 @@ declare class RealtimeEngine {
     freezeOffline(options: EngineFreezeOptions): EngineFreezeResult;
     drainTelemetry(maxRecords?: number): EngineTelemetry[];
     drainMeterTelemetry(maxRecords?: number): EngineMeterTelemetry[];
+    /**
+     * Drains pending meter telemetry as per-plane (wide) records for a surround
+     * target. Use this for a surround mix target; {@link drainMeterTelemetry}
+     * stays the stereo fast path. The two share one queue — call only one per
+     * target. The live AudioWorklet path owns the queue via the stereo drain, so
+     * this wide drain is for an offline (non-worklet) engine instance; per-plane
+     * surround meters are not delivered over the live worklet meter ring.
+     */
+    drainMeterTelemetryWide(maxRecords?: number): EngineMeterTelemetryWide[];
+    /**
+     * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
+     * the minimum render-frame gap between snapshots (0 disables). @param bandCount
+     * is the FFT band resolution (1..64); changing it re-prepares the tap. Returns
+     * the band count actually applied.
+     */
+    configureScopeTelemetry(intervalFrames: number, bandCount: number): number;
+    /** Drains pending spectrum + vectorscope snapshots (per mix target). */
+    drainScopeTelemetry(maxRecords?: number): EngineScopeTelemetry[];
     destroy(): void;
 }
 declare class ClipPageProvider {
@@ -3782,7 +4528,7 @@ interface OpfsClipPageProviderBinding {
     supplyRequest(request: ClipPageRequest): Promise<boolean>;
     close(): void;
 }
-declare const opfsClipPageWorkerSource = "\nself.onmessage = async (event) => {\n  const message = event.data;\n  if (!message || message.type !== 'sonare:read-clip-page') return;\n  const { requestId, path, pageIndex, numChannels, numSamples, pageFrames, dataOffsetBytes = 0 } = message;\n  try {\n    if (pageIndex < 0) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const startFrame = pageIndex * pageFrames;\n    if (startFrame >= numSamples) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const root = await self.navigator.storage.getDirectory();\n    let dir = root;\n    const parts = String(path).split('/').filter(Boolean);\n    for (let i = 0; i < parts.length - 1; ++i) {\n      dir = await dir.getDirectoryHandle(parts[i]);\n    }\n    const fileHandle = await dir.getFileHandle(parts[parts.length - 1]);\n    const access = await fileHandle.createSyncAccessHandle();\n    try {\n      const frames = Math.min(pageFrames, numSamples - startFrame);\n      const frameBytes = numChannels * 4;\n      const bytes = new Uint8Array(frames * frameBytes);\n      let bytesReadTotal = 0;\n      const readOffset = dataOffsetBytes + startFrame * frameBytes;\n      while (bytesReadTotal < bytes.byteLength) {\n        const bytesRead = access.read(bytes.subarray(bytesReadTotal), {\n          at: readOffset + bytesReadTotal,\n        });\n        if (bytesRead <= 0) {\n          break;\n        }\n        bytesReadTotal += bytesRead;\n      }\n      if (bytesReadTotal !== bytes.byteLength || bytesReadTotal % frameBytes !== 0) {\n        self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n        return;\n      }\n      const framesRead = bytesReadTotal / frameBytes;\n      const view = new DataView(bytes.buffer, 0, framesRead * frameBytes);\n      const channelBuffers = Array.from({ length: numChannels }, () => new ArrayBuffer(framesRead * 4));\n      for (let ch = 0; ch < numChannels; ++ch) {\n        const channel = new Float32Array(channelBuffers[ch]);\n        for (let frame = 0; frame < framesRead; ++frame) {\n          channel[frame] = view.getFloat32((frame * numChannels + ch) * 4, true);\n        }\n      }\n      self.postMessage(\n        { type: 'sonare:clip-page', requestId, pageIndex, ok: true, frames: framesRead, channelBuffers },\n        channelBuffers,\n      );\n    } finally {\n      access.close();\n    }\n  } catch (error) {\n    self.postMessage({\n      type: 'sonare:clip-page',\n      requestId,\n      pageIndex,\n      ok: false,\n      error: error instanceof Error ? error.message : String(error),\n    });\n  }\n};\n";
+declare const opfsClipPageWorkerSource = "\nconst sonareClipPageReadQueues = new Map();\n\nfunction sonareEnqueueClipPageRead(key, task) {\n  const previous = sonareClipPageReadQueues.get(key) || Promise.resolve();\n  const next = previous.catch(() => undefined).then(task);\n  const queued = next.finally(() => {\n    if (sonareClipPageReadQueues.get(key) === queued) {\n      sonareClipPageReadQueues.delete(key);\n    }\n  });\n  sonareClipPageReadQueues.set(key, queued);\n  return next;\n}\n\nself.onmessage = async (event) => {\n  const message = event.data;\n  if (!message || message.type !== 'sonare:read-clip-page') return;\n  const { requestId, path, pageIndex, numChannels, numSamples, pageFrames, dataOffsetBytes = 0 } = message;\n  await sonareEnqueueClipPageRead(String(path), async () => {\n  try {\n    if (pageIndex < 0) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const startFrame = pageIndex * pageFrames;\n    if (startFrame >= numSamples) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const root = await self.navigator.storage.getDirectory();\n    let dir = root;\n    const parts = String(path).split('/').filter(Boolean);\n    for (let i = 0; i < parts.length - 1; ++i) {\n      dir = await dir.getDirectoryHandle(parts[i]);\n    }\n    const fileHandle = await dir.getFileHandle(parts[parts.length - 1]);\n    const access = await fileHandle.createSyncAccessHandle();\n    try {\n      const frames = Math.min(pageFrames, numSamples - startFrame);\n      const frameBytes = numChannels * 4;\n      const bytes = new Uint8Array(frames * frameBytes);\n      let bytesReadTotal = 0;\n      const readOffset = dataOffsetBytes + startFrame * frameBytes;\n      while (bytesReadTotal < bytes.byteLength) {\n        const bytesRead = access.read(bytes.subarray(bytesReadTotal), {\n          at: readOffset + bytesReadTotal,\n        });\n        if (bytesRead <= 0) {\n          break;\n        }\n        bytesReadTotal += bytesRead;\n      }\n      if (bytesReadTotal !== bytes.byteLength || bytesReadTotal % frameBytes !== 0) {\n        self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n        return;\n      }\n      const framesRead = bytesReadTotal / frameBytes;\n      const view = new DataView(bytes.buffer, 0, framesRead * frameBytes);\n      const channelBuffers = Array.from({ length: numChannels }, () => new ArrayBuffer(framesRead * 4));\n      for (let ch = 0; ch < numChannels; ++ch) {\n        const channel = new Float32Array(channelBuffers[ch]);\n        for (let frame = 0; frame < framesRead; ++frame) {\n          channel[frame] = view.getFloat32((frame * numChannels + ch) * 4, true);\n        }\n      }\n      self.postMessage(\n        { type: 'sonare:clip-page', requestId, pageIndex, ok: true, frames: framesRead, channelBuffers },\n        channelBuffers,\n      );\n    } finally {\n      access.close();\n    }\n  } catch (error) {\n    self.postMessage({\n      type: 'sonare:clip-page',\n      requestId,\n      pageIndex,\n      ok: false,\n      error: error instanceof Error ? error.message : String(error),\n    });\n  }\n  });\n};\n";
 declare function createOpfsClipPageWorker(): Worker;
 declare function createOpfsClipPageProvider(engine: RealtimeEngine, options: OpfsClipPageProviderOptions): OpfsClipPageProviderBinding;
 
@@ -4045,6 +4791,11 @@ interface FrameBuffer {
     /** Number of mel bands; flat `mel` is `[nFrames * nMels]` row-major. */
     nMels: number;
     timestamps: Float32Array;
+    /**
+     * Mel spectrogram in LINEAR power (not dB) — the raw per-frame mel energies.
+     * The quantized read paths (`readFramesU8` / `readFramesI16`) convert to dB
+     * before packing, so their `mel` is dB-scaled; this float buffer is not.
+     */
     mel: Float32Array;
     chroma: Float32Array;
     onsetStrength: Float32Array;
@@ -4077,6 +4828,7 @@ interface StreamFramesU8 {
     nFrames: number;
     nMels: number;
     timestamps: Float32Array;
+    /** Row-major `[nFrames * nMels]` mel in dB, quantized over `[melDbMin, melDbMax]`. */
     mel: Uint8Array;
     chroma: Uint8Array;
     onsetStrength: Uint8Array;
@@ -4088,6 +4840,7 @@ interface StreamFramesI16 {
     nFrames: number;
     nMels: number;
     timestamps: Float32Array;
+    /** Row-major `[nFrames * nMels]` mel in dB, quantized over `[melDbMin, melDbMax]`. */
     mel: Int16Array;
     chroma: Int16Array;
     onsetStrength: Int16Array;
@@ -4413,6 +5166,11 @@ declare class Mixer {
     setVcaOffsetDb(stripIndex: number, offsetDb: number): void;
     /** Set independent left/right pan positions (dual-pan mode). */
     setDualPan(stripIndex: number, leftPan: number, rightPan: number): void;
+    /**
+     * Set the strip's surround pan position, used when it feeds a >2-channel bus.
+     * Stored on the scene; inert until the surround DSP path applies it.
+     */
+    setSurroundPan(stripIndex: number, pan: SurroundPan): void;
     /**
      * Add a send to a strip after construction.
      *
@@ -4902,6 +5660,11 @@ type HpssWithResidualResult = WasmHpssWithResidualResult;
  */
 declare function init(options?: {
     locateFile?: (path: string, prefix: string) => string;
+    wasmBinary?: ArrayBuffer | Uint8Array;
+    moduleFactory?: (options?: {
+        locateFile?: (path: string, prefix: string) => string;
+        wasmBinary?: ArrayBuffer | Uint8Array;
+    }) => Promise<SonareModule>;
 }): Promise<void>;
 /**
  * Check if the module is initialized.
@@ -4925,4 +5688,4 @@ declare function voiceCharacterPresetId(preset: VoicePresetId | number): string
  */
 declare function realtimeVoiceChangerPresetConfig(preset: VoicePresetId | number): RealtimeVoiceChangerPodConfig | null;
 
-export { type EngineClip as $, type AcousticOptions as A, type BarChord as B, type Chord as C, type CompressorDetector as D, type CompressorOptions as E, type CqtResult as F, type DeclickOptions as G, type DeclipOptions as H, type DecomposeResult as I, type DecrackleMode as J, type DecrackleOptions as K, type DehumOptions as L, type DenoiseClassicalMode as M, type DenoiseClassicalNoiseEstimator as N, type DenoiseClassicalOptions as O, type DereverbClassicalOptions as P, type DynamicRangeReport as Q, type Dynamics as R, type DynamicsAnalysisResult as S, 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_SPECTRUM_RING_HEADER_INTS, SonareEngine, type SonareEngineCommandRecord, type SonareEngineCommandRingBuffer, SonareEngineCommandType, type SonareEngineOptions, type SonareEngineSyncAutomationMessage, type SonareEngineSyncClipsMessage, type SonareEngineSyncMarkersMessage, type SonareEngineSyncMessage, type SonareEngineSyncMetronomeMessage, SonareEngineTelemetryError, type SonareEngineTelemetryRecord, type SonareEngineTelemetryRingBuffer, type SonareEngineTelemetryRingReadResult, SonareEngineTelemetryType, type SonareEngineTransportFacade, type SonareMeterRingBuffer, type SonareMeterRingReadResult, SonareRealtimeEngineNode, type SonareRealtimeEngineNodeCapabilities, type SonareRealtimeEngineNodeOptions, SonareRealtimeEngineWorkletProcessor, type SonareRealtimeEngineWorkletProcessorOptions, type SonareRealtimeVoiceChangerDestroyMessage, type SonareRealtimeVoiceChangerMessage, type SonareRealtimeVoiceChangerResetMessage, type SonareRealtimeVoiceChangerSetConfigMessage, SonareRealtimeVoiceChangerWorkletProcessor, type SonareRealtimeVoiceChangerWorkletProcessorOptions, SonareRtRealtimeEngineRuntime, type SonareRtRealtimeEngineRuntimeOptions, type SonareSpectrumRingBuffer, type SonareSpectrumRingReadResult, type SonareWorkletDestroyMessage, type SonareWorkletMessage, type SonareWorkletMeterSnapshot, SonareWorkletProcessor, type SonareWorkletProcessorOptions, type SonareWorkletScheduleInsertAutomationMessage, type SonareWorkletSetMeterIntervalMessage, type SonareWorkletSpectrumSnapshot, type SonareWorkletTransportMessage, type DynamicsResult as T, EXPECTED_ENGINE_ABI_VERSION as U, EXPECTED_PROJECT_ABI_VERSION as V, type EngineAutomationPoint as W, type EngineBounceOptions as X, type EngineBounceResult as Y, type EngineCapabilities as Z, type EngineCaptureStatus as _, type AcousticResult as a, type PatternScore as a$, type EngineFreezeOptions as a0, type EngineFreezeResult as a1, type EngineGraphSpec as a2, type EngineMarker as a3, type EngineMeterTelemetry as a4, type EngineMetronomeConfig as a5, type EngineParameterInfo as a6, type EngineTelemetry as a7, type EngineTransportState as a8, type EqBand as a9, type Matrix2dResult as aA, type MelPowerResult as aB, type MelSpectrogramResult as aC, type MelodyOptions as aD, type MelodyPoint as aE, type MelodyResult as aF, type MeterTap as aG, type MeteringDetectClippingOptions as aH, type MeteringDynamicRangeOptions as aI, type MfccResult as aJ, type MicrophoneInputBinding as aK, type MidiCcBindOptions as aL, type MidiCcLearnOptions as aM, type MixMeterSnapshot as aN, type MixOptions as aO, type MixResult as aP, Mixer as aQ, type MixerProcessResult as aR, type MixerRealtimeBuffer as aS, Mode as aT, type NoteStretchOptions as aU, type OpfsClipPageProviderBinding as aV, type OpfsClipPageProviderOptions as aW, type PairAnalysis as aX, type PairProcessor as aY, type PanLaw as aZ, type PanMode as a_, type EqBandPhase as aa, type EqBandType as ab, type EqCoeffMode as ac, type EqMatchOptions as ad, type EqSpectrumSnapshot as ae, type EqStereoPlacement as af, ErrorCode as ag, type FrameBuffer as ah, type GateOptions as ai, type GoniometerPoint as aj, type HpssResult as ak, type HpssWithResidualResult as al, type Key as am, type KeyCandidate as an, type KeyDetectionOptions as ao, KeyProfile as ap, type KeyProfileName as aq, type LufsResult as ar, type MasteringChainConfig as as, type MasteringChainResult as at, type MasteringOptions as au, type MasteringPreset as av, type MasteringProcessorParams as aw, type MasteringResult as ax, type MasteringStereoChainResult as ay, type MasteringStereoResult as az, type AnalysisResult as b, StreamAnalyzer as b$, type PhaseScopeReport as b0, PitchClass as b1, type PitchResult as b2, type ProgressiveEstimate as b3, Project as b4, type ProjectAssistSidecar as b5, type ProjectAutomationCurve as b6, type ProjectAutomationLaneDesc as b7, type ProjectAutomationPoint as b8, type ProjectBounceOptions as b9, type RhythmFeatures as bA, type RirResult as bB, type RirSynthOptions as bC, type RoomEstimateOptions as bD, type RoomEstimateResult as bE, type RoomGeometryOptions as bF, type RoomMorphOptions as bG, SYNTH_BODY_TYPES as bH, SYNTH_ENGINE_MODES as bI, SYNTH_FILTER_MODELS as bJ, SYNTH_FILTER_OUTPUTS as bK, SYNTH_MOD_DESTINATIONS as bL, SYNTH_MOD_SOURCES as bM, SYNTH_OSC_WAVEFORMS as bN, type Section as bO, SectionType as bP, type SendTiming as bQ, type Sf2InstrumentConfig as bR, type Sf2ProgramStatus as bS, type SoloProcessor as bT, SonareError as bU, type SourceBackend as bV, type SpectrumOptions as bW, type SpectrumReport as bX, type StereoAnalysis as bY, type StftPowerResult as bZ, type StftResult as b_, type ProjectChordSymbol as ba, type ProjectClipCompSegment as bb, type ProjectClipDesc as bc, type ProjectClipFade as bd, type ProjectClipTake as be, type ProjectCompileResult as bf, type ProjectFadeCurve as bg, type ProjectKeySegment as bh, type ProjectLoopMode as bi, type ProjectLoopRecordingDesc as bj, type ProjectLoopRecordingResult as bk, type ProjectMidiClipResult as bl, type ProjectMidiEvent as bm, type ProjectNotePairValidation as bn, type ProjectTrackDesc as bo, type ProjectTrackKind as bp, type ProjectWarpAnchor as bq, type ProjectWarpMapDesc as br, RealtimeEngine as bs, RealtimeVoiceChanger as bt, type RealtimeVoiceChangerConfigInput as bu, type RealtimeVoiceChangerInterleavedBuffer as bv, type RealtimeVoiceChangerMonoBuffer as bw, type RealtimeVoiceChangerPlanarBuffer as bx, type RealtimeVoiceChangerPodConfig as by, type RhythmAnalysisResult as bz, type AnalyzeBpmOptions as c, decompose as c$, type StreamConfig as c0, type StreamConfigDefaults as c1, type StreamFramesI16 as c2, type StreamFramesU8 as c3, type StreamQuantizeConfig as c4, StreamingEqualizer as c5, type StreamingEqualizerConfig as c6, StreamingMasteringChain as c7, type StreamingMasteringChainConfig as c8, type StreamingPlatform as c9, type WaveformPeaksOptions as cA, type WaveformPeaksReport as cB, type WebMidiBinding as cC, type WebMidiCcBinding as cD, type WebMidiInputInfo as cE, amplitudeToDb as cF, analyze as cG, analyzeBpm as cH, analyzeDynamics as cI, analyzeImpulseResponse as cJ, analyzeMelody as cK, analyzeRhythm as cL, analyzeSections as cM, analyzeTimbre as cN, analyzeWithProgress as cO, bassChroma as cP, bindMicrophoneInput as cQ, bindWebMidi as cR, chordFunctionalAnalysis as cS, chroma as cT, chromaCens as cU, cqt as cV, createOpfsClipPageProvider as cW, createOpfsClipPageWorker as cX, cyclicTempogram as cY, dbToAmplitude as cZ, dbToPower as c_, StreamingRetune as ca, type StreamingRetuneConfig as cb, type SynthBodyType as cc, type SynthEngineMode as cd, type SynthEnumTables as ce, type SynthFilterModel as cf, type SynthFilterOutput as cg, type SynthModDestination as ch, type SynthModRouting as ci, type SynthModSource as cj, type SynthOscWaveform as ck, type SynthPatch as cl, type TempogramMode as cm, type Timbre as cn, type TimbreAnalysisResult as co, type TimbreFrame as cp, type TimeSignature as cq, type TransientShaperOptions as cr, createSonareEngineCommandRingBuffer, createSonareEngineTelemetryRingBuffer, createSonareMeterRingBuffer, createSonareSpectrumRingBuffer, type TrimSilenceMode as cs, type TrimSilenceOptions as ct, type ValidateOptions as cu, type VectorscopeReport as cv, type VoiceChangeOptions as cw, type VoiceChangeRealtimeOptions as cx, type VoicePresetId as cy, type WaveformPeakPyramidOptions as cz, type AnalyzeDynamicsOptions as d, masteringRepairDereverbClassical as d$, decomposeWithInit as d0, deemphasis as d1, detectAcoustic as d2, detectBeats as d3, detectBpm as d4, detectChords as d5, detectDownbeats as d6, detectKey as d7, detectKeyCandidates as d8, detectOnsets as d9, masterAudioStereoWithProgress as dA, masterAudioWithProgress as dB, mastering as dC, masteringAssistantSuggest as dD, masteringAudioProfile as dE, masteringChain as dF, masteringChainStereo as dG, masteringChainStereoWithProgress as dH, masteringChainWithProgress as dI, masteringDynamicsCompressor as dJ, masteringDynamicsGate as dK, masteringDynamicsTransientShaper as dL, masteringInsertNames as dM, masteringInsertParamNames as dN, masteringPairAnalysisNames as dO, masteringPairAnalyze as dP, masteringPairProcess as dQ, masteringPairProcessorNames as dR, masteringPresetNames as dS, masteringProcess as dT, masteringProcessStereo as dU, masteringProcessorNames as dV, masteringRepairDeclick as dW, masteringRepairDeclip as dX, masteringRepairDecrackle as dY, masteringRepairDehum as dZ, masteringRepairDenoiseClassical as d_, ebur128LoudnessRange as da, engineAbiVersion as db, engineCapabilities as dc, estimateRoom as dd, estimateTuning as de, decodeFrame, fixFrames as df, fixLength as dg, fourierTempogram as dh, frameSignal as di, framesToSamples as dj, framesToTime as dk, harmonic as dl, hasFfmpegSupport as dm, hpss as dn, hpssWithResidual as dp, hybridCqt as dq, hzToMel as dr, hzToMidi as ds, hzToNote as dt, isSonareError as du, isWebMidiAvailable as dv, lufs as dw, lufsInterleaved as dx, masterAudio as dy, masterAudioStereo as dz, type AnalyzeRhythmOptions as e, samplesToFrames as e$, masteringRepairTrimSilence as e0, masteringStereoAnalysisNames as e1, masteringStereoAnalyze as e2, masteringStreamingPreview as e3, melSpectrogram as e4, melToAudio as e5, melToHz as e6, melToStft as e7, meteringCrestFactorDb as e8, meteringDcOffset as e9, onsetEnvelope as eA, onsetStrengthMulti as eB, opfsClipPageWorkerSource as eC, padCenter as eD, pcen as eE, peakPick as eF, percussive as eG, phaseVocoder as eH, pitchCorrectToMidi as eI, pitchCorrectToMidiTimevarying as eJ, pitchPyin as eK, pitchShift as eL, pitchTuning as eM, pitchYin as eN, plp as eO, polyFeatures as eP, powerToDb as eQ, preemphasis as eR, projectAbiVersion as eS, pseudoCqt as eT, realtimeVoiceChangerPresetConfig as eU, realtimeVoiceChangerPresetJson as eV, realtimeVoiceChangerPresetNames as eW, remix as eX, resample as eY, rmsEnergy as eZ, roomMorph as e_, meteringDetectClipping as ea, meteringDynamicRange as eb, meteringPeakDb as ec, meteringPhaseScope as ed, meteringPhaseScopeDecimated as ee, meteringRmsDb as ef, meteringSpectrum as eg, meteringSpectrumFrame as eh, meteringStereoCorrelation as ei, meteringStereoWidth as ej, meteringTruePeakDb as ek, meteringVectorscope as el, meteringVectorscopeDecimated as em, mfcc as en, encodeFrameHi, encodeFrameLo, mfccToAudio as eo, mfccToMel as ep, midiToHz as eq, mixStereo as er, mixingScenePresetJson as es, mixingScenePresetNames as et, momentaryLufs as eu, nnFilter as ev, nnlsChroma as ew, normalize as ex, noteStretch as ey, noteToHz as ez, type AnalyzeSectionsOptions as f, scaleCorrectionSemitones as f0, scalePitchClassEnabled as f1, scaleQuantizeMidi as f2, shortTermLufs as f3, spectralBandwidth as f4, spectralCentroid as f5, spectralContrast as f6, spectralFlatness as f7, spectralRolloff as f8, splitSilence as f9, stft as fa, stftDb as fb, streamAnalyzerConfigDefaults as fc, synthEnumTables as fd, synthPresetNames as fe, synthPresetPatch as ff, synthesizeRir as fg, tempogram as fh, tempogramRatio as fi, timeStretch as fj, timeToFrames as fk, tonnetz as fl, trim as fm, trimSilence as fn, validateRealtimeVoiceChangerPresetJson as fo, vectorNormalize as fp, version as fq, voiceChange as fr, voiceChangeRealtime as fs, voiceChangerAbiVersion as ft, voiceCharacterPresetId as fu, vqt as fv, waveformPeakPyramid as fw, waveformPeaks as fx, zeroCrossingRate as fy, zeroCrossings as fz, type AnalyzeTimbreOptions as g, type AnalyzerStats as h, Audio as i, init, isInitialized, type AutomationCurve as j, type Beat as k, type BindMicrophoneInputOptions as l, type BindWebMidiOptions as m, type BpmAnalysisResult as n, type BpmCandidate as o, type BrowserAudioDecodeOptions as p, popSonareEngineCommandRingBuffer, pushSonareEngineCommandRingBuffer, type BuiltinSynthBinding as q, type BuiltinSynthConfig as r, readSonareEngineTelemetryRingBuffer, readSonareMeterRingBuffer, readSonareSpectrumRingBuffer, registerSonareRealtimeEngineWorkletProcessor, registerSonareRealtimeVoiceChangerWorkletProcessor, registerSonareWorkletProcessor, type BuiltinSynthWaveform as s, sonareEngineCommandRingBufferByteLength, sonareEngineTelemetryRingBufferByteLength, sonareMeterRingBufferByteLength, sonareSpectrumRingBufferByteLength, type ChordAnalysisResult as t, type ChordChange as u, type ChordDetectionOptions as v, ChordQuality as w, writeSonareEngineTelemetryRingBuffer, type ChromaResult as x, type ClippingRegion as y, type ClippingReport as z };
+export { type EngineCaptureStatus as $, type AcousticOptions as A, type BarChord as B, type Chord as C, type CompressorDetector as D, type CompressorOptions as E, type CqtResult as F, type DeclickOptions as G, type DeclipOptions as H, type DecomposeResult as I, type DecrackleMode as J, type DecrackleOptions as K, type DehumOptions as L, type DenoiseClassicalMode as M, type DenoiseClassicalNoiseEstimator as N, type DenoiseClassicalOptions as O, type DereverbClassicalOptions as P, type DynamicRangeReport as Q, type Dynamics as R, type DynamicsAnalysisResult as S, 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, SonareEngine, type SonareEngineCaptureRequestMessage, type SonareEngineCaptureResponseMessage, type SonareEngineCommandRecord, type SonareEngineCommandRingBuffer, SonareEngineCommandType, type SonareEngineOptions, type SonareEngineSyncAutomationMessage, type SonareEngineSyncBuiltinInstrumentMessage, type SonareEngineSyncCaptureMessage, type SonareEngineSyncClipsDeltaMessage, type SonareEngineSyncClipsMessage, type SonareEngineSyncLoadSoundFontMessage, type SonareEngineSyncMarkersMessage, type SonareEngineSyncMasterStripEqBandMessage, type SonareEngineSyncMasterStripInsertBypassedMessage, type SonareEngineSyncMessage, type SonareEngineSyncMetronomeMessage, type SonareEngineSyncMidiCcMessage, type SonareEngineSyncMidiClipsMessage, type SonareEngineSyncMidiNoteMessage, type SonareEngineSyncMidiPanicMessage, type SonareEngineSyncMixerMessage, type SonareEngineSyncSf2InstrumentMessage, type SonareEngineSyncSynthInstrumentMessage, type SonareEngineSyncTempoMessage, type SonareEngineSyncTrackStripEqBandMessage, type SonareEngineSyncTrackStripInsertBypassedMessage, SonareEngineTelemetryError, type SonareEngineTelemetryRecord, type SonareEngineTelemetryRingBuffer, type SonareEngineTelemetryRingReadResult, SonareEngineTelemetryType, type SonareEngineTransportFacade, type SonareEngineTransportRequestMessage, type SonareEngineTransportResponseMessage, type SonareMeterRingBuffer, type SonareMeterRingReadResult, SonareRealtimeEngineNode, type SonareRealtimeEngineNodeCapabilities, type SonareRealtimeEngineNodeOptions, SonareRealtimeEngineWorkletProcessor, type SonareRealtimeEngineWorkletProcessorOptions, type SonareRealtimeVoiceChangerDestroyMessage, type SonareRealtimeVoiceChangerMessage, type SonareRealtimeVoiceChangerResetMessage, type SonareRealtimeVoiceChangerSetConfigMessage, SonareRealtimeVoiceChangerWorkletProcessor, type SonareRealtimeVoiceChangerWorkletProcessorOptions, SonareRtRealtimeEngineRuntime, type SonareRtRealtimeEngineRuntimeOptions, type SonareScopeRingBuffer, type SonareScopeRingReadResult, type SonareSpectrumRingBuffer, type SonareSpectrumRingReadResult, type SonareWorkletDestroyMessage, type SonareWorkletMessage, type SonareWorkletMeterSnapshot, SonareWorkletProcessor, type SonareWorkletProcessorOptions, type SonareWorkletScheduleInsertAutomationMessage, type SonareWorkletScopeSnapshot, type SonareWorkletSetMeterIntervalMessage, type SonareWorkletSpectrumSnapshot, type SonareWorkletTransportMessage, type DynamicsResult as T, EXPECTED_ENGINE_ABI_VERSION as U, EXPECTED_PROJECT_ABI_VERSION as V, type EngineAutomationPoint as W, type EngineBounceOptions as X, type EngineBounceResult as Y, type EngineBus as Z, type EngineCapabilities as _, type AcousticResult as a, type MixOptions as a$, type EngineClip as a0, type EngineFreezeOptions as a1, type EngineFreezeResult as a2, type EngineGraphSpec as a3, type EngineMarker as a4, type EngineMeterTelemetry as a5, type EngineMeterTelemetryWide as a6, type EngineMetronomeConfig as a7, type EngineMidiClipSchedule as a8, type EngineMidiEvent as a9, type LufsResult as aA, MarkerKind as aB, type MasteringChainConfig as aC, type MasteringChainResult as aD, type MasteringChannelPolicy as aE, type MasteringInsertParamInfo as aF, type MasteringOptions as aG, type MasteringPreset as aH, type MasteringProcessorCatalogEntry as aI, type MasteringProcessorParams as aJ, type MasteringResult as aK, type MasteringStereoChainResult as aL, type MasteringStereoResult as aM, type Matrix2dResult as aN, type MelPowerResult as aO, type MelSpectrogramResult as aP, type MelodyOptions as aQ, type MelodyPoint as aR, type MelodyResult as aS, type MeterTap as aT, type MeteringDetectClippingOptions as aU, type MeteringDynamicRangeOptions as aV, type MfccResult as aW, type MicrophoneInputBinding as aX, type MidiCcBindOptions as aY, type MidiCcLearnOptions as aZ, type MixMeterSnapshot as a_, type EngineParameterInfo as aa, type EngineScopeTelemetry as ab, type EngineTelemetry as ac, type EngineTempoSegment as ad, type EngineTimeSignatureSegment as ae, type EngineTrackLane as af, type EngineTrackSend as ag, type EngineTransportState as ah, type EqBand as ai, type EqBandPhase as aj, type EqBandType as ak, type EqCoeffMode as al, type EqMatchOptions as am, type EqSpectrumSnapshot as an, type EqStereoPlacement as ao, ErrorCode as ap, type FrameBuffer as aq, type GateOptions as ar, type GoniometerPoint as as, type HpssResult as at, type HpssWithResidualResult as au, type Key as av, type KeyCandidate as aw, type KeyDetectionOptions as ax, KeyProfile as ay, type KeyProfileName as az, type AnalysisResult as b, SYNTH_OSC_WAVEFORMS as b$, type MixResult as b0, Mixer as b1, type MixerProcessResult as b2, type MixerRealtimeBuffer as b3, Mode as b4, type NoteStretchOptions as b5, type OpfsClipPageProviderBinding as b6, type OpfsClipPageProviderOptions as b7, type PairAnalysis as b8, type PairProcessor as b9, type ProjectMidiEvent as bA, type ProjectNotePairValidation as bB, type ProjectTrackDesc as bC, type ProjectTrackKind as bD, type ProjectWarpAnchor as bE, type ProjectWarpMapDesc as bF, RealtimeEngine as bG, RealtimeVoiceChanger as bH, type RealtimeVoiceChangerConfigInput as bI, type RealtimeVoiceChangerInterleavedBuffer as bJ, type RealtimeVoiceChangerMonoBuffer as bK, type RealtimeVoiceChangerPlanarBuffer as bL, type RealtimeVoiceChangerPodConfig as bM, type RhythmAnalysisResult as bN, type RhythmFeatures as bO, type RirResult as bP, type RirSynthOptions as bQ, type RoomEstimateOptions as bR, type RoomEstimateResult as bS, type RoomGeometryOptions as bT, type RoomMorphOptions as bU, SYNTH_BODY_TYPES as bV, SYNTH_ENGINE_MODES as bW, SYNTH_FILTER_MODELS as bX, SYNTH_FILTER_OUTPUTS as bY, SYNTH_MOD_DESTINATIONS as bZ, SYNTH_MOD_SOURCES as b_, type PanLaw as ba, type PanMode as bb, type PatternScore as bc, type PhaseScopeReport as bd, PitchClass as be, type PitchResult as bf, type ProgressiveEstimate as bg, Project as bh, type ProjectAssistSidecar as bi, type ProjectAutomationCurve as bj, type ProjectAutomationLaneDesc as bk, type ProjectAutomationPoint as bl, type ProjectBounceOptions as bm, type ProjectChordSymbol as bn, type ProjectClipCompSegment as bo, type ProjectClipDesc as bp, type ProjectClipFade as bq, type ProjectClipTake as br, type ProjectCompileResult as bs, type ProjectFadeCurve as bt, type ProjectKeySegment as bu, type ProjectLoopMode as bv, type ProjectLoopRecordingDesc as bw, type ProjectLoopRecordingResult as bx, type ProjectMarker as by, type ProjectMidiClipResult as bz, type AnalyzeBpmOptions as c, analyzeImpulseResponse as c$, type Section as c0, SectionType as c1, type SendTiming as c2, type Sf2InstrumentConfig as c3, type Sf2ProgramStatus as c4, type SoloProcessor as c5, SonareError as c6, type SourceBackend as c7, type SpectralEditMode as c8, type SpectralEditOptions as c9, type SynthModRouting as cA, type SynthModSource as cB, type SynthOscWaveform as cC, type SynthPatch as cD, type TempogramMode as cE, type Timbre as cF, type TimbreAnalysisResult as cG, type TimbreFrame as cH, type TimeSignature as cI, type TransientShaperOptions as cJ, type TrimSilenceMode as cK, type TrimSilenceOptions as cL, type ValidateOptions as cM, type VectorscopeReport as cN, type VoiceChangeOptions as cO, type VoiceChangeRealtimeOptions as cP, type VoicePresetId as cQ, type WaveformPeakPyramidOptions as cR, type WaveformPeaksOptions as cS, type WaveformPeaksReport as cT, type WebMidiBinding as cU, type WebMidiCcBinding as cV, type WebMidiInputInfo as cW, amplitudeToDb as cX, analyze as cY, analyzeBpm as cZ, analyzeDynamics as c_, type SpectralEditWindow as ca, type SpectralRegionOp as cb, type SpectrumOptions as cc, type SpectrumReport as cd, type StereoAnalysis as ce, type StftPowerResult as cf, type StftResult as cg, StreamAnalyzer as ch, type StreamConfig as ci, type StreamConfigDefaults as cj, type StreamFramesI16 as ck, type StreamFramesU8 as cl, type StreamQuantizeConfig as cm, StreamingEqualizer as cn, type StreamingEqualizerConfig as co, StreamingMasteringChain as cp, type StreamingMasteringChainConfig as cq, type StreamingPlatform as cr, createSonareEngineCommandRingBuffer, createSonareEngineTelemetryRingBuffer, createSonareMeterRingBuffer, createSonareScopeRingBuffer, createSonareSpectrumRingBuffer, StreamingRetune as cs, type StreamingRetuneConfig as ct, type SynthBodyType as cu, type SynthEngineMode as cv, type SynthEnumTables as cw, type SynthFilterModel as cx, type SynthFilterOutput as cy, type SynthModDestination as cz, type AnalyzeDynamicsOptions as d, masteringDynamicsCompressor as d$, analyzeMelody as d0, analyzeRhythm as d1, analyzeSections as d2, analyzeTimbre as d3, analyzeWithProgress as d4, bassChroma as d5, bindMicrophoneInput as d6, bindWebMidi as d7, chordFunctionalAnalysis as d8, chroma as d9, fourierTempogram as dA, frameSignal as dB, framesToSamples as dC, framesToTime as dD, harmonic as dE, hasFfmpegSupport as dF, hpss as dG, hpssWithResidual as dH, hybridCqt as dI, hzToMel as dJ, hzToMidi as dK, hzToNote as dL, isSonareError as dM, isWebMidiAvailable as dN, lufs as dO, lufsInterleaved as dP, masterAudio as dQ, masterAudioStereo as dR, masterAudioStereoWithProgress as dS, masterAudioWithProgress as dT, mastering as dU, masteringAssistantSuggest as dV, masteringAudioProfile as dW, masteringChain as dX, masteringChainStereo as dY, masteringChainStereoWithProgress as dZ, masteringChainWithProgress as d_, chromaCens as da, cqt as db, createOpfsClipPageProvider as dc, createOpfsClipPageWorker as dd, cyclicTempogram as de, decodeFrame, dbToAmplitude as df, dbToPower as dg, decompose as dh, decomposeWithInit as di, deemphasis as dj, detectAcoustic as dk, detectBeats as dl, detectBpm as dm, detectChords as dn, detectDownbeats as dp, detectKey as dq, detectKeyCandidates as dr, detectOnsets as ds, ebur128LoudnessRange as dt, engineAbiVersion as du, engineCapabilities as dv, estimateRoom as dw, estimateTuning as dx, fixFrames as dy, fixLength as dz, type AnalyzeRhythmOptions as e, phaseVocoder as e$, masteringDynamicsGate as e0, masteringDynamicsTransientShaper as e1, masteringInsertNames as e2, masteringInsertParamInfo as e3, masteringInsertParamNames as e4, masteringPairAnalysisNames as e5, masteringPairAnalyze as e6, masteringPairProcess as e7, masteringPairProcessorNames as e8, masteringPresetNames as e9, meteringSpectrum as eA, meteringSpectrumFrame as eB, meteringStereoCorrelation as eC, meteringStereoWidth as eD, meteringTruePeakDb as eE, meteringVectorscope as eF, meteringVectorscopeDecimated as eG, mfcc as eH, mfccToAudio as eI, mfccToMel as eJ, midiToHz as eK, mixStereo as eL, mixingScenePresetJson as eM, mixingScenePresetNames as eN, momentaryLufs as eO, nnFilter as eP, nnlsChroma as eQ, normalize as eR, noteStretch as eS, noteToHz as eT, onsetEnvelope as eU, onsetStrengthMulti as eV, opfsClipPageWorkerSource as eW, padCenter as eX, pcen as eY, peakPick as eZ, percussive as e_, masteringProcess as ea, masteringProcessStereo as eb, masteringProcessorCatalog as ec, masteringProcessorNames as ed, masteringRepairDeclick as ee, masteringRepairDeclip as ef, masteringRepairDecrackle as eg, masteringRepairDehum as eh, masteringRepairDenoiseClassical as ei, masteringRepairDereverbClassical as ej, masteringRepairTrimSilence as ek, masteringStereoAnalysisNames as el, masteringStereoAnalyze as em, masteringStreamingPreview as en, encodeFrameHi, encodeFrameLo, melSpectrogram as eo, melToAudio as ep, melToHz as eq, melToStft as er, meteringCrestFactorDb as es, meteringDcOffset as et, meteringDetectClipping as eu, meteringDynamicRange as ev, meteringPeakDb as ew, meteringPhaseScope as ex, meteringPhaseScopeDecimated as ey, meteringRmsDb as ez, type AnalyzeSectionsOptions as f, pitchCorrectToMidi as f0, pitchCorrectToMidiTimevarying as f1, pitchPyin as f2, pitchShift as f3, pitchTuning as f4, pitchYin as f5, plp as f6, polyFeatures as f7, powerToDb as f8, preemphasis as f9, synthPresetPatch as fA, synthesizeRir as fB, tempogram as fC, tempogramRatio as fD, timeStretch as fE, timeToFrames as fF, tonnetz as fG, trim as fH, trimSilence as fI, validateRealtimeVoiceChangerPresetJson as fJ, vectorNormalize as fK, version as fL, voiceChange as fM, voiceChangeRealtime as fN, voiceChangerAbiVersion as fO, voiceCharacterPresetId as fP, vqt as fQ, waveformPeakPyramid as fR, waveformPeaks as fS, zeroCrossingRate as fT, zeroCrossings as fU, projectAbiVersion as fa, pseudoCqt as fb, realtimeVoiceChangerPresetConfig as fc, realtimeVoiceChangerPresetJson as fd, realtimeVoiceChangerPresetNames as fe, remix as ff, resample as fg, rmsEnergy as fh, roomMorph as fi, samplesToFrames as fj, scaleCorrectionSemitones as fk, scalePitchClassEnabled as fl, scaleQuantizeMidi as fm, shortTermLufs as fn, spectralBandwidth as fo, spectralCentroid as fp, spectralContrast as fq, spectralEdit as fr, spectralFlatness as fs, spectralRolloff as ft, splitSilence as fu, stft as fv, stftDb as fw, streamAnalyzerConfigDefaults as fx, synthEnumTables as fy, synthPresetNames as fz, type AnalyzeTimbreOptions as g, type AnalyzerStats as h, Audio as i, init, isInitialized, type AutomationCurve as j, type Beat as k, type BindMicrophoneInputOptions as l, type BindWebMidiOptions as m, type BpmAnalysisResult as n, type BpmCandidate as o, type BrowserAudioDecodeOptions as p, popSonareEngineCommandRingBuffer, pushSonareEngineCommandRingBuffer, type BuiltinSynthBinding as q, type BuiltinSynthConfig as r, readSonareEngineTelemetryRingBuffer, readSonareMeterRingBuffer, readSonareScopeRingBuffer, readSonareSpectrumRingBuffer, registerSonareRealtimeEngineWorkletProcessor, registerSonareRealtimeVoiceChangerWorkletProcessor, registerSonareWorkletProcessor, type BuiltinSynthWaveform as s, sonareEngineCommandRingBufferByteLength, sonareEngineTelemetryRingBufferByteLength, sonareMeterRingBufferByteLength, sonareScopeRingBufferByteLength, sonareSpectrumRingBufferByteLength, type ChordAnalysisResult as t, type ChordChange as u, type ChordDetectionOptions as v, ChordQuality as w, writeSonareEngineTelemetryRingBuffer, type ChromaResult as x, type ClippingRegion as y, type ClippingReport as z };