@libraz/libsonare 1.5.4 → 1.6.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ProgressCallback, WasmNnlsChromaResult, WasmClipPageRequest, WasmExternalMidiEvent, WasmEngineTransportState, WasmEngineTempoSegment, WasmEngineTimeSignatureSegment, WasmEngineParameterInfo, WasmEngineAutomationPoint, WasmEngineMarker, WasmEngineMetronomeConfig, WasmEngineGraphSpec, WasmEngineClip, WasmEngineCaptureStatus, WasmEngineProcessWithMonitorResult, WasmEngineBounceOptions, WasmEngineBounceResult, WasmEngineFreezeOptions, WasmEngineFreezeResult, WasmEngineTelemetry, WasmEngineMeterTelemetry, WasmEngineMeterTelemetryWide, WasmEngineScopeTelemetry, WasmCyclicTempogramResult, WasmFrameResult, WasmTempogramResult, WasmTrimResult, WasmFourierTempogramResult, WasmDecomposeResult, WasmHpssWithResidualResult, WasmLufsResult, WasmMatrix2dResult, SonareModule } from './sonare.js';
+import { ProgressCallback, WasmNnlsChromaResult, WasmExternalMidiEvent, WasmEngineTransportState, WasmEngineTempoSegment, WasmEngineTimeSignatureSegment, WasmEngineParameterInfo, WasmEngineAutomationPoint, WasmEngineMarker, WasmEngineMetronomeConfig, WasmEngineGraphSpec, WasmEngineClip, WasmClipPageRequest, WasmEngineCaptureStatus, WasmEngineProcessWithMonitorResult, WasmEngineBounceOptions, WasmEngineBounceResult, WasmEngineFreezeOptions, WasmEngineFreezeResult, WasmEngineTelemetry, WasmEngineMeterTelemetry, WasmEngineMeterTelemetryWide, WasmEngineScopeTelemetry, WasmCyclicTempogramResult, WasmFrameResult, WasmTempogramResult, WasmTrimResult, WasmFourierTempogramResult, WasmDecomposeResult, WasmHpssWithResidualResult, WasmLufsResult, WasmMatrix2dResult, SonareModule } from './sonare.js';
 export { ProgressCallback } from './sonare.js';
 
 /**
@@ -156,6 +156,8 @@ interface MasteringResult {
     inputLufs: number;
     outputLufs: number;
     appliedGainDb: number;
+    /** True when peak headroom prevented the requested LUFS target. */
+    loudnessTargetLimited?: boolean;
     latencySamples?: number;
 }
 type MasteringProcessorParams = Record<string, number | boolean>;
@@ -343,6 +345,7 @@ interface MasteringChainConfig {
         monoMaker?: {
             enabled?: boolean;
             amount?: number;
+            frequencyHz?: number;
         };
     };
     maximizer?: {
@@ -401,6 +404,24 @@ interface StageGainReduction {
      */
     gainReductionDb: number;
 }
+/** Existing EBU R128 measurements captured before or after mastering. */
+interface MasteringLoudnessSummary {
+    integratedLufs: number;
+    maxMomentaryLufs: number;
+    maxShortTermLufs: number;
+    truePeakDbtp: number;
+    loudnessRange: number;
+}
+/** Compact explanation of how an offline mastering chain changed a program. */
+interface MasteringReport {
+    before: MasteringLoudnessSummary;
+    after: MasteringLoudnessSummary;
+    appliedGainDb: number;
+    maxGainReductionDb: number;
+    loudnessTargetLimited: boolean;
+    /** 32 logarithmically-spaced after-minus-before spectral energy deltas (dB). */
+    bandEnergyDeltaDb: Float32Array;
+}
 interface MasteringChainResult {
     /** Latency-compensated offline output; no separate latency field is reported. */
     samples: Float32Array;
@@ -417,8 +438,11 @@ interface MasteringChainResult {
     outputTruePeakDbtp: number;
     /** EBU Tech 3342 Loudness Range of the output (LU). */
     outputLra: number;
+    /** True when peak headroom prevented the requested LUFS target. */
+    loudnessTargetLimited: boolean;
     /** Per-stage gain reductions for the dynamics/maximizer stages (a subset of `stages`). */
     stageGainReductions: StageGainReduction[];
+    report: MasteringReport;
 }
 interface MasteringChainStereoResult {
     left: Float32Array;
@@ -431,7 +455,9 @@ interface MasteringChainStereoResult {
     /** See {@link MasteringChainResult} for field semantics. */
     outputTruePeakDbtp: number;
     outputLra: number;
+    loudnessTargetLimited: boolean;
     stageGainReductions: StageGainReduction[];
+    report: MasteringReport;
 }
 /**
  * @deprecated Use {@link MasteringChainStereoResult}. Retained as an alias for
@@ -449,7 +475,7 @@ interface MasteringStereoResult {
     latencySamples: number;
 }
 
-type PanMode = 'balance' | 'stereoPan' | 'stereo-pan' | 'dualPan' | 'dual-pan' | number;
+type PanMode = 'balance' | 'pan' | '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
@@ -521,7 +547,9 @@ interface MixerProcessResult {
 type AutomationCurve = 'linear' | 'exponential' | 'hold' | 's-curve';
 /**
  * Pan law applied when computing left/right gains from a pan position
- * (see {@link Mixer.setPanLaw}). Maps to the underlying integer code.
+ * (see {@link Mixer.setPanLaw}). On mono strips it changes the centre gain;
+ * on stereo Balance strips it changes only the far-channel taper, while centre
+ * remains unity. Maps to the underlying integer code.
  */
 type PanLaw = 'const3dB' | 'const4.5dB' | 'const6dB' | 'linear0dB';
 /**
@@ -730,6 +758,10 @@ interface Beat {
 interface Chord {
     root: PitchClass;
     bass: PitchClass;
+    /** Canonical core spelling; stable across all language bindings. */
+    rootName: string;
+    /** Canonical core spelling; stable across all language bindings. */
+    bassName: string;
     quality: ChordQuality;
     start: number;
     end: number;
@@ -800,6 +832,12 @@ interface TimeSignature {
     denominator: number;
     confidence: number;
 }
+/** Existing tempo-estimator hypothesis retained by unified analysis. */
+interface BpmHypothesis {
+    value: number;
+    confidence: number;
+    relation: 'primary' | 'half' | 'double' | 'other';
+}
 /**
  * Rhythm features
  */
@@ -826,8 +864,10 @@ interface MelodyContour {
 interface AnalysisResult {
     bpm: number;
     bpmConfidence: number;
+    bpmCandidates: BpmHypothesis[];
     key: Key;
     timeSignature: TimeSignature;
+    timeSignatureCandidates: TimeSignature[];
     beatTimes: Float32Array;
     beats: Beat[];
     chords: Chord[];
@@ -1005,21 +1045,22 @@ interface PitchCorrectOptions extends ValidateOptions {
 interface NoteStretchOptions {
     /** Note onset position in samples (selects the region). Default 0. */
     onsetSample?: number;
-    /** Note offset position in samples (selects the region). Default 0. */
+    /** Note offset position in samples (selects the region). Defaults to the input length. */
     offsetSample?: number;
-    /** Stretch ratio (0.5 = double duration, 2.0 = half duration). Default 1. */
+    /** Stretch ratio (0.5 = half duration, 2.0 = double duration). Default 1. */
     stretchRatio?: number;
 }
 /** Options for `noteMove`. */
 interface NoteMoveOptions {
     onsetSample?: number;
+    /** Defaults to the input length. */
     offsetSample?: number;
     targetOnsetSample?: 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';
+type SpectralEditWindow = 'hann' | 'hamming' | 'blackman' | 'rectangular' | 'rect';
 /** One time x frequency rectangle edit op for `spectralEdit`. */
 interface SpectralRegionOp {
     /** Region time start (input samples); clamped to [0, length]. Default 0. */
@@ -1141,13 +1182,48 @@ interface PitchResult {
     medianF0: number;
     meanF0: number;
 }
+/** Per-bin pitch candidates and peak magnitudes from spectral piptrack. */
+interface PiptrackResult {
+    nBins: number;
+    nFrames: number;
+    pitches: Float32Array;
+    magnitudes: Float32Array;
+}
+/** Magnitude and reassigned time/frequency coordinates for every STFT bin. */
+interface ReassignedSpectrogramResult {
+    nBins: number;
+    nFrames: number;
+    magnitude: Float32Array;
+    times: Float32Array;
+    frequencies: Float32Array;
+}
+/** Row-major matrix returned by librosa.segment-compatible APIs. */
+interface SegmentMatrix {
+    rows: number;
+    cols: number;
+    values: Float32Array;
+}
+/** One stable monophonic note region segmented from an F0 track. */
+interface NoteSegment {
+    frameStart: number;
+    frameEnd: number;
+    startSeconds: number;
+    endSeconds: number;
+    medianCents: number;
+}
 /**
  * Loudness measurement result (EBU R128 / ITU-R BS.1770)
  */
 interface LufsResult {
     integratedLufs: number;
+    /** Final complete 400 ms window, not Max-M. */
     momentaryLufs: number;
+    /** Final complete 3 s window, not Max-S. */
     shortTermLufs: number;
+    /** Maximum 400 ms window (EBU R128 Max-M). */
+    maxMomentaryLufs: number;
+    /** Maximum 3 s window (EBU R128 Max-S). */
+    maxShortTermLufs: number;
     loudnessRange: number;
 }
 /**
@@ -1159,6 +1235,67 @@ interface HpssResult {
     sampleRate: number;
 }
 
+/** Runtime capabilities reported by the loaded libsonare build. */
+interface SonareCapabilities {
+    version: string;
+    abi: {
+        project: number;
+        engine: number;
+    };
+    platform: string;
+    features: {
+        mastering: boolean;
+        mixing: boolean;
+        fx: boolean;
+        ffmpeg: boolean;
+    };
+    decode: {
+        builtin: string[];
+        ffmpeg: string[];
+    };
+    simd: string;
+    hardwareConcurrency: number;
+}
+/** One parameter descriptor in the cross-surface capability catalog. */
+interface CapabilityCatalogParameter {
+    name: string;
+    id: number;
+    rtSafe: boolean;
+    type: 'boolean' | 'number';
+    min: number | null;
+    max: number | null;
+    default: boolean | number | null;
+    unit: string | null;
+}
+/** One named mastering processor and its host-facing capabilities. */
+interface CapabilityCatalogProcessor {
+    id: string;
+    kind: 'realtime' | 'offline' | 'pair';
+    realtimeInsertable: boolean;
+    stereoOnly: boolean;
+    latencySamples: number;
+    tailSamples: number;
+    /** Coarse realtime work estimate, or null when the processor is not an insert. */
+    realtimeCost: 'low' | 'moderate' | 'high' | null;
+    channelPolicy: 'multichannel' | 'stereoPairOnly' | 'perChannel' | 'passthrough';
+    category: string;
+    params: CapabilityCatalogParameter[];
+}
+/** Built-in preset names grouped by feature family. */
+interface CapabilityCatalogPresets {
+    mastering: string[];
+    synth: string[];
+    mixingScene: string[];
+    voiceChanger: string[];
+}
+/** Complete runtime catalog exposed by {@link capabilityCatalog}. */
+interface CapabilityCatalog {
+    version: string;
+    abi: SonareCapabilities['abi'];
+    processors: CapabilityCatalogProcessor[];
+    presets: CapabilityCatalogPresets;
+}
+
 /** Canonical request form for HPSS. */
 interface HpssRequest {
     samples: Float32Array;
@@ -1275,6 +1412,10 @@ declare function pitchShift(samples: Float32Array, sampleRate: number, semitones
 /**
  * Pitch-correct audio from a current MIDI note to a target MIDI note.
  *
+ * Applies one constant, immediate transpose with no retune glide and preserves
+ * the input buffer length. Use {@link pitchCorrectToMidiTimevarying} for a
+ * caller-supplied pitch contour.
+ *
  * @param samples - Audio samples (mono, float32)
  * @param sampleRate - Sample rate in Hz
  * @param currentMidi - Detected/current MIDI note number
@@ -1290,7 +1431,8 @@ declare function pitchCorrectToMidi(samples: Float32Array, sampleRate?: number,
  * the caller-supplied per-frame `f0Hz` contour and retunes every voiced frame
  * toward `targetMidi`, so vibrato/drift in the source is tracked rather than
  * flattened. `voiced` (non-zero = voiced) and `voicedProb` ([0,1]) are optional;
- * omitting them treats every frame as voiced.
+ * omitting them treats every frame as voiced. An `f0Hz` NaN is accepted only
+ * when the corresponding `voiced` entry is zero, matching pYIN output.
  *
  * @param samples - Audio samples (mono, float32)
  * @param f0Hz - Per-frame measured F0 in Hz (one entry per analysis frame)
@@ -1310,7 +1452,8 @@ declare function pitchCorrectToMidiTimevarying(samples: Float32Array, f0Hz: Floa
  * Generalises {@link pitchCorrectToMidiTimevarying}: the same caller-supplied
  * per-frame `f0Hz` contour drives correction, but `options.mode` selects between
  * a fixed-MIDI target (`'midi'`, default) and scale quantisation (`'scale'`),
- * and the retune knobs shape natural-vs-robotic correction.
+ * and the retune knobs shape natural-vs-robotic correction. An `f0Hz` NaN is
+ * accepted only for a frame marked unvoiced.
  *
  * @param samples - Audio samples (mono, float32)
  * @param f0Hz - Per-frame measured F0 in Hz (one entry per analysis frame)
@@ -1328,7 +1471,7 @@ declare function pitchCorrectTimevarying(samples: Float32Array, f0Hz: Float32Arr
  * @param sampleRate - Sample rate in Hz
  * @param onsetSample - Note onset position in samples
  * @param offsetSample - Note offset position in samples
- * @param stretchRatio - Stretch ratio (0.5 = double duration, 2.0 = half duration)
+ * @param stretchRatio - Stretch ratio (0.5 = half duration, 2.0 = double duration)
  * @returns Audio with the note region stretched
  */
 declare function noteStretch(request: NoteStretchRequest): Float32Array;
@@ -1341,7 +1484,7 @@ declare function noteMove(samples: Float32Array, sampleRate?: number, options?:
  *
  * @param samples - Audio samples (mono, float32)
  * @param sampleRate - Sample rate in Hz (default: 22050)
- * @param targetDb - Target peak level in dB (default: 0 dB = full scale)
+ * @param targetDb - Finite target at or below 0 dBFS (default: 0 dB = full scale)
  * @returns Normalized audio
  */
 declare function normalize(request: NormalizeRequest): Float32Array;
@@ -1419,6 +1562,7 @@ interface MasteringChainRequest {
     sampleRate?: number;
     config?: MasteringChainConfig;
     onProgress?: ProgressCallback;
+    cancel?: () => boolean;
 }
 interface MasteringChainStereoRequest {
     left: Float32Array;
@@ -1426,6 +1570,7 @@ interface MasteringChainStereoRequest {
     sampleRate?: number;
     config?: MasteringChainConfig;
     onProgress?: ProgressCallback;
+    cancel?: () => boolean;
 }
 /** Canonical request form for one-shot preset mastering. */
 interface MasterAudioRequest {
@@ -1434,6 +1579,7 @@ interface MasterAudioRequest {
     preset?: MasteringPreset;
     overrides?: MasteringChainConfig;
     onProgress?: ProgressCallback;
+    cancel?: () => boolean;
 }
 /** Canonical request form for one-shot stereo preset mastering. */
 interface MasterAudioStereoRequest {
@@ -1443,6 +1589,7 @@ interface MasterAudioStereoRequest {
     preset?: MasteringPreset;
     overrides?: MasteringChainConfig;
     onProgress?: ProgressCallback;
+    cancel?: () => boolean;
 }
 /**
  * Apply a configurable mastering chain in WASM.
@@ -1621,6 +1768,8 @@ interface MasteringInsertParamInfo {
     id: number;
     /** Whether the param can be changed live from the audio thread. */
     rtSafe: boolean;
+    /** Physical unit when the parameter is not unitless. */
+    unit?: string;
 }
 /**
  * Returns the realtime-automatable parameter descriptors for an insert / FX
@@ -1641,6 +1790,8 @@ declare function masteringInsertParamInfo(name: string): MasteringInsertParamInf
  * "perChannel"/"passthrough" are reserved and unused by the current catalog.
  */
 type MasteringChannelPolicy = 'multichannel' | 'stereoPairOnly' | 'perChannel' | 'passthrough';
+/** Coarse algorithmic work estimate for a realtime insert; not a benchmark. */
+type MasteringRealtimeCost = 'low' | 'moderate' | 'high';
 /** One processor's realtime/offline/pair classification in the catalog. */
 interface MasteringProcessorCatalogEntry {
     /** Processor id (the name used for scene inserts / named processors). */
@@ -1665,6 +1816,8 @@ interface MasteringProcessorCatalogEntry {
      * offline, dry-only, and no-tail processors.
      */
     tailSamples: number;
+    /** Coarse realtime work estimate, or null when the processor is not an insert. */
+    realtimeCost: MasteringRealtimeCost | null;
     /**
      * How the mixer wraps the processor on a >2-channel (surround) bus insert:
      * "multichannel" (one full-buffer call) or "stereoPairOnly" (front L/R pair,
@@ -2076,6 +2229,26 @@ interface ProjectBounceOptions {
     /** Host-instrument PDC (latency) fed to the compiler. */
     instrumentLatencySamples?: number;
 }
+/** One decoded output from a host-owned source-separation model. */
+interface ExternalSeparatedStem {
+    name: string;
+    /** Optional host metadata; it does not change DSP. */
+    role?: string;
+    layout: 'mono' | 'stereo' | 1 | 2;
+    planarSamples: Float32Array[];
+    /** Absolute project-rate frame at which this stem begins. */
+    startFrame?: number;
+}
+/** Request for {@link Project.importExternalStems}. */
+interface ExternalSeparatedStemImportRequest {
+    sampleRate: number;
+    stems: ExternalSeparatedStem[];
+}
+/** Ids of the normal tracks and clips created by the import. */
+interface ExternalSeparatedStemImportResult {
+    trackIds: number[];
+    clipIds: number[];
+}
 /**
  * Marker kind ordinals. Mirrors `SonareMarkerKind` in `src/sonare_c_types.h`;
  * the values are part of the ABI and must not be renumbered.
@@ -2102,8 +2275,43 @@ interface ProjectMarker {
     /** Key signature only: false = major, true = minor. */
     keyMinor?: boolean;
 }
+/** Read-only stored project track returned by {@link Project.trackByIndex}. */
+interface ProjectTrack {
+    id: number;
+    kind: number;
+    midiDestinationId: number;
+    gain: number;
+    pan: number;
+    mute: boolean;
+    solo: boolean;
+    name: string;
+}
+/** Read-only stored project clip returned by {@link Project.clipByIndex}. */
+interface ProjectClip {
+    id: number;
+    trackId: number;
+    sourceId: number;
+    sourceKind: number;
+    startPpq: number;
+    lengthPpq: number;
+    sourceOffsetPpq: number;
+    gain: number;
+    loopMode: number;
+    loopLengthPpq: number;
+}
+/** Read-only stored project source returned by {@link Project.sourceByIndex}. */
+interface ProjectSource {
+    id: number;
+    kind: number;
+    channelCount: number;
+    storageHandleId: number;
+    sampleRateHint: number;
+    nameOrUri: string;
+}
+/** Names accepted by the minimal built-in oscillator synth. */
+declare const BUILTIN_SYNTH_WAVEFORMS: readonly ["sine", "saw", "sawtooth", "square", "triangle"];
 /** Oscillator waveform for the built-in synth. */
-type BuiltinSynthWaveform = 'sine' | 'saw' | 'sawtooth' | 'square' | 'triangle' | 0 | 1 | 2 | 3;
+type BuiltinSynthWaveform = (typeof BUILTIN_SYNTH_WAVEFORMS)[number] | 0 | 1 | 2 | 3;
 /**
  * Built-in synth patch + MIDI routing for
  * {@link Project.bounceWithBuiltinInstrument}. Every field is optional; a
@@ -2148,6 +2356,8 @@ interface Sf2InstrumentConfig {
     gain?: number;
     /** Max simultaneous voices (0 => 48, clamped to [1, 64]). */
     polyphony?: number;
+    /** Prefer dedicated physical models for covered melodic GM programs. Defaults to false; drums stay SF2-first. */
+    preferModelForModeledFamilies?: boolean;
 }
 /** Source backend a resolved MIDI program renders through. */
 type SourceBackend = 'sf2' | 'synth';
@@ -2177,6 +2387,7 @@ declare const SYNTH_MOD_DESTINATIONS: readonly ["none", "pitch-cents", "cutoff-c
 interface SynthEnumTables {
     engineModes: string[];
     waveforms: string[];
+    builtinWaveforms: string[];
     filterModels: string[];
     filterOutputs: string[];
     bodyTypes: string[];
@@ -2276,7 +2487,7 @@ interface SynthPatch {
     busDrive?: number;
 }
 /** Clip fade-curve for {@link Project.setClipFade}. */
-type ProjectFadeCurve = 'linear' | 'equal-power' | 'equal_power' | 'equalPower' | 'exponential' | 'logarithmic' | 0 | 1 | 2 | 3;
+type ProjectFadeCurve = 'linear' | 'equal-power' | 'equal_power' | 'equalPower' | 'equalpower' | 'exponential' | 'exp' | 'logarithmic' | 'log' | 0 | 1 | 2 | 3;
 /** One clip fade region for {@link Project.setClipFade}. */
 interface ProjectClipFade {
     /** Fade length in PPQ (>= 0; 0 = no fade). */
@@ -2606,6 +2817,8 @@ declare class Project {
     addTrack(desc?: ProjectTrackDesc): number;
     /** Add an audio or MIDI clip and return its allocated clip id. */
     addClip(desc: ProjectClipDesc): number;
+    /** Import host-separated PCM through the normal audio-track/clip path. */
+    importExternalStems(request: ExternalSeparatedStemImportRequest): ExternalSeparatedStemImportResult;
     /** Split captured loop-recording audio into takes and add one clip. */
     addLoopRecordingTakes(desc: ProjectLoopRecordingDesc): ProjectLoopRecordingResult;
     /** Create a MIDI track + clip; returns `{ trackId, clipId }`. */
@@ -2630,7 +2843,11 @@ declare class Project {
      * Route a track's MIDI to host-instrument `destinationId` (0 = default). The
      * compiler stamps every MIDI clip on the track with this id so the engine
      * dispatches its events to the instrument registered for that destination.
-     * Routes through an undoable edit command.
+     * Routes through an undoable edit command. Builtin, NativeSynth, and SF2
+     * instruments retain source-track provenance inside a shared destination
+     * voice pool. With only zero-latency instruments bound, live lanes and
+     * channel-strip bounces remain aligned. Configure one live lane per source
+     * track that needs strip processing.
      */
     setTrackMidiDestination(trackId: number, destinationId: number): void;
     /** Set a track's linear playback gain (1.0 = unity; >= 0) via an undoable edit. */
@@ -2651,7 +2868,11 @@ declare class Project {
     setMaxUndoDepth(depth: number): void;
     /** Replace a MIDI clip's entire event list. */
     setMidiEvents(clipId: number, events: ReadonlyArray<ProjectMidiEvent | readonly [number, number, number]>): void;
-    /** Import an in-memory SMF buffer; returns the first added clip id. */
+    /**
+     * Import an in-memory SMF buffer; returns the first added clip id.
+     * Malformed or partially truncated tracks are rejected instead of installing
+     * a silently shortened clip.
+     */
     importSmf(data: Uint8Array): number;
     /** Export the project's tempo map + MIDI clips to an SMF byte buffer. */
     exportSmf(): Uint8Array;
@@ -2676,15 +2897,18 @@ declare class Project {
     setProgram(clipId: number, program: number, bank?: number): void;
     /** Set a MIDI clip's program / bank for one UMP group and channel. */
     setProgramOnChannel(clipId: number, group: number, channel: number, program: number, bank?: number): void;
-    /** Destructively bake a MIDI-FX chain into a clip's stored MIDI events. */
+    /**
+     * Destructively bake a MIDI-FX chain into all stored events. Large clips are
+     * drained without truncation; failure leaves the original clip unchanged.
+     */
     bakeMidiFx(clipId: number, configJson: string): void;
     /** Backward alias for {@link bakeMidiFx}. */
     setMidiFx(clipId: number, configJson: string): void;
     /**
      * Pre-flight check for hanging / unmatched notes in a MIDI clip: reports
-     * whether every note-on has a matching note-off (FIFO per channel+note).
-     * Useful before bouncing to catch a stuck note. Throws if `clipId` is unknown
-     * or not a MIDI clip.
+     * whether every note-on in the exported half-open playback window has a
+     * matching note-off (FIFO per group+channel+note). Useful before bouncing to
+     * catch a stuck note. Throws if `clipId` is unknown or not a MIDI clip.
      */
     validateMidiNotes(clipId: number): ProjectNotePairValidation;
     /** Return ranked tempo-octave and detected-meter candidates without editing. */
@@ -2788,6 +3012,10 @@ declare class Project {
     setClipGain(clipId: number, gain: number): void;
     /** Set a clip's fade-in / fade-out regions (undoable). */
     setClipFade(clipId: number, fadeIn?: ProjectClipFade, fadeOut?: ProjectClipFade): void;
+    /** Audio source ids that need decoded PCM after deserialization. */
+    unresolvedAudioSourceIds(): number[];
+    /** Register decoded interleaved PCM for an existing audio source (undoable). */
+    setSourceAudio(sourceId: number, audio: Float32Array, channels: number, sampleRate: number): void;
     /** Replace a clip's take list and active take id (undoable). */
     setClipTakes(clipId: number, takes: ReadonlyArray<ProjectClipTake>, activeTakeId?: number): void;
     /** Replace a clip's comp segments (undoable). */
@@ -2808,12 +3036,12 @@ declare class Project {
     renameTrack(trackId: number, name: string): void;
     /** Set a track's mixer-strip binding + output target (undoable; omit / '' clears). */
     setTrackRoute(trackId: number, channelStripRef?: string, outputTarget?: string): void;
-    /** Append an automation lane to a track; returns the lane index (undoable). */
+    /** Append an automation lane; returns its stable target parameter id (undoable). */
     addAutomationLane(trackId: number, desc: ProjectAutomationLaneDesc): number;
-    /** Replace an existing automation lane in place (undoable). */
-    editAutomationLane(trackId: number, laneIndex: number, desc: ProjectAutomationLaneDesc): void;
-    /** Remove an automation lane from a track (undoable). */
-    removeAutomationLane(trackId: number, laneIndex: number): void;
+    /** Replace the lane identified by its stable target parameter id (undoable). */
+    editAutomationLane(trackId: number, targetParamId: number, desc: ProjectAutomationLaneDesc): void;
+    /** Remove the lane identified by its stable target parameter id (undoable). */
+    removeAutomationLane(trackId: number, targetParamId: number): void;
     /** Replace the project's key annotation stream (undoable). */
     annotateKeys(keys: ReadonlyArray<ProjectKeySegment>): void;
     /** Replace the project's chord-symbol annotation stream (undoable). */
@@ -2845,6 +3073,12 @@ declare class Project {
     setMarkerEx(marker: ProjectMarker): number;
     /** Read a project marker by index (0-based, in stored order). */
     markerByIndex(index: number): ProjectMarker;
+    /** Read a stored project track by 0-based index. */
+    trackByIndex(index: number): ProjectTrack;
+    /** Read a stored project clip by 0-based index. */
+    clipByIndex(index: number): ProjectClip;
+    /** Read a stored project source by 0-based index. */
+    sourceByIndex(index: number): ProjectSource;
     /** Number of markers in the project. */
     markerCount(): number;
     /** Number of tracks in the project. */
@@ -2903,6 +3137,7 @@ type EngineMarker = WasmEngineMarker;
 type EngineMetronomeConfig = WasmEngineMetronomeConfig;
 type EngineGraphSpec = WasmEngineGraphSpec;
 type EngineCaptureStatus = WasmEngineCaptureStatus;
+type EngineCaptureSource = EngineCaptureStatus['source'] | number;
 type EngineBounceOptions = WasmEngineBounceOptions;
 type EngineBounceResult = WasmEngineBounceResult;
 type EngineFreezeOptions = WasmEngineFreezeOptions;
@@ -2993,8 +3228,8 @@ interface EngineCapabilities {
 declare function engineCapabilities(): EngineCapabilities;
 declare class RealtimeEngine {
     private native;
-    constructor(sampleRate?: number, maxBlockSize?: number, commandCapacity?: number, telemetryCapacity?: number);
-    prepare(sampleRate: number, maxBlockSize: number, commandCapacity?: number, telemetryCapacity?: number): void;
+    constructor(sampleRate?: number, maxBlockSize?: number, commandCapacity?: number, telemetryCapacity?: number, maxChannels?: number);
+    prepare(sampleRate: number, maxBlockSize: number, commandCapacity?: number, telemetryCapacity?: number, maxChannels?: 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). */
@@ -3040,6 +3275,7 @@ declare class RealtimeEngine {
         destinationId?: number;
         gain?: number;
         polyphony?: number;
+        preferModelForModeledFamilies?: boolean;
     }, destinationId?: number): void;
     clearMidiInstrument(destinationId?: number): void;
     midiInstrumentCount(): number;
@@ -3049,6 +3285,8 @@ declare class RealtimeEngine {
      * mapped into [minValue, maxValue] for `paramId`.
      */
     bindMidiCc(channel: number, controller: number, paramId: number, options?: MidiCcBindOptions): void;
+    /** Bind a 7/14-bit CC, RPN, or NRPN descriptor to a live parameter. */
+    bindMidiCcBinding(binding: ProjectMidiCcBinding): void;
     clearMidiCcBindings(): void;
     midiCcBindingCount(): number;
     /** Install/replace a live non-destructive MIDI-FX insert for one destination. */
@@ -3071,6 +3309,7 @@ declare class RealtimeEngine {
     setExternalMidiClockEnabled(enabled: boolean): void;
     /** Count of external-MIDI events dropped because the output queue was full. */
     externalMidiDroppedCount(): number;
+    externalMidiPendingCount(): number;
     /**
      * Drain queued external-MIDI events, already lowered to MIDI 1.0 byte
      * messages ready to write to a Web MIDI output port. Call once per audio
@@ -3079,6 +3318,13 @@ declare class RealtimeEngine {
      * queued for the next call (lossless); call again to drain the rest.
      */
     drainExternalMidi(maxRecords?: number): WasmExternalMidiEvent[];
+    /** Scalar, allocation-free external-MIDI drain for AudioWorklet SAB output. */
+    popExternalMidiToScratch(): boolean;
+    externalMidiScratchDestinationId(): number;
+    externalMidiScratchRenderFrame(): number;
+    externalMidiScratchByteWord(): number;
+    externalMidiScratchByteCount(): number;
+    consumeExternalMidiScratch(): void;
     pushMidiInputNoteOn(group: number, channel: number, note: number, velocity: number, portTimeSamples?: number): void;
     pushMidiInputNoteOff(group: number, channel: number, note: number, velocity?: number, portTimeSamples?: number): void;
     pushMidiInputCc(group: number, channel: number, controller: number, value: number, portTimeSamples?: number): void;
@@ -3091,6 +3337,8 @@ declare class RealtimeEngine {
      * immediate. Mirrors the Node/Python/C-ABI `pushMidiCc`.
      */
     pushMidiCc(destinationId: number, group: number, channel: number, controller: number, value: number, renderFrame?: number): void;
+    /** Queue one immediate MIDI 1.0 channel-voice UMP word for a destination. */
+    pushMidiUmp(destinationId: number, word0: number, renderFrame?: number): void;
     /**
      * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
      * the full message including the leading 0xF0 and trailing 0xF7 (1..512
@@ -3120,7 +3368,10 @@ declare class RealtimeEngine {
      * settled values instead of ramping in from defaults.
      */
     settleParameters(): void;
+    /** Drains queued commands on an offline/control-only engine immediately. */
+    flushControlCommands(): void;
     seekPpq(ppq: number, renderFrame?: number): void;
+    /** Set a finite tempo in the range (0, 100000] BPM. */
     setTempo(bpm: number): void;
     setTempoSegments(segments: readonly EngineTempoSegment[]): void;
     setTimeSignature(numerator: number, denominator: number): void;
@@ -3139,6 +3390,7 @@ declare class RealtimeEngine {
     marker(id: number): EngineMarker;
     seekMarker(markerId: number, renderFrame?: number): void;
     setLoopFromMarkers(startMarkerId: number, endMarkerId: number): void;
+    /** Set a metronome config; click lengths are limited to one second. */
     setMetronome(config: EngineMetronomeConfig): void;
     metronome(): Required<EngineMetronomeConfig>;
     countInEndSample(startSample: number, bars: number): number;
@@ -3210,15 +3462,29 @@ declare class RealtimeEngine {
     clearClipPage(providerId: number, pageIndex: number): void;
     destroyClipPageProvider(providerId: number): void;
     popClipPageRequest(): ClipPageRequest | null;
+    /**
+     * Moves one native request into the binding's persistent scalar scratch.
+     * This avoids creating an embind JS object in AudioWorklet process().
+     */
+    popClipPageRequestToScratch(): boolean;
+    clipPageRequestScratchClipId(): number;
+    clipPageRequestScratchSample(): number;
+    /** Cumulative page misses dropped because the native bounded request queue was full. */
+    clipPageRequestOverflowCount(): number;
     setCaptureBuffer(numChannels: number, capacityFrames: number): void;
     armCapture(armed?: boolean): void;
     setCapturePunch(startSample: number, endSample: number, enabled?: boolean): void;
-    setCaptureSource(source: EngineCaptureStatus['source']): void;
+    setCaptureSource(source: EngineCaptureSource): void;
+    /** Positive values delay capture relative to the punch window. */
     setRecordOffsetSamples(offsetSamples: number): void;
     setInputMonitor(enabled: boolean, gain?: number): void;
     resetCapture(): void;
     captureStatus(): EngineCaptureStatus;
     capturedAudio(): Float32Array[];
+    /**
+     * Renders in place, adding engine output to `channels`. Zero each plane first
+     * when it contains no upstream input.
+     */
     process(channels: Float32Array[]): Float32Array[];
     /**
      * Allocates persistent per-channel WASM-heap scratch for the zero-copy
@@ -3235,6 +3501,7 @@ declare class RealtimeEngine {
     getChannelBuffer(channel: number, numFrames: number): Float32Array;
     /**
      * Runs the engine in place over the prepared per-channel scratch buffers.
+     * Zero each active span first when it contains no upstream input.
      * Allocation-free: safe to call on the AudioWorklet render thread after
      * `prepareChannels`.
      */
@@ -3244,6 +3511,18 @@ declare class RealtimeEngine {
     bounceOffline(options: EngineBounceOptions): EngineBounceResult;
     freezeOffline(options: EngineFreezeOptions): EngineFreezeResult;
     drainTelemetry(maxRecords?: number): EngineTelemetry[];
+    popTelemetryToScratch(): boolean;
+    telemetryScratchType(): number;
+    telemetryScratchError(): number;
+    telemetryScratchRenderFrame(): number;
+    telemetryScratchTimelineSample(): number;
+    telemetryScratchAudibleTimelineSample(): number;
+    telemetryScratchGraphLatencySamplesQ8(): number;
+    telemetryScratchValue(): number;
+    popMeterTelemetryToScratch(): boolean;
+    meterScratchTargetId(): number;
+    meterScratchRenderFrame(): number;
+    meterScratchValue(field: number): number;
     drainMeterTelemetry(maxRecords?: number): EngineMeterTelemetry[];
     /**
      * Drains pending meter telemetry as per-plane (wide) records for a surround
@@ -3263,6 +3542,14 @@ declare class RealtimeEngine {
     configureScopeTelemetry(intervalFrames: number, bandCount: number): number;
     /** Drains pending spectrum + vectorscope snapshots (per mix target). */
     drainScopeTelemetry(maxRecords?: number): EngineScopeTelemetry[];
+    popScopeTelemetryToScratch(): boolean;
+    scopeScratchTargetId(): number;
+    scopeScratchRenderFrame(): number;
+    scopeScratchBandCount(): number;
+    scopeScratchBand(index: number): number;
+    scopeScratchPointCount(): number;
+    scopeScratchPointLeft(index: number): number;
+    scopeScratchPointRight(index: number): number;
     destroy(): void;
 }
 declare class ClipPageProvider {
@@ -3283,11 +3570,19 @@ interface OpfsClipPageProviderOptions {
     dataOffsetBytes?: number;
     worker?: Worker;
     terminateWorkerOnClose?: boolean;
+    /** Internal bridge hook used to mirror a supplied page into an AudioWorklet. */
+    onPageSupplied?: (pageIndex: number, channels: Float32Array[]) => void;
+    /** Internal bridge hook used to mirror an eviction into an AudioWorklet. */
+    onPageCleared?: (pageIndex: number) => void;
+    /** Internal bridge hook called after the local provider is destroyed. */
+    onClose?: () => void;
 }
 interface OpfsClipPageProviderBinding {
     provider: ClipPageProvider;
     supplyPage(pageIndex: number): Promise<boolean>;
     supplyRequest(request: ClipPageRequest): Promise<boolean>;
+    /** Evict one resident page from every configured consumer. */
+    clearPage?(pageIndex: number): void;
     close(): void;
 }
 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";
@@ -3300,7 +3595,16 @@ declare function createOpfsClipPageProvider(engine: RealtimeEngine, options: Opf
  */
 interface ClipPageStreamerEngine {
     /** Drain one pending audio-thread page-miss request, or `null` when empty. */
-    popClipPageRequest(): ClipPageRequest | null;
+    popClipPageRequest(): ClipPageStreamerRequest | null;
+}
+/**
+ * A page miss reported by either a direct engine (`sample`) or the worklet
+ * bridge (`pageIndex`). Exactly one position form is required.
+ */
+interface ClipPageStreamerRequest {
+    clipId: number;
+    sample?: number;
+    pageIndex?: number;
 }
 /** A paged clip the streamer keeps fed from its backing store. */
 interface ClipPageStreamSource {
@@ -3378,6 +3682,7 @@ declare class ClipPageStreamer {
     close(): void;
     private serviceFrontier;
     private resetState;
+    private clearPage;
 }
 interface OpfsClipStreamOptions extends OpfsClipPageProviderOptions {
     /** Clip schedule id used in `setClips` (matches the page-miss request clipId). */
@@ -3390,20 +3695,30 @@ interface OpfsClipStreamOptions extends OpfsClipPageProviderOptions {
 }
 interface OpfsClipStream {
     binding: OpfsClipPageProviderBinding;
-    /** Pass to `setClips({ pageProvider })` to schedule the streaming clip. */
+    /** Pass as `addClip`'s buffer argument to schedule the streaming clip. */
     provider: ClipPageProvider;
 }
+/** Structural seam implemented by the AudioWorklet-backed `SonareEngine`. */
+interface WorkletOpfsClipStreamHost {
+    attachOpfsClipStream(options: OpfsClipStreamOptions): Promise<OpfsClipStream>;
+}
 /**
  * One-call wiring of an OPFS-backed streaming clip: creates the page provider,
  * primes the leading pages, and registers it with `streamer` so later misses are
  * serviced within the bounded window. Returns the binding (for `close`) and the
- * provider to schedule via `setClips({ pageProvider })`.
+ * provider to schedule via `addClip(trackId, provider, startPpq, { id: clipId })`.
  *
  * @param streamer Shared streamer pumped on the control thread.
  * @param engine Engine the provider is created on (the same one `streamer` drives).
  * @param options Provider options plus `clipId` and optional `primePages`.
  */
 declare function attachOpfsClipStream(streamer: ClipPageStreamer, engine: RealtimeEngine, options: OpfsClipStreamOptions): Promise<OpfsClipStream>;
+/**
+ * Worklet overload: delegates to `SonareEngine.attachOpfsClipStream`, which
+ * creates the remote provider and drives this same sliding-window policy from
+ * worklet page-miss messages.
+ */
+declare function attachOpfsClipStream(engine: WorkletOpfsClipStreamHost, options: OpfsClipStreamOptions): Promise<OpfsClipStream>;
 
 /**
  * Numeric error codes carried by a {@link SonareError}. Mirrors the C ABI
@@ -3419,6 +3734,7 @@ declare enum ErrorCode {
     OutOfMemory = 5,
     NotSupported = 6,
     InvalidState = 7,
+    Cancelled = 8,
     Unknown = 99
 }
 /**
@@ -3436,6 +3752,12 @@ declare class SonareError extends Error {
 /** Type guard: whether a caught value is a libsonare {@link SonareError}. */
 declare function isSonareError(value: unknown): value is SonareError;
 
+declare function tone(request?: ToneRequest): Float32Array;
+declare function tone(frequency?: number, sampleRate?: number, duration?: number, phase?: number, amplitude?: number): Float32Array;
+declare function chirp(request?: ChirpRequest): Float32Array;
+declare function chirp(fmin?: number, fmax?: number, sampleRate?: number, duration?: number, linear?: boolean): Float32Array;
+declare function clicks(request: ClicksRequest): Float32Array;
+declare function clicks(times: Float32Array, sampleRate?: number, length?: number, frequency?: number, clickDuration?: number): Float32Array;
 interface DbConversionRequest {
     values: Float32Array;
     ref?: number;
@@ -3453,6 +3775,27 @@ interface FrameSignalRequest {
     frameLength: number;
     hopLength: number;
 }
+interface ToneRequest {
+    frequency?: number;
+    sampleRate?: number;
+    duration?: number;
+    phase?: number;
+    amplitude?: number;
+}
+interface ChirpRequest {
+    fmin?: number;
+    fmax?: number;
+    sampleRate?: number;
+    duration?: number;
+    linear?: boolean;
+}
+interface ClicksRequest {
+    times: Float32Array;
+    sampleRate?: number;
+    length?: number;
+    frequency?: number;
+    clickDuration?: number;
+}
 /** Canonical request form for pre/de-emphasis filters. */
 interface EmphasisRequest {
     samples: Float32Array;
@@ -3478,6 +3821,10 @@ interface FixFramesRequest {
     xMax?: number;
     pad?: boolean;
 }
+interface OnsetBacktrackRequest {
+    events: Int32Array;
+    energy: Float32Array;
+}
 /** Canonical request form for peak selection. */
 interface PeakPickRequest {
     values: Float32Array;
@@ -3504,6 +3851,14 @@ interface PcenRequest {
     values: Float32Array;
     nBins: number;
     nFrames: number;
+    sampleRate?: number;
+    hopLength?: number;
+    timeConstant?: number;
+    gain?: number;
+    bias?: number;
+    power?: number;
+    eps?: number;
+    /** @deprecated Put PCEN fields directly on the request object. */
     options?: Record<string, number>;
 }
 interface TempogramRequest {
@@ -3512,6 +3867,8 @@ interface TempogramRequest {
     hopLength?: number;
     winLength?: number;
     mode?: TempogramMode;
+    center?: boolean;
+    norm?: boolean;
 }
 interface CyclicTempogramRequest {
     onsetEnvelope: Float32Array;
@@ -3613,6 +3970,8 @@ declare function fixLength(request: FixLengthRequest): Float32Array;
 declare function fixLength(values: Float32Array, targetSize: number, padValue?: number): Float32Array;
 declare function fixFrames(request: FixFramesRequest): Int32Array;
 declare function fixFrames(frames: Int32Array, xMin?: number, xMax?: number, pad?: boolean): Int32Array;
+declare function onsetBacktrack(request: OnsetBacktrackRequest): Int32Array;
+declare function onsetBacktrack(events: Int32Array, energy: Float32Array): Int32Array;
 declare function peakPick(request: PeakPickRequest): Int32Array;
 declare function peakPick(values: Float32Array, preMax: number, postMax: number, preAvg: number, postAvg: number, delta: number, wait: number): Int32Array;
 declare function vectorNormalize(request: VectorNormalizeRequest): Float32Array;
@@ -3622,7 +3981,7 @@ declare function pcen(values: Float32Array, nBins: number, nFrames: number, opti
 declare function tonnetz(request: TonnetzRequest): Float32Array;
 declare function tonnetz(chromagram: Float32Array, nChroma: number, nFrames: number): Float32Array;
 declare function tempogram(request: TempogramRequest): WasmTempogramResult;
-declare function tempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number, mode?: TempogramMode): WasmTempogramResult;
+declare function tempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number, mode?: TempogramMode, center?: boolean, norm?: boolean): WasmTempogramResult;
 declare function cyclicTempogram(request: CyclicTempogramRequest): WasmCyclicTempogramResult;
 declare function cyclicTempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number, bpmMin?: number, nBins?: number): WasmCyclicTempogramResult;
 declare function plp(request: PlpRequest): Float32Array;
@@ -3659,6 +4018,8 @@ interface FourierTempogramRequest extends GuardedOptions$2 {
     sampleRate?: number;
     hopLength?: number;
     winLength?: number;
+    center?: boolean;
+    norm?: boolean;
 }
 interface TempogramRatioRequest extends GuardedOptions$2 {
     tempogramData: Float32Array;
@@ -3695,6 +4056,9 @@ interface LufsRequest extends ValidateOptions {
 interface NnlsChromaRequest extends GuardedOptions$2 {
     samples: Float32Array;
     sampleRate?: number;
+    enableStftBlend?: boolean;
+    stftBlendWeight?: number;
+    stftBlendNFft?: number;
 }
 /**
  * Compute NNLS (non-negative least squares) chromagram.
@@ -3704,7 +4068,7 @@ interface NnlsChromaRequest extends GuardedOptions$2 {
  * @returns NNLS chroma result
  */
 declare function nnlsChroma(request: NnlsChromaRequest): WasmNnlsChromaResult;
-declare function nnlsChroma(samples: Float32Array, sampleRate?: number, options?: GuardedOptions$2): WasmNnlsChromaResult;
+declare function nnlsChroma(samples: Float32Array, sampleRate?: number, options?: Omit<NnlsChromaRequest, 'samples' | 'sampleRate'>): WasmNnlsChromaResult;
 /**
  * Compute the Constant-Q Transform magnitude.
  *
@@ -3753,7 +4117,8 @@ declare function hybridCqt(samples: Float32Array, sampleRate?: number, hopLength
  * @param fmin - Minimum frequency in Hz (default: 32.70319566257483, C1)
  * @param nBins - Number of frequency bins (default: 84)
  * @param binsPerOctave - Bins per octave (default: 12)
- * @param gamma - Bandwidth offset; 0 is equivalent to CQT (default: 0)
+ * @param gamma - Bandwidth offset; negative selects the automatic ERB-derived
+ *   value, while 0 is equivalent to CQT (default: -1)
  * @returns VQT magnitude result (same shape as CQT)
  */
 declare function vqt(request: VqtRequest): CqtResult;
@@ -3794,7 +4159,7 @@ interface MelodyOptions {
      */
     usePyin?: boolean;
     /**
-     * When {@link usePyin} is `true`, reflect-pad by `frameLength / 2` so frame
+     * When {@link usePyin} is `true`, zero-pad by `frameLength / 2` so frame
      * `i` is centered at `i * hopLength` (matches `librosa.pyin(center=True)`).
      * Ignored by the plain-YIN path. Defaults to `true`.
      */
@@ -3845,7 +4210,7 @@ declare function onsetStrengthMulti(samples: Float32Array, sampleRate?: number,
  * @returns Fourier tempogram result
  */
 declare function fourierTempogram(request: FourierTempogramRequest): WasmFourierTempogramResult;
-declare function fourierTempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number, options?: GuardedOptions$2): WasmFourierTempogramResult;
+declare function fourierTempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number, center?: boolean, norm?: boolean, options?: GuardedOptions$2): WasmFourierTempogramResult;
 /**
  * Compute tempogram ratio features.
  *
@@ -3900,8 +4265,8 @@ declare function shortTermLufs(samples: Float32Array, sampleRate?: number, optio
  * @param hopLength - Hop length (default: 512)
  * @param fmin - Minimum frequency in Hz (default: 65)
  * @param fmax - Maximum frequency in Hz (default: 2093)
- * @param threshold - YIN threshold (default: 0.3)
- * @param fillNa - If true, return 0 for unvoiced f0 frames; otherwise keep NaN (default: false)
+ * @param threshold - YIN threshold (default: 0.1)
+ * @param fillNa - Retained for compatibility; YIN always returns a finite per-frame estimate.
  * @returns Pitch detection result
  */
 interface PitchYinRequest {
@@ -3914,6 +4279,18 @@ interface PitchYinRequest {
     threshold?: number;
     fillNa?: boolean;
 }
+interface PiptrackRequest {
+    samples: Float32Array;
+    sampleRate?: number;
+    nFft?: number;
+    hopLength?: number;
+    fmin?: number;
+    fmax?: number;
+    threshold?: number;
+}
+/** Per-bin spectral pitch candidates and peak magnitudes (librosa.piptrack). */
+declare function piptrack(request: PiptrackRequest): PiptrackResult;
+declare function piptrack(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number): PiptrackResult;
 declare function pitchYin(request: PitchYinRequest): PitchResult;
 declare function pitchYin(samples: Float32Array, sampleRate?: number, frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number, fillNa?: boolean): PitchResult;
 /**
@@ -3925,7 +4302,7 @@ declare function pitchYin(samples: Float32Array, sampleRate?: number, frameLengt
  * @param hopLength - Hop length (default: 512)
  * @param fmin - Minimum frequency in Hz (default: 65)
  * @param fmax - Maximum frequency in Hz (default: 2093)
- * @param threshold - YIN threshold (default: 0.3)
+ * @param threshold - YIN threshold (default: 0.1)
  * @param fillNa - If true, return 0 for unvoiced f0 frames; otherwise keep NaN (default: false)
  * @returns Pitch detection result
  */
@@ -3933,6 +4310,22 @@ interface PitchPyinRequest extends PitchYinRequest {
 }
 declare function pitchPyin(request: PitchPyinRequest): PitchResult;
 declare function pitchPyin(samples: Float32Array, sampleRate?: number, frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number, fillNa?: boolean): PitchResult;
+/** Parameters for segmenting an F0 track into stable monophonic notes. */
+interface NoteSegmentsRequest {
+    f0Hz: Float32Array;
+    voicedProb: Float32Array;
+    frameRate: number;
+    segmentationThresholdCents?: number;
+    minNoteMs?: number;
+    referenceHz?: number;
+}
+/**
+ * Segment a caller-supplied monophonic F0 track into stable note regions.
+ *
+ * `f0Hz` and `voicedProb` must have the same non-zero length. Zero-Hz frames
+ * and probabilities below 0.5 are treated as unvoiced.
+ */
+declare function noteSegments(request: NoteSegmentsRequest): NoteSegment[];
 
 /**
  * Resample audio to a different sample rate.
@@ -4009,6 +4402,59 @@ interface NnFilterRequest {
     k?: number;
     width?: number;
 }
+interface SegmentCrossSimilarityRequest {
+    x: Float32Array;
+    xRows: number;
+    xCols: number;
+    y: Float32Array;
+    yRows: number;
+    yCols: number;
+    k?: number;
+    metric?: 'cosine' | 'euclidean';
+    mode?: 'connectivity' | 'affinity';
+}
+interface SegmentRecurrenceMatrixRequest {
+    data: Float32Array;
+    rows: number;
+    cols: number;
+    k?: number;
+    width?: number;
+    sym?: boolean;
+    metric?: 'cosine' | 'euclidean';
+    mode?: 'connectivity' | 'affinity';
+}
+interface SegmentRecurrenceToLagRequest {
+    recurrence: Float32Array;
+    n: number;
+    pad?: boolean;
+}
+interface SegmentLagToRecurrenceRequest {
+    lag: Float32Array;
+    rows: number;
+    lags: number;
+}
+interface SegmentSubsegmentRequest {
+    data: Float32Array;
+    rows: number;
+    cols: number;
+    boundaries: Int32Array;
+    nSegments?: number;
+}
+interface SegmentAgglomerativeRequest {
+    data: Float32Array;
+    rows: number;
+    cols: number;
+    k: number;
+    linkage?: 'average' | 'single' | 'complete' | 'ward';
+}
+interface SegmentPathEnhanceRequest {
+    recurrence: Float32Array;
+    n: number;
+    win: number;
+    maxRatio?: number;
+    minRatio?: number;
+    nFilters?: number;
+}
 interface RemixRequest {
     samples: Float32Array;
     intervals: Int32Array | ArrayLike<number>;
@@ -4106,7 +4552,7 @@ declare function remix(samples: Float32Array, intervals: Int32Array | ArrayLike<
  * Phase-vocoder time-scale modification (rate > 1 faster, < 1 slower).
  */
 declare function phaseVocoder(request: PhaseVocoderRequest): Float32Array;
-declare function phaseVocoder(samples: Float32Array, rate: number, sampleRate?: number, nFft?: number, hopLength?: number): Float32Array;
+declare function phaseVocoder(samples: Float32Array, sampleRate: number, rate: number, nFft?: number, hopLength?: number): Float32Array;
 /**
  * HPSS into harmonic / percussive / residual signals.
  */
@@ -4139,8 +4585,10 @@ declare function ebur128LoudnessRange(samples: Float32Array, sampleRate?: number
  * @param hopLength - Hop length (default: 512)
  * @returns Spectral bandwidth in Hz for each frame
  */
-declare function spectralBandwidth(request: SpectralFrameRequest): Float32Array;
-declare function spectralBandwidth(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number): Float32Array;
+declare function spectralBandwidth(request: SpectralFrameRequest & {
+    p?: number;
+}): Float32Array;
+declare function spectralBandwidth(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, p?: number): Float32Array;
 /**
  * Compute spectral rolloff frequency.
  *
@@ -4164,6 +4612,10 @@ declare function spectralRolloff(samples: Float32Array, sampleRate?: number, nFf
  */
 declare function spectralFlatness(request: SpectralFrameRequest): Float32Array;
 declare function spectralFlatness(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number): Float32Array;
+declare function spectralFlux(request: SpectralFrameRequest & {
+    lag?: number;
+}): Float32Array;
+declare function spectralFlux(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, lag?: number): Float32Array;
 /**
  * Compute zero crossing rate.
  *
@@ -4186,6 +4638,20 @@ declare function zeroCrossingRate(samples: Float32Array, sampleRate?: number, fr
  */
 declare function rmsEnergy(request: ZeroCrossingRateRequest): Float32Array;
 declare function rmsEnergy(samples: Float32Array, sampleRate?: number, frameLength?: number, hopLength?: number): Float32Array;
+/** Column-wise cross-similarity (librosa.segment.cross_similarity). */
+declare function segmentCrossSimilarity(request: SegmentCrossSimilarityRequest): SegmentMatrix;
+/** Self-similarity recurrence matrix (librosa.segment.recurrence_matrix). */
+declare function segmentRecurrenceMatrix(request: SegmentRecurrenceMatrixRequest): SegmentMatrix;
+/** Convert an `n × n` recurrence matrix to a lag matrix. */
+declare function segmentRecurrenceToLag(request: SegmentRecurrenceToLagRequest): SegmentMatrix;
+/** Convert a lag matrix back to an `n × n` recurrence matrix. */
+declare function segmentLagToRecurrence(request: SegmentLagToRecurrenceRequest): SegmentMatrix;
+/** Refine frame boundaries by clustering within each parent segment. */
+declare function segmentSubsegment(request: SegmentSubsegmentRequest): Int32Array;
+/** Cluster feature columns and return one label per column. */
+declare function segmentAgglomerative(request: SegmentAgglomerativeRequest): Int32Array;
+/** Enhance diagonal paths in an `n × n` recurrence matrix. */
+declare function segmentPathEnhance(request: SegmentPathEnhanceRequest): SegmentMatrix;
 
 type GuardedOptions$1 = ValidateOptions;
 /** Canonical request form for basic frame-based spectrogram features. */
@@ -4200,6 +4666,7 @@ interface ChromaSpectrogramRequest extends GuardedOptions$1 {
     sampleRate?: number;
     hopLength?: number;
     nChroma?: number;
+    binsPerOctave?: number;
 }
 interface MelSpectrogramRequest extends SpectrogramRequest {
     nMels?: number;
@@ -4211,11 +4678,23 @@ interface MfccRequest extends MelSpectrogramRequest {
     nMfcc?: number;
     lifter?: number;
 }
+interface MelDeltaRequest extends GuardedOptions$1 {
+    features: Float32Array;
+    nFeatures: number;
+    nFrames: number;
+    width?: number;
+}
+interface ReassignedSpectrogramRequest extends SpectrogramRequest {
+    refPower?: number;
+    fillNan?: boolean;
+}
 interface MfccToMelRequest extends GuardedOptions$1 {
     mfccCoefficients: Float32Array;
     nMfcc: number;
     nFrames: number;
     nMels?: number;
+    /** Lifter used by the forward MFCC transform; zero means no liftering. */
+    lifter?: number;
 }
 /** Canonical request form for reconstruction from a Mel power spectrogram. */
 interface MelToStftRequest extends GuardedOptions$1 {
@@ -4233,6 +4712,16 @@ interface MelToAudioRequest extends MelToStftRequest {
     hopLength?: number;
     nIter?: number;
 }
+interface GriffinLimRequest extends GuardedOptions$1 {
+    magnitude: Float32Array;
+    nBins: number;
+    nFrames: number;
+    sampleRate?: number;
+    nFft?: number;
+    hopLength?: number;
+    nIter?: number;
+    momentum?: number;
+}
 /** Canonical request form for Griffin-Lim reconstruction from MFCCs. */
 interface MfccToAudioRequest extends MfccToMelRequest {
     sampleRate?: number;
@@ -4298,7 +4787,7 @@ declare function stftDb(samples: Float32Array, sampleRate?: number, nFft?: numbe
  * @returns Chroma result
  */
 declare function chromaCens(request: ChromaSpectrogramRequest): ChromaResult;
-declare function chromaCens(samples: Float32Array, sampleRate?: number, hopLength?: number, nChroma?: number, options?: GuardedOptions$1): ChromaResult;
+declare function chromaCens(samples: Float32Array, sampleRate?: number, hopLength?: number, nChroma?: number, binsPerOctave?: number, options?: GuardedOptions$1): ChromaResult;
 /**
  * Compute a constant-Q chromagram (librosa.feature.chroma_cqt).
  *
@@ -4309,7 +4798,7 @@ declare function chromaCens(samples: Float32Array, sampleRate?: number, hopLengt
  * @returns Chroma result
  */
 declare function chromaCqt(request: ChromaSpectrogramRequest): ChromaResult;
-declare function chromaCqt(samples: Float32Array, sampleRate?: number, hopLength?: number, nChroma?: number, options?: GuardedOptions$1): ChromaResult;
+declare function chromaCqt(samples: Float32Array, sampleRate?: number, hopLength?: number, nChroma?: number, binsPerOctave?: number, options?: GuardedOptions$1): ChromaResult;
 /**
  * Compute low-frequency bass chroma.
  *
@@ -4354,6 +4843,12 @@ declare function melSpectrogram(samples: Float32Array, sampleRate?: number, nFft
  */
 declare function mfcc(request: MfccRequest): MfccResult;
 declare function mfcc(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, nMels?: number, nMfcc?: number, fmin?: number, fmax?: number, htk?: boolean, lifter?: number, options?: GuardedOptions$1): MfccResult;
+/** First-order regression delta of a row-major feature matrix. */
+declare function melDelta(request: MelDeltaRequest): Float32Array;
+declare function melDelta(features: Float32Array, nFeatures: number, nFrames: number, width?: number): Float32Array;
+/** Auger-Flandrin reassigned spectrogram (row-major [nBins x nFrames] arrays). */
+declare function reassignedSpectrogram(request: ReassignedSpectrogramRequest): ReassignedSpectrogramResult;
+declare function reassignedSpectrogram(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, refPower?: number, fillNan?: boolean): ReassignedSpectrogramResult;
 /**
  * Approximate inverse of a Mel filterbank: Mel power spectrogram -> STFT power
  * spectrogram. Mirrors `feature::mel_to_stft`.
@@ -4388,6 +4883,9 @@ declare function melToStft(melPower: Float32Array, nMels: number, nFrames: numbe
  */
 declare function melToAudio(request: MelToAudioRequest): Float32Array;
 declare function melToAudio(melPower: Float32Array, nMels: number, nFrames: number, sampleRate?: number, nFft?: number, hopLength?: number, fmin?: number, fmax?: number, nIter?: number, htk?: boolean, options?: GuardedOptions$1): Float32Array;
+/** Reconstruct audio from an STFT magnitude matrix via Griffin-Lim. */
+declare function griffinLim(request: GriffinLimRequest): Float32Array;
+declare function griffinLim(magnitude: Float32Array, nBins: number, nFrames: number, sampleRate?: number, nFft?: number, hopLength?: number, nIter?: number, momentum?: number, options?: GuardedOptions$1): Float32Array;
 /**
  * Invert MFCC coefficients back to a Mel power spectrogram. Mirrors
  * `feature::mfcc_to_mel`.
@@ -4399,7 +4897,7 @@ declare function melToAudio(melPower: Float32Array, nMels: number, nFrames: numb
  * @returns Mel power spectrogram result
  */
 declare function mfccToMel(request: MfccToMelRequest): MelPowerResult;
-declare function mfccToMel(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels?: number, options?: GuardedOptions$1): MelPowerResult;
+declare function mfccToMel(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels?: number, lifter?: number, options?: GuardedOptions$1): MelPowerResult;
 /**
  * Reconstruct audio directly from MFCC coefficients via Griffin-Lim. Mirrors
  * `feature::mfcc_to_audio`.
@@ -4418,7 +4916,7 @@ declare function mfccToMel(mfccCoefficients: Float32Array, nMfcc: number, nFrame
  * @returns Reconstructed audio samples (mono, float32)
  */
 declare function mfccToAudio(request: MfccToAudioRequest): Float32Array;
-declare function mfccToAudio(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels?: number, sampleRate?: number, nFft?: number, hopLength?: number, fmin?: number, fmax?: number, nIter?: number, htk?: boolean, options?: GuardedOptions$1): Float32Array;
+declare function mfccToAudio(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels?: number, sampleRate?: number, nFft?: number, hopLength?: number, fmin?: number, fmax?: number, nIter?: number, htk?: boolean, lifter?: number, options?: GuardedOptions$1): Float32Array;
 /**
  * Compute STFT chromagram (librosa.feature.chroma_stft).
  *
@@ -4494,7 +4992,10 @@ declare enum SonareEngineTelemetryError {
     SmoothedParameterCapacity = 13,
     CommandBacklogDeferred = 14,
     ClipPageUnderrun = 15,
-    InsertAutomationOverflow = 16
+    InsertAutomationOverflow = 16,
+    MidiClockOverflow = 17,
+    MetronomeOverflow = 18,
+    InvalidCommand = 19
 }
 interface SonareMeterRingBuffer {
     sharedBuffer: SharedArrayBuffer;
@@ -4526,6 +5027,12 @@ interface SonareScopeRingBuffer {
     bands: number;
     maxPoints: number;
 }
+interface SonareExternalMidiRingBuffer {
+    sharedBuffer: SharedArrayBuffer;
+    header: Int32Array;
+    records: Uint32Array;
+    capacity: number;
+}
 interface SonareEngineCommandRecord {
     type: SonareEngineCommandType | number;
     targetId?: number;
@@ -4554,6 +5061,12 @@ interface SonareEngineTelemetryRingBuffer {
     view: DataView;
     capacity: number;
 }
+interface SonareClipPageRequestRingBuffer {
+    sharedBuffer: SharedArrayBuffer;
+    header: Int32Array;
+    records: Uint32Array;
+    capacity: number;
+}
 
 interface SonareRealtimeEngineWorkletProcessorOptions {
     wasmBinary?: ArrayBuffer | Uint8Array;
@@ -4573,6 +5086,16 @@ interface SonareRealtimeEngineWorkletProcessorOptions {
     scopeBands?: number;
     scopeSharedBuffer?: SharedArrayBuffer;
     scopeRingCapacity?: number;
+    /**
+     * Lock-free SPSC queue for clip-page cache misses. Supplying this is required
+     * for realtime-safe OPFS streaming: it avoids both embind object creation and
+     * postMessage structured cloning from AudioWorklet process().
+     */
+    clipPageRequestSharedBuffer?: SharedArrayBuffer;
+    clipPageRequestRingCapacity?: number;
+    /** Lock-free worklet-to-main-thread MIDI-1 output ring. */
+    externalMidiSharedBuffer?: SharedArrayBuffer;
+    externalMidiRingCapacity?: number;
 }
 interface SonareRealtimeEngineNodeCapabilities {
     mode: 'sab' | 'postMessage';
@@ -4580,6 +5103,10 @@ interface SonareRealtimeEngineNodeCapabilities {
     sharedArrayBuffer: boolean;
     atomics: boolean;
     audioWorklet: boolean;
+    /** True only when clip-page misses use the bounded SAB ring. */
+    clipPageRequestsRealtimeSafe: boolean;
+    /** True when external MIDI uses the SAB output ring rather than postMessage. */
+    externalMidiRealtimeSafe: boolean;
     engineAbiVersion?: number;
     expectedEngineAbiVersion?: number;
     abiCompatible?: boolean;
@@ -4605,6 +5132,12 @@ interface SonareWorkletExternalMidiEvent {
     /** MIDI 1.0 status + data bytes (1..3 entries). */
     bytes: number[];
 }
+/** A control-plane sync message that the worklet rejected without crashing. */
+interface SonareEngineSyncErrorMessage {
+    type: 'syncError';
+    syncType: SonareEngineSyncMessage['type'];
+    message: string;
+}
 interface SonareEngineSyncClipsMessage {
     type: 'syncClips';
     clips: EngineClip[];
@@ -4618,7 +5151,8 @@ interface SonareEngineSyncClipsDeltaMessage {
 interface SonareEngineSyncClipPageProviderMessage {
     type: 'syncClipPageProvider';
     clipId: number;
-    clip: EngineClip;
+    /** Omitted when an OPFS stream is primed before its clip is scheduled. */
+    clip?: EngineClip;
     numChannels: number;
     numSamples: number;
     pageFrames: number;
@@ -4630,10 +5164,41 @@ interface SonareEngineSyncClipPageMessage {
     pageIndex: number;
     channels: Float32Array[];
 }
+/** Evicts one page after the main-thread sliding window advances. */
+interface SonareEngineSyncClipPageClearMessage {
+    type: 'syncClipPageClear';
+    clipId: number;
+    pageIndex: number;
+}
+/** Releases a provider whose clip was removed or whose stream was closed. */
+interface SonareEngineSyncClipPageDestroyMessage {
+    type: 'syncClipPageDestroy';
+    clipId: number;
+}
 /** Makes a fully supplied paged clip visible to the audio engine. */
 interface SonareEngineSyncClipPageCommitMessage {
     type: 'syncClipPageCommit';
     clipId: number;
+    /**
+     * Clip schedule to publish with a provider that was primed before its
+     * schedule was known. The original pre-baked push path supplies it on the
+     * provider message instead.
+     */
+    clip?: EngineClip;
+}
+/**
+ * A bounded batch of page misses emitted by the AudioWorklet. The main thread
+ * resolves these from OPFS and responds with `syncClipPage`; a missing page is
+ * silent until that response arrives.
+ */
+interface SonareEngineClipPageRequestMessage {
+    type: 'clipPageRequest';
+    requests: Array<{
+        clipId: number;
+        pageIndex: number;
+    }>;
+    /** Number of misses dropped because a bounded native or SAB request queue was full. */
+    dropped?: number;
 }
 interface SonareEngineSyncMidiClipsMessage {
     type: 'syncMidiClips';
@@ -4652,6 +5217,11 @@ interface SonareEngineSyncAutomationMessage {
     paramId: number;
     points: EngineAutomationPoint[];
 }
+/** Replaces the live engine's registered custom-parameter set. */
+interface SonareEngineSyncParametersMessage {
+    type: 'syncParameters';
+    parameters: EngineParameterInfo[];
+}
 interface SonareEngineSyncTempoMessage {
     type: 'syncTempo';
     bpm: number;
@@ -4782,6 +5352,7 @@ interface SonareEngineSyncSf2InstrumentMessage {
         destinationId?: number;
         gain?: number;
         polyphony?: number;
+        preferModelForModeledFamilies?: boolean;
     };
 }
 interface SonareEngineSyncLoadSoundFontMessage {
@@ -4812,6 +5383,12 @@ interface SonareEngineSyncMidiCcMessage {
     value: number;
     renderFrame: number;
 }
+interface SonareEngineSyncMidiUmpMessage {
+    type: 'syncMidiUmp';
+    destinationId: number;
+    word0: number;
+    renderFrame: number;
+}
 interface SonareEngineSyncMidiSysexMessage {
     type: 'syncMidiSysex';
     destinationId: number;
@@ -4831,7 +5408,31 @@ interface SonareEngineSyncExternalMidiClockMessage {
     type: 'syncExternalMidiClock';
     enabled: boolean;
 }
-type SonareEngineSyncMessage = SonareEngineSyncClipsMessage | SonareEngineSyncClipsDeltaMessage | SonareEngineSyncClipPageProviderMessage | SonareEngineSyncClipPageMessage | SonareEngineSyncClipPageCommitMessage | SonareEngineSyncMidiClipsMessage | SonareEngineSyncMarkersMessage | SonareEngineSyncMetronomeMessage | SonareEngineSyncAutomationMessage | SonareEngineSyncTempoMessage | SonareEngineSyncMixerMessage | SonareEngineSyncCaptureMessage | SonareEngineSyncTrackStripEqBandMessage | SonareEngineSyncMasterStripEqBandMessage | SonareEngineSyncTrackStripInsertBypassedMessage | SonareEngineSyncMasterStripInsertBypassedMessage | SonareEngineSyncTrackStripInsertParamByNameMessage | SonareEngineSyncMasterStripInsertParamByNameMessage | SonareEngineSyncBusStripInsertParamByNameMessage | SonareEngineSyncTrackStripPanMessage | SonareEngineSyncTrackStripPanLawMessage | SonareEngineSyncTrackStripPanModeMessage | SonareEngineSyncTrackStripDualPanMessage | SonareEngineSyncTrackStripChannelDelaySamplesMessage | SonareEngineSyncBuiltinInstrumentMessage | SonareEngineSyncSynthInstrumentMessage | SonareEngineSyncSf2InstrumentMessage | SonareEngineSyncLoadSoundFontMessage | SonareEngineSyncMidiFxMessage | SonareEngineSyncMidiNoteMessage | SonareEngineSyncMidiCcMessage | SonareEngineSyncMidiSysexMessage | SonareEngineSyncMidiPanicMessage | SonareEngineSyncMidiDestinationExternalMessage | SonareEngineSyncExternalMidiClockMessage;
+interface SonareEngineSyncMidiInputSourceMessage {
+    type: 'syncMidiInputSource' | 'syncClearMidiInputSource';
+    destinationId?: number;
+}
+interface SonareEngineSyncMidiCcBindingMessage {
+    type: 'syncMidiCcBinding';
+    channel: number;
+    controller: number;
+    paramId: number;
+    minValue: number;
+    maxValue: number;
+}
+interface SonareEngineSyncMidiInputEventMessage {
+    type: 'syncMidiInputNoteOn' | 'syncMidiInputNoteOff' | 'syncMidiInputCc';
+    group: number;
+    channel: number;
+    data0: number;
+    data1: number;
+    portTimeSamples: number;
+}
+/** Releases the realtime engine and all worklet-owned clip buffers. */
+interface SonareEngineDestroyMessage {
+    type: 'destroy';
+}
+type SonareEngineSyncMessage = SonareEngineSyncClipsMessage | SonareEngineSyncClipsDeltaMessage | SonareEngineSyncClipPageProviderMessage | SonareEngineSyncClipPageMessage | SonareEngineSyncClipPageClearMessage | SonareEngineSyncClipPageCommitMessage | SonareEngineSyncClipPageDestroyMessage | SonareEngineSyncMidiClipsMessage | SonareEngineSyncMarkersMessage | SonareEngineSyncMetronomeMessage | SonareEngineSyncAutomationMessage | SonareEngineSyncParametersMessage | SonareEngineSyncTempoMessage | SonareEngineSyncMixerMessage | SonareEngineSyncCaptureMessage | SonareEngineSyncTrackStripEqBandMessage | SonareEngineSyncMasterStripEqBandMessage | SonareEngineSyncTrackStripInsertBypassedMessage | SonareEngineSyncMasterStripInsertBypassedMessage | SonareEngineSyncTrackStripInsertParamByNameMessage | SonareEngineSyncMasterStripInsertParamByNameMessage | SonareEngineSyncBusStripInsertParamByNameMessage | SonareEngineSyncTrackStripPanMessage | SonareEngineSyncTrackStripPanLawMessage | SonareEngineSyncTrackStripPanModeMessage | SonareEngineSyncTrackStripDualPanMessage | SonareEngineSyncTrackStripChannelDelaySamplesMessage | SonareEngineSyncBuiltinInstrumentMessage | SonareEngineSyncSynthInstrumentMessage | SonareEngineSyncSf2InstrumentMessage | SonareEngineSyncLoadSoundFontMessage | SonareEngineSyncMidiFxMessage | SonareEngineSyncMidiNoteMessage | SonareEngineSyncMidiCcMessage | SonareEngineSyncMidiUmpMessage | SonareEngineSyncMidiSysexMessage | SonareEngineSyncMidiPanicMessage | SonareEngineSyncMidiDestinationExternalMessage | SonareEngineSyncExternalMidiClockMessage | SonareEngineSyncMidiInputSourceMessage | SonareEngineSyncMidiCcBindingMessage | SonareEngineSyncMidiInputEventMessage | SonareEngineDestroyMessage;
 
 declare class SonareRealtimeEngineNode {
     readonly node: AudioWorkletNode;
@@ -4840,14 +5441,20 @@ declare class SonareRealtimeEngineNode {
     readonly telemetryRing?: SonareEngineTelemetryRingBuffer;
     readonly meterRing?: SonareMeterRingBuffer;
     readonly scopeRing?: SonareScopeRingBuffer;
+    readonly clipPageRequestRing?: SonareClipPageRequestRingBuffer;
+    readonly externalMidiRing?: SonareExternalMidiRingBuffer;
     readonly ready: Promise<void>;
     private telemetryReadIndex;
     private meterReadIndex;
     private scopeReadIndex;
+    private clipPageRequestDroppedRead;
+    private ringPollTimer;
     private telemetryListeners;
     private meterListeners;
     private scopeListeners;
     private midiOutListeners;
+    private clipPageRequestListeners;
+    private syncErrorListeners;
     private captureRequestId;
     private readonly captureRequests;
     private transportRequestId;
@@ -4856,6 +5463,8 @@ declare class SonareRealtimeEngineNode {
     private rejectReady;
     private destroyed;
     private constructor();
+    /** Subscribes to control-plane sync rejections reported by the worklet. */
+    onSyncError(listener: (message: SonareEngineSyncErrorMessage) => void): () => void;
     static create(context: BaseAudioContext, options?: SonareRealtimeEngineNodeOptions): Promise<SonareRealtimeEngineNode>;
     play(sampleTime?: number): boolean;
     stop(sampleTime?: number): boolean;
@@ -4869,6 +5478,14 @@ declare class SonareRealtimeEngineNode {
     pollTelemetry(): SonareEngineTelemetryRecord[];
     pollMeters(): SonareWorkletMeterSnapshot[];
     pollScope(): SonareWorkletScopeSnapshot[];
+    /** Drain lowered MIDI-1 records from the SAB ring on the main thread. */
+    pollMidiOut(): SonareWorkletExternalMidiEvent[];
+    /**
+     * Drains bounded paged-clip misses from the SAB ring and forwards one batch
+     * to subscribers. In postMessage mode the legacy handler remains available,
+     * but that degraded path is not realtime-safe for OPFS streaming.
+     */
+    pollClipPageRequests(): SonareEngineClipPageRequestMessage | undefined;
     onTelemetry(callback: (telemetry: SonareEngineTelemetryRecord) => void): () => void;
     onMeter(callback: (meter: SonareWorkletMeterSnapshot) => void): () => void;
     onScope(callback: (scope: SonareWorkletScopeSnapshot) => void): () => void;
@@ -4878,10 +5495,18 @@ declare class SonareRealtimeEngineNode {
      * Web MIDI output port. Returns an unsubscribe function.
      */
     onMidiOut(callback: (events: SonareWorkletExternalMidiEvent[]) => void): () => void;
+    /**
+     * Subscribe to bounded batches of paged-clip misses from the worklet. The
+     * callback runs on the main thread and may initiate asynchronous OPFS I/O.
+     */
+    onClipPageRequests(callback: (message: SonareEngineClipPageRequestMessage) => void): () => void;
     destroy(): void;
     private emitTelemetry;
+    private startRingPolling;
+    private stopRingPollingIfUnused;
     private emitMeter;
     private emitMidiOut;
+    private emitClipPageRequests;
     private emitScope;
     private sendCaptureRequest;
     private sendTransportRequest;
@@ -4960,6 +5585,13 @@ declare function meteringPeakDb(request: MeteringSamplesRequest): number;
 declare function meteringPeakDb(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): number;
 declare function meteringRmsDb(request: MeteringSamplesRequest): number;
 declare function meteringRmsDb(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): number;
+interface MeteringSilenceRatioRequest extends MeteringSamplesRequest {
+    thresholdDb?: number;
+    frameLength?: number;
+    hopLength?: number;
+}
+declare function meteringSilenceRatio(request: MeteringSilenceRatioRequest): number;
+declare function meteringSilenceRatio(samples: Float32Array, sampleRate?: number, thresholdDb?: number, frameLength?: number, hopLength?: number, options?: ValidateOptions): number;
 declare function meteringCrestFactorDb(request: MeteringSamplesRequest): number;
 declare function meteringCrestFactorDb(samples: Float32Array, sampleRate?: number, options?: ValidateOptions): number;
 declare function meteringDcOffset(request: MeteringSamplesRequest): number;
@@ -4979,7 +5611,7 @@ declare function meteringTruePeakDb(samples: Float32Array, sampleRate?: number,
 declare function meteringDetectClipping(request: MeteringDetectClippingRequest): ClippingReport;
 declare function meteringDetectClipping(samples: Float32Array, sampleRate?: number, options?: MeteringDetectClippingOptions): ClippingReport;
 /**
- * Sliding-window dynamic range. Pass 0 for window/hop to use the library
+ * Sliding-window dynamic range for mono audio. Pass 0 for window/hop to use the library
  * default (window=3 s, hop=1 s). The percentiles use a NEGATIVE sentinel for
  * "use the library default" (low=0.10, high=0.95) because 0 is a literal 0th
  * percentile; omitted percentiles therefore default to -1.
@@ -5079,7 +5711,7 @@ interface WaveformPeaksReport {
     bucketCount: number;
     samplesPerBucket: number;
 }
-/** Pearson correlation in [-1, 1] between two equal-length channels. */
+/** Uncentered correlation (cosine similarity) in [-1, 1] between equal-length channels. */
 declare function meteringStereoCorrelation(request: MeteringStereoRequest): number;
 declare function meteringStereoCorrelation(left: Float32Array, right: Float32Array, sampleRate?: number, options?: ValidateOptions): number;
 /**
@@ -5124,7 +5756,7 @@ declare function meteringPhaseScope(left: Float32Array, right: Float32Array, sam
 declare function meteringPhaseScopeDecimated(request: MeteringStereoDecimatedRequest): PhaseScopeReport;
 declare function meteringPhaseScopeDecimated(left: Float32Array, right: Float32Array, sampleRate?: number, maxPoints?: number, options?: ValidateOptions): PhaseScopeReport;
 /**
- * Welch-averaged magnitude / power / dB spectrum over the WHOLE signal (split
+ * Welch-averaged magnitude / power / dB spectrum over the WHOLE mono signal (split
  * into Hann-windowed, 50%-overlapping `nFft`-length frames whose power spectra
  * are averaged). For a true single-frame snapshot, use
  * {@link meteringSpectrumFrame}.
@@ -5152,12 +5784,29 @@ interface SamplesRequest extends GuardedOptions {
     samples: Float32Array;
     sampleRate?: number;
 }
+/** Peak-picking configuration for {@link detectOnsets}. */
+interface OnsetDetectOptions {
+    nFft?: number;
+    hopLength?: number;
+    threshold?: number;
+    preMax?: number;
+    postMax?: number;
+    preAvg?: number;
+    postAvg?: number;
+    delta?: number;
+    wait?: number;
+    backtrack?: boolean;
+    backtrackRange?: number;
+}
+interface DetectOnsetsRequest extends SamplesRequest, OnsetDetectOptions {
+}
 /** Canonical request form for key detection functions. */
 interface DetectKeyRequest extends KeyDetectionOptions, SamplesRequest {
 }
 /** Canonical request form for analysis with synchronous progress reporting. */
 interface AnalyzeWithProgressRequest extends SamplesRequest {
-    onProgress: ProgressCallback;
+    onProgress?: ProgressCallback;
+    cancel?: () => boolean;
 }
 /** Canonical request form for chord detection. */
 interface DetectChordsRequest extends ChordDetectionOptions, SamplesRequest {
@@ -5219,8 +5868,8 @@ declare function detectKeyCandidates(samples: Float32Array, sampleRate?: number,
  * @param sampleRate - Sample rate in Hz (default: 22050)
  * @returns Array of onset times in seconds
  */
-declare function detectOnsets(request: SamplesRequest): Float32Array;
-declare function detectOnsets(samples: Float32Array, sampleRate?: number, options?: GuardedOptions): Float32Array;
+declare function detectOnsets(request: DetectOnsetsRequest): Float32Array;
+declare function detectOnsets(samples: Float32Array, sampleRate?: number, options?: OnsetDetectOptions & GuardedOptions): Float32Array;
 /**
  * Detect beat times from audio samples.
  *
@@ -5273,8 +5922,26 @@ declare function chordFunctionalAnalysis(samples: Float32Array, keyRoot: PitchCl
  * the UI responsive for long inputs, drive this from a Web Worker and use
  * {@link analyzeWithProgress} to report progress.
  */
-declare function analyze(request: SamplesRequest): AnalysisResult;
-declare function analyze(samples: Float32Array, sampleRate?: number, options?: GuardedOptions): AnalysisResult;
+interface MusicAnalyzeOptions {
+    nFft?: number;
+    hopLength?: number;
+    bpmMin?: number;
+    bpmMax?: number;
+    startBpm?: number;
+    useTriadsOnly?: boolean;
+    useHpss?: boolean;
+    chromaHighpassHz?: number;
+    useBassWeighted?: boolean;
+    chromaHopMultiplier?: number;
+    useChordHmm?: boolean;
+    useChordKeyContext?: boolean;
+    chordHmmBeamWidth?: number;
+    detectChordInversions?: boolean;
+}
+interface MusicAnalyzeRequest extends SamplesRequest, MusicAnalyzeOptions {
+}
+declare function analyze(request: MusicAnalyzeRequest): AnalysisResult;
+declare function analyze(samples: Float32Array, sampleRate?: number, options?: GuardedOptions & MusicAnalyzeOptions): AnalysisResult;
 declare function analyzeImpulseResponse(request: AnalyzeImpulseResponseRequest): AcousticResult;
 declare function analyzeImpulseResponse(samples: Float32Array, sampleRate?: number, nOctaveBands?: number): AcousticResult;
 declare function detectAcoustic(request: DetectAcousticRequest): AcousticResult;
@@ -5754,7 +6421,10 @@ declare class Mixer {
      * @param blockSize - Maximum block size per {@link processStereo} call (default: 512)
      */
     static fromSceneJson(json: string, sampleRate?: number, blockSize?: number): Mixer;
-    /** Rebuild and compile the routing graph from the current scene topology. */
+    /**
+     * Rebuild and compile the routing graph without resetting its absolute
+     * automation sample position or queued strip automation.
+     */
     compile(): void;
     /**
      * Non-fatal warnings captured when this mixer was built from scene JSON: one
@@ -5828,6 +6498,8 @@ declare class Mixer {
     addVcaGroup(id: string, gainDb?: number, members?: string[]): void;
     /** Set an existing VCA group's gain in dB. */
     setVcaGroupGainDb(id: string, gainDb: number): void;
+    /** Replace an existing VCA group's strip membership. */
+    setVcaGroupMembers(id: string, members: string[]): void;
     /** Remove a VCA group by id. */
     removeVcaGroup(id: string): void;
     /** Number of VCA groups in the mixer topology. */
@@ -5923,6 +6595,8 @@ declare class Mixer {
      *   the tap-less post-fader strip meter is read.
      */
     stripMeter(stripIndex: number, tap?: MeterTap | number): MixMeterSnapshot;
+    /** Read the post-insert meter for a compiled bus, including master. */
+    busMeter(busId: string): MixMeterSnapshot;
     /**
      * Schedule sample-accurate fader automation on a strip.
      *
@@ -6025,12 +6699,28 @@ interface RealtimeVoiceChangerPlanarBuffer {
 }
 declare class RealtimeVoiceChanger {
     private changer;
-    constructor(config?: RealtimeVoiceChangerConfigInput);
+    /**
+     * Creates a voice changer. Supplying `sampleRate` prepares it immediately,
+     * matching the Node and Python constructors; omitting it preserves the
+     * explicit {@link prepare} lifecycle for callers that configure later.
+     */
+    constructor(config?: RealtimeVoiceChangerConfigInput | RealtimeVoiceChangerPodConfig, sampleRate?: number, maxBlockSize?: number, channels?: number);
     prepare(sampleRate: number, maxBlockSize?: number, channels?: number): void;
     reset(): void;
     setConfig(config: RealtimeVoiceChangerConfigInput | RealtimeVoiceChangerPodConfig): void;
+    /**
+     * Apply a flat, pre-normalized config without JSON serialization. Intended
+     * for AudioWorklet control messages whose sender prepared the POD on the
+     * main thread.
+     */
+    setPodConfig(config: RealtimeVoiceChangerPodConfig): void;
     configJson(): string;
     latencySamples(): number;
+    /**
+     * Monotonically increases whenever {@link prepare} can replace the native
+     * scratch buffers. Cached WASM heap views must be reacquired after it changes.
+     */
+    bufferGeneration(): number;
     processMono(samples: Float32Array): Float32Array;
     processMonoInto(samples: Float32Array, output: Float32Array): void;
     processInterleaved(samples: Float32Array, channels: number): Float32Array;
@@ -6146,6 +6836,18 @@ declare class StreamingMasteringChain {
         left: Float32Array;
         right: Float32Array;
     };
+    /**
+     * Emit delayed audio and finite processor tails after the final mono block.
+     * Call until this returns an empty array. The initial `latencySamples()`
+     * samples of the concatenated stream are delayed and should be discarded for
+     * time-aligned output.
+     */
+    flushMono(): Float32Array;
+    /** Stereo counterpart of {@link flushMono}. */
+    flushStereo(): {
+        left: Float32Array;
+        right: Float32Array;
+    };
     /** Reset all processor state without rebuilding. */
     reset(): void;
     /** Total reported latency in samples across all active processors. */
@@ -6271,6 +6973,14 @@ declare class StreamingRetune {
     delete(): void;
 }
 
+interface WebMidiEngine {
+    bindMidiCc(channel: number, controller: number, paramId: number, options?: MidiCcBindOptions): void;
+    setMidiInputSource(destinationId?: number): void;
+    clearMidiInputSource(): void;
+    pushMidiInputNoteOn(group: number, channel: number, note: number, velocity: number, time?: number): void;
+    pushMidiInputNoteOff(group: number, channel: number, note: number, velocity?: number, time?: number): void;
+    pushMidiInputCc(group: number, channel: number, controller: number, value: number, time?: number): void;
+}
 type MidiInputState = 'connected' | 'disconnected';
 interface MidiPortLike {
     id: string;
@@ -6336,7 +7046,99 @@ interface WebMidiBinding {
     close(): void;
 }
 declare function isWebMidiAvailable(): boolean;
-declare function bindWebMidi(engine: RealtimeEngine, options?: BindWebMidiOptions): Promise<WebMidiBinding>;
+declare function bindWebMidi(engine: WebMidiEngine, options?: BindWebMidiOptions): Promise<WebMidiBinding>;
+
+type WorkerRequest<T> = Omit<T, 'onProgress'>;
+/** Progress relayed from the Worker at the core's native progress boundaries. */
+interface OfflineWorkerProgress {
+    progress: number;
+    stage: string;
+}
+/** Per-call behaviour for a one-shot operation. */
+interface OfflineWorkerCallOptions {
+    /**
+     * Preserve the caller's input arrays by copying them before dispatch.
+     *
+     * The default is `false`: `Float32Array` buffers are transferred to the
+     * Worker and become detached on the calling thread, avoiding a second copy.
+     */
+    copy?: boolean;
+    /** Receives native progress boundaries for analysis and mastering calls. */
+    onProgress?: (update: OfflineWorkerProgress) => void;
+}
+/** Options used to create an {@link OfflineWorkerClient}. */
+interface OfflineWorkerClientOptions {
+    /** Reuse a Worker owned by the host instead of creating one. */
+    worker?: OfflineWorker;
+    /** URL of the Worker entry; defaults to the adjacent published `worker.js`. */
+    workerUrl?: string | URL;
+    /** Test/host hook for creating a dedicated Worker. */
+    workerFactory?: (url: URL) => OfflineWorker;
+    /** Terminate a supplied Worker when {@link OfflineWorkerClient.dispose} runs. */
+    terminateWorkerOnDispose?: boolean;
+}
+/** Browser Worker or Node `worker_threads.Worker` used by the client. */
+interface OfflineWorker {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    terminate(): unknown;
+    addEventListener?(type: string, listener: EventListener): void;
+    removeEventListener?(type: string, listener: EventListener): void;
+    on?(type: 'message' | 'error', listener: (...args: unknown[]) => void): unknown;
+    off?(type: 'message' | 'error', listener: (...args: unknown[]) => void): unknown;
+}
+/**
+ * A cancellable promise returned by an {@link OfflineWorkerClient} call.
+ *
+ * It is Promise-like, so `await client.analyze(...)` works. Call `cancel()` to
+ * request cancellation at the next native progress boundary. In browsers this
+ * uses a `SharedArrayBuffer` flag, which requires cross-origin isolation for
+ * prompt cancellation while synchronous WASM is running. The worker forwards
+ * that flag through the same native cancellation callback used by synchronous
+ * one-shot requests.
+ */
+declare class OfflineWorkerTask<T> implements PromiseLike<T> {
+    readonly result: Promise<T>;
+    private readonly cancelRequest;
+    constructor(result: Promise<T>, cancelRequest: () => void);
+    cancel(): void;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+/**
+ * Owns a dedicated Worker for value-based offline analysis and mastering.
+ *
+ * `Project`, `Mixer`, and realtime APIs are intentionally absent: their native
+ * handles are local to one JavaScript realm and cannot be transferred safely.
+ */
+declare class OfflineWorkerClient {
+    private readonly worker;
+    private readonly ownsWorker;
+    private readonly pending;
+    private nextId;
+    private closed;
+    private usesEventTarget;
+    constructor(options?: OfflineWorkerClientOptions);
+    /** Dispatch full music analysis to the Worker. */
+    analyze(request: WorkerRequest<MusicAnalyzeRequest>, options?: OfflineWorkerCallOptions): OfflineWorkerTask<ReturnType<typeof analyze>>;
+    /** Dispatch BPM detection to the Worker. */
+    detectBpm(request: SamplesRequest, options?: OfflineWorkerCallOptions): OfflineWorkerTask<number>;
+    /** Dispatch key detection to the Worker. */
+    detectKey(request: DetectKeyRequest, options?: OfflineWorkerCallOptions): OfflineWorkerTask<ReturnType<typeof detectKey>>;
+    /** Dispatch chord detection to the Worker. */
+    detectChords(request: DetectChordsRequest, options?: OfflineWorkerCallOptions): OfflineWorkerTask<ReturnType<typeof detectChords>>;
+    /** Dispatch mono preset mastering to the Worker. */
+    masterAudio(request: WorkerRequest<MasterAudioRequest>, options?: OfflineWorkerCallOptions): OfflineWorkerTask<ReturnType<typeof masterAudio>>;
+    /** Dispatch stereo preset mastering to the Worker. */
+    masterAudioStereo(request: WorkerRequest<MasterAudioStereoRequest>, options?: OfflineWorkerCallOptions): OfflineWorkerTask<ReturnType<typeof masterAudioStereo>>;
+    /** Stop accepting calls, reject outstanding work, and release the Worker if owned. */
+    dispose(): void;
+    private call;
+    private readonly onMessage;
+    private readonly onError;
+    private readonly onNodeMessage;
+    private readonly onNodeError;
+}
 
 /**
  * sonare - Audio Analysis Library
@@ -6387,6 +7189,14 @@ declare function isInitialized(): boolean;
  * Get the library version.
  */
 declare function version(): string;
+/**
+ * Return the capabilities of the loaded WASM build.
+ *
+ * This is synchronous and only describes the already-initialized module.
+ */
+declare function capabilities(): SonareCapabilities;
+/** Return the initialized module's processors, parameters, and presets. */
+declare function capabilityCatalog(): CapabilityCatalog;
 /**
  * Aggregate native ABI version: the per-subsystem ABI macros folded into one
  * 32-bit value. It bumps whenever any flat C POD layout changes, so callers can
@@ -6397,14 +7207,14 @@ declare function engineAbiVersion(): number;
 declare function voiceChangerAbiVersion(): number;
 /**
  * Map a voice-character preset ordinal (or canonical id) to its canonical id
- * string (e.g. `'bright-idol'`). Returns `null` for an out-of-range ordinal.
+ * string (e.g. `'bright-idol'`). Invalid ordinals throw.
  */
-declare function voiceCharacterPresetId(preset: VoicePresetId | number): string | null;
+declare function voiceCharacterPresetId(preset: VoicePresetId | number): string;
 /**
  * Return the canonical (normalized) flat POD config for a built-in voice
  * preset, skipping the JSON round-trip. Accepts a canonical preset id or its
- * integer ordinal. Returns `null` for an out-of-range ordinal.
+ * integer ordinal. Invalid ordinals throw.
  */
-declare function realtimeVoiceChangerPresetConfig(preset: VoicePresetId | number): RealtimeVoiceChangerPodConfig | null;
+declare function realtimeVoiceChangerPresetConfig(preset: VoicePresetId | number): RealtimeVoiceChangerPodConfig;
 
-export { type AcousticOptions, type AcousticResult, type AnalysisResult, type AnalyzeBpmOptions, type AnalyzeBpmRequest, type AnalyzeDynamicsOptions, type AnalyzeDynamicsRequest, type AnalyzeImpulseResponseRequest, type AnalyzeMelodyRequest, type AnalyzeRhythmOptions, type AnalyzeRhythmRequest, type AnalyzeSectionsOptions, type AnalyzeSectionsRequest, type AnalyzeTimbreOptions, type AnalyzeTimbreRequest, type AnalyzeWithProgressRequest, type AnalyzerStats, Audio, type AutomationCurve, type BarChord, type Beat, type BindMicrophoneInputOptions, type BindWebMidiOptions, type BpmAnalysisResult, type BpmCandidate, type BrowserAudioDecodeOptions, type BuiltinSynthBinding, type BuiltinSynthConfig, type BuiltinSynthWaveform, type Chord, type ChordAnalysisResult, type ChordChange, type ChordDetectionOptions, type ChordFunctionalAnalysisRequest, ChordQuality, type ChromaResult, type ChromaSpectrogramRequest, type ClipPageRequest, type ClipPageStreamSource, ClipPageStreamer, type ClipPageStreamerEngine, type ClipPageStreamerOptions, type ClippingRegion, type ClippingReport, type CompressorDetector, type CompressorOptions, type CqtRequest, type CqtResult, type CqtToAudioRequest, type CyclicTempogramRequest, type DbConversionRequest, type DeclickOptions, type DeclipOptions, type DecomposeRequest, type DecomposeResult, type DecomposeWithInitRequest, type DecrackleMode, type DecrackleOptions, type DehumOptions, type DenoiseClassicalMode, type DenoiseClassicalNoiseEstimator, type DenoiseClassicalOptions, type DereverbClassicalOptions, type DetectAcousticRequest, type DetectChordsRequest, type DetectKeyRequest, type DynamicRangeReport, type Dynamics, type DynamicsAnalysisResult, type DynamicsResult, EXPECTED_ENGINE_ABI_VERSION, EXPECTED_PROJECT_ABI_VERSION, type Ebur128LoudnessRangeRequest, type EmphasisRequest, type EngineAutomationPoint, type EngineBounceOptions, type EngineBounceResult, type EngineBus, type EngineCapabilities, type EngineCaptureStatus, type EngineClip, type EngineFreezeOptions, type EngineFreezeResult, type EngineGraphSpec, type EngineMarker, type EngineMeterTelemetry, type EngineMeterTelemetryWide, type EngineMetronomeConfig, type EngineMidiClipSchedule, type EngineMidiEvent, type EngineParameterInfo, type EngineScopeTelemetry, type EngineTelemetry, type EngineTempoSegment, type EngineTimeSignatureSegment, type EngineTrackLane, type EngineTrackSend, type EngineTransportState, type EqBand, type EqBandPhase, type EqBandType, type EqCoeffMode, type EqMatchOptions, type EqSpectrumSnapshot, type EqStereoPlacement, ErrorCode, type EstimateRoomRequest, type EstimateTuningRequest, type ExternalMidiEvent, type FixFramesRequest, type FixLengthRequest, type FourierTempogramRequest, type FrameBuffer, type FrameSignalRequest, type GateOptions, type GoniometerPoint, type HarmonicRequest, type HpssRequest, type HpssResult, type HpssWithResidualRequest, type HpssWithResidualResult, type Key, type KeyCandidate, type KeyDetectionOptions, KeyProfile, type KeyProfileName, type LufsInterleavedRequest, type LufsRequest, type LufsResult, MarkerKind, type MasterAudioRequest, type MasterAudioStereoRequest, type MasteringChainConfig, type MasteringChainRequest, type MasteringChainResult, type MasteringChainStereoRequest, type MasteringChainStereoResult, type MasteringChannelPolicy, type MasteringDynamicsCompressorRequest, type MasteringDynamicsGateRequest, type MasteringDynamicsTransientShaperRequest, type MasteringInsertParamInfo, type MasteringOptions, type MasteringPairAnalyzeRequest, type MasteringPairProcessRequest, type MasteringPreset, type MasteringProcessRequest, type MasteringProcessStereoRequest, type MasteringProcessorCatalogEntry, type MasteringProcessorParams, type MasteringRepairDeclickRequest, type MasteringRepairDeclipRequest, type MasteringRepairDecrackleRequest, type MasteringRepairDehumRequest, type MasteringRepairDenoiseClassicalRequest, type MasteringRepairDereverbClassicalRequest, type MasteringRepairTrimSilenceRequest, type MasteringRequest, type MasteringResult, type MasteringSamplesParamsRequest, type MasteringStereoAnalyzeRequest, type MasteringStereoChainResult, type MasteringStereoResult, type MasteringStreamingPreviewRequest, type Matrix2dResult, type MelPowerResult, type MelSpectrogramRequest, type MelSpectrogramResult, type MelToAudioRequest, type MelToStftRequest, type MelodyOptions, type MelodyPoint, type MelodyResult, type MeterTap, type MeteringDetectClippingOptions, type MeteringDetectClippingRequest, type MeteringDynamicRangeOptions, type MeteringDynamicRangeRequest, type MeteringSamplesRequest, type MeteringSpectrumFrameRequest, type MeteringSpectrumRequest, type MeteringStereoDecimatedRequest, type MeteringStereoRequest, type MeteringTruePeakRequest, type MfccRequest, type MfccResult, type MfccToAudioRequest, type MfccToMelRequest, type MicrophoneInputBinding, type MidiCcBindOptions, type MidiCcLearnOptions, type MixMeterSnapshot, type MixOptions, type MixResult, type MixStereoRequest, Mixer, type MixerProcessResult, type MixerRealtimeBuffer, Mode, type NnFilterRequest, type NnlsChromaRequest, type NormalizeRequest, type NoteMoveRequest, type NoteStretchOptions, type NoteStretchRequest, type OnsetEnvelopeRequest, type OnsetStrengthMultiRequest, type OpfsClipPageProviderBinding, type OpfsClipPageProviderOptions, type OpfsClipStream, type OpfsClipStreamOptions, type PadCenterRequest, type PairAnalysis, type PairProcessor, type PanLaw, type PanMode, type PatternScore, type PcenRequest, type PeakPickRequest, type PercussiveRequest, type PhaseScopeReport, type PhaseVocoderRequest, PitchClass as Pitch, PitchClass, type PitchCorrectOptions, type PitchCorrectTimevaryingRequest, type PitchCorrectToMidiRequest, type PitchCorrectToMidiTimevaryingRequest, type PitchPyinRequest, type PitchResult, type PitchShiftRequest, type PitchTuningRequest, type PitchYinRequest, type PlpRequest, type PolyFeaturesRequest, type ProgressiveEstimate, Project, type ProjectAssistSidecar, type ProjectAutomationCurve, type ProjectAutomationLaneDesc, type ProjectAutomationPoint, type ProjectBounceOptions, type ProjectChordSymbol, type ProjectClipCompSegment, type ProjectClipDesc, type ProjectClipFade, type ProjectClipTake, type ProjectCompileResult, type ProjectFadeCurve, type ProjectKeySegment, type ProjectLoopMode, type ProjectLoopRecordingDesc, type ProjectLoopRecordingResult, type ProjectMarker, type ProjectMidiClipResult, type ProjectMidiEvent, type ProjectNotePairValidation, type ProjectTrackDesc, type ProjectTrackKind, type ProjectWarpAnchor, type ProjectWarpMapDesc, RealtimeEngine, RealtimeVoiceChanger, type RealtimeVoiceChangerConfigInput, type RealtimeVoiceChangerInterleavedBuffer, type RealtimeVoiceChangerMonoBuffer, type RealtimeVoiceChangerPlanarBuffer, type RealtimeVoiceChangerPodConfig, type RemixRequest, type ResampleRequest, type RhythmAnalysisResult, type RhythmFeatures, type RirResult, type RirSynthOptions, type RoomEstimateOptions, type RoomEstimateResult, type RoomGeometryOptions, type RoomMorphOptions, type RoomMorphRequest, SYNTH_BODY_TYPES, SYNTH_ENGINE_MODES, SYNTH_FILTER_MODELS, SYNTH_FILTER_OUTPUTS, SYNTH_MOD_DESTINATIONS, SYNTH_MOD_SOURCES, SYNTH_OSC_WAVEFORMS, type SamplesRequest, type Section, SectionType, type SendTiming, type Sf2InstrumentConfig, type Sf2ProgramStatus, type SilenceRequest, type SoloProcessor, SonareError, type SourceBackend, type SpectralContrastRequest, type SpectralEditMode, type SpectralEditOptions, type SpectralEditRequest, type SpectralEditWindow, type SpectralFrameRequest, type SpectralRegionOp, type SpectralRolloffRequest, type SpectrogramRequest, type SpectrumOptions, type SpectrumReport, type StageGainReduction, type StereoAnalysis, type StftPowerResult, type StftResult, StreamAnalyzer, type StreamConfig, type StreamConfigDefaults, type StreamFramesI16, type StreamFramesU8, type StreamQuantizeConfig, StreamingEqualizer, type StreamingEqualizerConfig, StreamingMasteringChain, type StreamingMasteringChainConfig, type StreamingPlatform, StreamingRetune, type StreamingRetuneConfig, type SynthBodyType, type SynthEngineMode, type SynthEnumTables, type SynthFilterModel, type SynthFilterOutput, type SynthModDestination, type SynthModRouting, type SynthModSource, type SynthOscWaveform, type SynthPatch, type TempogramMode, type TempogramRatioRequest, type TempogramRequest, type Timbre, type TimbreAnalysisResult, type TimbreFrame, type TimeSignature, type TimeStretchRequest, type TonnetzRequest, type TransientShaperOptions, type TrimRequest, type TrimSilenceMode, type TrimSilenceOptions, type ValidateOptions, type VectorNormalizeRequest, type VectorscopeReport, type VoiceChangeOptions, type VoiceChangeRealtimeOptions, type VoiceChangeRealtimeRequest, type VoiceChangeRequest, type VoicePresetId, type VqtRequest, type VqtToAudioRequest, type WaveformPeakPyramidOptions, type WaveformPeakPyramidRequest, type WaveformPeaksOptions, type WaveformPeaksReport, type WaveformPeaksRequest, type WebMidiBinding, type WebMidiCcBinding, type WebMidiInputInfo, type ZeroCrossingRateRequest, type ZeroCrossingsRequest, abiVersion, amplitudeToDb, analyze, analyzeBpm, analyzeDynamics, analyzeImpulseResponse, analyzeMelody, analyzeRhythm, analyzeSections, analyzeTimbre, analyzeWithProgress, attachOpfsClipStream, bassChroma, bindMicrophoneInput, bindWebMidi, chordFunctionalAnalysis, chroma, chromaCens, chromaCqt, cqt, cqtToAudio, createOpfsClipPageProvider, createOpfsClipPageWorker, cyclicTempogram, dbToAmplitude, dbToPower, decompose, decomposeWithInit, deemphasis, detectAcoustic, detectBeats, detectBpm, detectChords, detectDownbeats, detectKey, detectKeyCandidates, detectOnsets, ebur128LoudnessRange, engineAbiVersion, engineCapabilities, estimateRoom, estimateTuning, fixFrames, fixLength, fourierTempogram, frameSignal, framesToSamples, framesToTime, harmonic, hasFfmpegSupport, hpss, hpssWithResidual, hybridCqt, hzToMel, hzToMidi, hzToNote, init, isInitialized, isSonareError, isWebMidiAvailable, lufs, lufsInterleaved, masterAudio, masterAudioStereo, masterAudioStereoWithProgress, masterAudioWithProgress, mastering, masteringAssistantSuggest, masteringAudioProfile, masteringChain, masteringChainStereo, masteringChainStereoWithProgress, masteringChainWithProgress, masteringDynamicsCompressor, masteringDynamicsGate, masteringDynamicsTransientShaper, masteringInsertNames, masteringInsertParamInfo, masteringInsertParamNames, masteringPairAnalysisNames, masteringPairAnalyze, masteringPairProcess, masteringPairProcessorNames, masteringPresetNames, masteringProcess, masteringProcessStereo, masteringProcessorCatalog, masteringProcessorNames, masteringRepairDeclick, masteringRepairDeclip, masteringRepairDecrackle, masteringRepairDehum, masteringRepairDenoiseClassical, masteringRepairDereverbClassical, masteringRepairTrimSilence, masteringStereoAnalysisNames, masteringStereoAnalyze, masteringStreamingPreview, melSpectrogram, melToAudio, melToHz, melToStft, meteringCrestFactorDb, meteringDcOffset, meteringDetectClipping, meteringDynamicRange, meteringPeakDb, meteringPhaseScope, meteringPhaseScopeDecimated, meteringRmsDb, meteringSpectrum, meteringSpectrumFrame, meteringStereoCorrelation, meteringStereoWidth, meteringTruePeakDb, meteringVectorscope, meteringVectorscopeDecimated, mfcc, mfccToAudio, mfccToMel, midiToHz, mixStereo, mixingScenePresetJson, mixingScenePresetNames, momentaryLufs, nnFilter, nnlsChroma, normalize, noteMove, noteStretch, noteToHz, onsetEnvelope, onsetStrengthMulti, opfsClipPageWorkerSource, padCenter, pcen, peakPick, percussive, phaseVocoder, pitchCorrectTimevarying, pitchCorrectToMidi, pitchCorrectToMidiTimevarying, pitchPyin, pitchShift, pitchTuning, pitchYin, plp, polyFeatures, powerToDb, preemphasis, projectAbiVersion, pseudoCqt, realtimeVoiceChangerPresetConfig, realtimeVoiceChangerPresetJson, realtimeVoiceChangerPresetNames, remix, resample, rmsEnergy, roomMorph, samplesToFrames, scaleCorrectionSemitones, scalePitchClassEnabled, scaleQuantizeMidi, shortTermLufs, spectralBandwidth, spectralCentroid, spectralContrast, spectralEdit, spectralFlatness, spectralRolloff, splitSilence, stft, stftDb, streamAnalyzerConfigDefaults, synthEnumTables, synthPresetNames, synthPresetPatch, synthesizeRir, tempogram, tempogramRatio, timeStretch, timeToFrames, tonnetz, trim, trimSilence, validateRealtimeVoiceChangerPresetJson, vectorNormalize, version, voiceChange, voiceChangeRealtime, voiceChangerAbiVersion, voiceCharacterPresetId, vqt, vqtToAudio, waveformPeakPyramid, waveformPeaks, zeroCrossingRate, zeroCrossings };
+export { type AcousticOptions, type AcousticResult, type AnalysisResult, type AnalyzeBpmOptions, type AnalyzeBpmRequest, type AnalyzeDynamicsOptions, type AnalyzeDynamicsRequest, type AnalyzeImpulseResponseRequest, type AnalyzeMelodyRequest, type AnalyzeRhythmOptions, type AnalyzeRhythmRequest, type AnalyzeSectionsOptions, type AnalyzeSectionsRequest, type AnalyzeTimbreOptions, type AnalyzeTimbreRequest, type AnalyzeWithProgressRequest, type AnalyzerStats, Audio, type AutomationCurve, BUILTIN_SYNTH_WAVEFORMS, type BarChord, type Beat, type BindMicrophoneInputOptions, type BindWebMidiOptions, type BpmAnalysisResult, type BpmCandidate, type BpmHypothesis, type BrowserAudioDecodeOptions, type BuiltinSynthBinding, type BuiltinSynthConfig, type BuiltinSynthWaveform, type ChirpRequest, type Chord, type ChordAnalysisResult, type ChordChange, type ChordDetectionOptions, type ChordFunctionalAnalysisRequest, ChordQuality, type ChromaResult, type ChromaSpectrogramRequest, type ClicksRequest, ClipPageProvider, type ClipPageRequest, type ClipPageStreamSource, ClipPageStreamer, type ClipPageStreamerEngine, type ClipPageStreamerOptions, type ClipPageStreamerRequest, type ClippingRegion, type ClippingReport, type CompressorDetector, type CompressorOptions, type CqtRequest, type CqtResult, type CqtToAudioRequest, type CyclicTempogramRequest, type DbConversionRequest, type DeclickOptions, type DeclipOptions, type DecomposeRequest, type DecomposeResult, type DecomposeWithInitRequest, type DecrackleMode, type DecrackleOptions, type DehumOptions, type DenoiseClassicalMode, type DenoiseClassicalNoiseEstimator, type DenoiseClassicalOptions, type DereverbClassicalOptions, type DetectAcousticRequest, type DetectChordsRequest, type DetectKeyRequest, type DetectOnsetsRequest, type DynamicRangeReport, type Dynamics, type DynamicsAnalysisResult, type DynamicsResult, EXPECTED_ENGINE_ABI_VERSION, EXPECTED_PROJECT_ABI_VERSION, type Ebur128LoudnessRangeRequest, type EmphasisRequest, type EngineAutomationPoint, type EngineBounceOptions, type EngineBounceResult, type EngineBus, type EngineCapabilities, type EngineCaptureSource, type EngineCaptureStatus, type EngineClip, type EngineFreezeOptions, type EngineFreezeResult, type EngineGraphSpec, type EngineMarker, type EngineMeterTelemetry, type EngineMeterTelemetryWide, type EngineMetronomeConfig, type EngineMidiClipSchedule, type EngineMidiEvent, type EngineParameterInfo, type EngineScopeTelemetry, type EngineTelemetry, type EngineTempoSegment, type EngineTimeSignatureSegment, type EngineTrackLane, type EngineTrackSend, type EngineTransportState, type EqBand, type EqBandPhase, type EqBandType, type EqCoeffMode, type EqMatchOptions, type EqSpectrumSnapshot, type EqStereoPlacement, ErrorCode, type EstimateRoomRequest, type EstimateTuningRequest, type ExternalMidiEvent, type ExternalSeparatedStem, type ExternalSeparatedStemImportRequest, type ExternalSeparatedStemImportResult, type FixFramesRequest, type FixLengthRequest, type FourierTempogramRequest, type FrameBuffer, type FrameSignalRequest, type GateOptions, type GoniometerPoint, type GriffinLimRequest, type HarmonicRequest, type HpssRequest, type HpssResult, type HpssWithResidualRequest, type HpssWithResidualResult, type Key, type KeyCandidate, type KeyDetectionOptions, KeyProfile, type KeyProfileName, type LufsInterleavedRequest, type LufsRequest, type LufsResult, MarkerKind, type MasterAudioRequest, type MasterAudioStereoRequest, type MasteringChainConfig, type MasteringChainRequest, type MasteringChainResult, type MasteringChainStereoRequest, type MasteringChainStereoResult, type MasteringChannelPolicy, type MasteringDynamicsCompressorRequest, type MasteringDynamicsGateRequest, type MasteringDynamicsTransientShaperRequest, type MasteringInsertParamInfo, type MasteringLoudnessSummary, type MasteringOptions, type MasteringPairAnalyzeRequest, type MasteringPairProcessRequest, type MasteringPreset, type MasteringProcessRequest, type MasteringProcessStereoRequest, type MasteringProcessorCatalogEntry, type MasteringProcessorParams, type MasteringRealtimeCost, type MasteringRepairDeclickRequest, type MasteringRepairDeclipRequest, type MasteringRepairDecrackleRequest, type MasteringRepairDehumRequest, type MasteringRepairDenoiseClassicalRequest, type MasteringRepairDereverbClassicalRequest, type MasteringRepairTrimSilenceRequest, type MasteringReport, type MasteringRequest, type MasteringResult, type MasteringSamplesParamsRequest, type MasteringStereoAnalyzeRequest, type MasteringStereoChainResult, type MasteringStereoResult, type MasteringStreamingPreviewRequest, type Matrix2dResult, type MelDeltaRequest, type MelPowerResult, type MelSpectrogramRequest, type MelSpectrogramResult, type MelToAudioRequest, type MelToStftRequest, type MelodyOptions, type MelodyPoint, type MelodyResult, type MeterTap, type MeteringDetectClippingOptions, type MeteringDetectClippingRequest, type MeteringDynamicRangeOptions, type MeteringDynamicRangeRequest, type MeteringSamplesRequest, type MeteringSilenceRatioRequest, type MeteringSpectrumFrameRequest, type MeteringSpectrumRequest, type MeteringStereoDecimatedRequest, type MeteringStereoRequest, type MeteringTruePeakRequest, type MfccRequest, type MfccResult, type MfccToAudioRequest, type MfccToMelRequest, type MicrophoneInputBinding, type MidiCcBindOptions, type MidiCcLearnOptions, type MixMeterSnapshot, type MixOptions, type MixResult, type MixStereoRequest, Mixer, type MixerProcessResult, type MixerRealtimeBuffer, Mode, type MusicAnalyzeRequest, type NnFilterRequest, type NnlsChromaRequest, type NormalizeRequest, type NoteMoveRequest, type NoteSegment, type NoteSegmentsRequest, type NoteStretchOptions, type NoteStretchRequest, type OfflineWorker, type OfflineWorkerCallOptions, OfflineWorkerClient, type OfflineWorkerClientOptions, type OfflineWorkerProgress, OfflineWorkerTask, type OnsetBacktrackRequest, type OnsetEnvelopeRequest, type OnsetStrengthMultiRequest, type OpfsClipPageProviderBinding, type OpfsClipPageProviderOptions, type OpfsClipStream, type OpfsClipStreamOptions, type PadCenterRequest, type PairAnalysis, type PairProcessor, type PanLaw, type PanMode, type PatternScore, type PcenRequest, type PeakPickRequest, type PercussiveRequest, type PhaseScopeReport, type PhaseVocoderRequest, type PiptrackRequest, PitchClass as Pitch, PitchClass, type PitchCorrectOptions, type PitchCorrectTimevaryingRequest, type PitchCorrectToMidiRequest, type PitchCorrectToMidiTimevaryingRequest, type PitchPyinRequest, type PitchResult, type PitchShiftRequest, type PitchTuningRequest, type PitchYinRequest, type PlpRequest, type PolyFeaturesRequest, type ProgressiveEstimate, Project, type ProjectAssistSidecar, type ProjectAutomationCurve, type ProjectAutomationLaneDesc, type ProjectAutomationPoint, type ProjectBounceOptions, type ProjectChordSymbol, type ProjectClip, type ProjectClipCompSegment, type ProjectClipDesc, type ProjectClipFade, type ProjectClipTake, type ProjectCompileResult, type ProjectFadeCurve, type ProjectKeySegment, type ProjectLoopMode, type ProjectLoopRecordingDesc, type ProjectLoopRecordingResult, type ProjectMarker, type ProjectMidiClipResult, type ProjectMidiEvent, type ProjectNotePairValidation, type ProjectSource, type ProjectTrack, type ProjectTrackDesc, type ProjectTrackKind, type ProjectWarpAnchor, type ProjectWarpMapDesc, RealtimeEngine, RealtimeVoiceChanger, type RealtimeVoiceChangerConfigInput, type RealtimeVoiceChangerInterleavedBuffer, type RealtimeVoiceChangerMonoBuffer, type RealtimeVoiceChangerPlanarBuffer, type RealtimeVoiceChangerPodConfig, type ReassignedSpectrogramRequest, type RemixRequest, type ResampleRequest, type RhythmAnalysisResult, type RhythmFeatures, type RirResult, type RirSynthOptions, type RoomEstimateOptions, type RoomEstimateResult, type RoomGeometryOptions, type RoomMorphOptions, type RoomMorphRequest, SYNTH_BODY_TYPES, SYNTH_ENGINE_MODES, SYNTH_FILTER_MODELS, SYNTH_FILTER_OUTPUTS, SYNTH_MOD_DESTINATIONS, SYNTH_MOD_SOURCES, SYNTH_OSC_WAVEFORMS, type SamplesRequest, type Section, SectionType, type SegmentAgglomerativeRequest, type SegmentCrossSimilarityRequest, type SegmentLagToRecurrenceRequest, type SegmentMatrix, type SegmentPathEnhanceRequest, type SegmentRecurrenceMatrixRequest, type SegmentRecurrenceToLagRequest, type SegmentSubsegmentRequest, type SendTiming, type Sf2InstrumentConfig, type Sf2ProgramStatus, type SilenceRequest, type SoloProcessor, type SonareCapabilities, SonareError, type SourceBackend, type SpectralContrastRequest, type SpectralEditMode, type SpectralEditOptions, type SpectralEditRequest, type SpectralEditWindow, type SpectralFrameRequest, type SpectralRegionOp, type SpectralRolloffRequest, type SpectrogramRequest, type SpectrumOptions, type SpectrumReport, type StageGainReduction, type StereoAnalysis, type StftPowerResult, type StftResult, StreamAnalyzer, type StreamConfig, type StreamConfigDefaults, type StreamFramesI16, type StreamFramesU8, type StreamQuantizeConfig, StreamingEqualizer, type StreamingEqualizerConfig, StreamingMasteringChain, type StreamingMasteringChainConfig, type StreamingPlatform, StreamingRetune, type StreamingRetuneConfig, type SynthBodyType, type SynthEngineMode, type SynthEnumTables, type SynthFilterModel, type SynthFilterOutput, type SynthModDestination, type SynthModRouting, type SynthModSource, type SynthOscWaveform, type SynthPatch, type TempogramMode, type TempogramRatioRequest, type TempogramRequest, type Timbre, type TimbreAnalysisResult, type TimbreFrame, type TimeSignature, type TimeStretchRequest, type ToneRequest, type TonnetzRequest, type TransientShaperOptions, type TrimRequest, type TrimSilenceMode, type TrimSilenceOptions, type ValidateOptions, type VectorNormalizeRequest, type VectorscopeReport, type VoiceChangeOptions, type VoiceChangeRealtimeOptions, type VoiceChangeRealtimeRequest, type VoiceChangeRequest, type VoicePresetId, type VqtRequest, type VqtToAudioRequest, type WaveformPeakPyramidOptions, type WaveformPeakPyramidRequest, type WaveformPeaksOptions, type WaveformPeaksReport, type WaveformPeaksRequest, type WebMidiBinding, type WebMidiCcBinding, type WebMidiInputInfo, type WorkletOpfsClipStreamHost, type ZeroCrossingRateRequest, type ZeroCrossingsRequest, abiVersion, amplitudeToDb, analyze, analyzeBpm, analyzeDynamics, analyzeImpulseResponse, analyzeMelody, analyzeRhythm, analyzeSections, analyzeTimbre, analyzeWithProgress, attachOpfsClipStream, bassChroma, bindMicrophoneInput, bindWebMidi, capabilities, capabilityCatalog, chirp, chordFunctionalAnalysis, chroma, chromaCens, chromaCqt, clicks, cqt, cqtToAudio, createOpfsClipPageProvider, createOpfsClipPageWorker, cyclicTempogram, dbToAmplitude, dbToPower, decompose, decomposeWithInit, deemphasis, detectAcoustic, detectBeats, detectBpm, detectChords, detectDownbeats, detectKey, detectKeyCandidates, detectOnsets, ebur128LoudnessRange, engineAbiVersion, engineCapabilities, estimateRoom, estimateTuning, fixFrames, fixLength, fourierTempogram, frameSignal, framesToSamples, framesToTime, griffinLim, harmonic, hasFfmpegSupport, hpss, hpssWithResidual, hybridCqt, hzToMel, hzToMidi, hzToNote, init, isInitialized, isSonareError, isWebMidiAvailable, lufs, lufsInterleaved, masterAudio, masterAudioStereo, masterAudioStereoWithProgress, masterAudioWithProgress, mastering, masteringAssistantSuggest, masteringAudioProfile, masteringChain, masteringChainStereo, masteringChainStereoWithProgress, masteringChainWithProgress, masteringDynamicsCompressor, masteringDynamicsGate, masteringDynamicsTransientShaper, masteringInsertNames, masteringInsertParamInfo, masteringInsertParamNames, masteringPairAnalysisNames, masteringPairAnalyze, masteringPairProcess, masteringPairProcessorNames, masteringPresetNames, masteringProcess, masteringProcessStereo, masteringProcessorCatalog, masteringProcessorNames, masteringRepairDeclick, masteringRepairDeclip, masteringRepairDecrackle, masteringRepairDehum, masteringRepairDenoiseClassical, masteringRepairDereverbClassical, masteringRepairTrimSilence, masteringStereoAnalysisNames, masteringStereoAnalyze, masteringStreamingPreview, melDelta, melSpectrogram, melToAudio, melToHz, melToStft, meteringCrestFactorDb, meteringDcOffset, meteringDetectClipping, meteringDynamicRange, meteringPeakDb, meteringPhaseScope, meteringPhaseScopeDecimated, meteringRmsDb, meteringSilenceRatio, meteringSpectrum, meteringSpectrumFrame, meteringStereoCorrelation, meteringStereoWidth, meteringTruePeakDb, meteringVectorscope, meteringVectorscopeDecimated, mfcc, mfccToAudio, mfccToMel, midiToHz, mixStereo, mixingScenePresetJson, mixingScenePresetNames, momentaryLufs, nnFilter, nnlsChroma, normalize, noteMove, noteSegments, noteStretch, noteToHz, onsetBacktrack, onsetEnvelope, onsetStrengthMulti, opfsClipPageWorkerSource, padCenter, pcen, peakPick, percussive, phaseVocoder, piptrack, pitchCorrectTimevarying, pitchCorrectToMidi, pitchCorrectToMidiTimevarying, pitchPyin, pitchShift, pitchTuning, pitchYin, plp, polyFeatures, powerToDb, preemphasis, projectAbiVersion, pseudoCqt, realtimeVoiceChangerPresetConfig, realtimeVoiceChangerPresetJson, realtimeVoiceChangerPresetNames, reassignedSpectrogram, remix, resample, rmsEnergy, roomMorph, samplesToFrames, scaleCorrectionSemitones, scalePitchClassEnabled, scaleQuantizeMidi, segmentAgglomerative, segmentCrossSimilarity, segmentLagToRecurrence, segmentPathEnhance, segmentRecurrenceMatrix, segmentRecurrenceToLag, segmentSubsegment, shortTermLufs, spectralBandwidth, spectralCentroid, spectralContrast, spectralEdit, spectralFlatness, spectralFlux, spectralRolloff, splitSilence, stft, stftDb, streamAnalyzerConfigDefaults, synthEnumTables, synthPresetNames, synthPresetPatch, synthesizeRir, tempogram, tempogramRatio, timeStretch, timeToFrames, tone, tonnetz, trim, trimSilence, validateRealtimeVoiceChangerPresetJson, vectorNormalize, version, voiceChange, voiceChangeRealtime, voiceChangerAbiVersion, voiceCharacterPresetId, vqt, vqtToAudio, waveformPeakPyramid, waveformPeaks, zeroCrossingRate, zeroCrossings };