@libraz/libsonare 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -22,8 +22,25 @@ type PitchClass = (typeof PitchClass)[keyof typeof PitchClass];
 declare const Mode: {
     readonly Major: 0;
     readonly Minor: 1;
+    readonly Dorian: 2;
+    readonly Phrygian: 3;
+    readonly Lydian: 4;
+    readonly Mixolydian: 5;
+    readonly Locrian: 6;
 };
 type Mode = (typeof Mode)[keyof typeof Mode];
+type TempogramMode = 'autocorrelation' | 'auto' | 'ac' | 'cosine' | 0 | 1;
+declare const KeyProfile: {
+    readonly KrumhanslSchmuckler: 0;
+    readonly Temperley: 1;
+    readonly Shaath: 2;
+    readonly FaraldoEDMT: 3;
+    readonly FaraldoEDMA: 4;
+    readonly FaraldoEDMM: 5;
+    readonly BellmanBudge: 6;
+};
+type KeyProfile = (typeof KeyProfile)[keyof typeof KeyProfile];
+type KeyProfileName = 'ks' | 'krumhansl' | 'temperley' | 'shaath' | 'keyfinder' | 'faraldo-edmt' | 'edmt' | 'faraldo-edma' | 'edma' | 'faraldo-edmm' | 'edmm' | 'bellman-budge' | 'bellman';
 /**
  * Chord quality
  */
@@ -37,8 +54,26 @@ declare const ChordQuality: {
     readonly Minor7: 6;
     readonly Sus2: 7;
     readonly Sus4: 8;
+    readonly Unknown: 9;
+    readonly Add9: 10;
+    readonly MinorAdd9: 11;
+    readonly Dim7: 12;
+    readonly HalfDim7: 13;
+    readonly Major9: 14;
+    readonly Dominant9: 15;
+    readonly Sus2Add4: 16;
 };
 type ChordQuality = (typeof ChordQuality)[keyof typeof ChordQuality];
+type MasteringPreset = 'pop' | 'edm' | 'acoustic' | 'hipHop' | 'aiMusic' | 'speech' | 'streaming' | 'youtube' | 'broadcast' | 'podcast' | 'audiobook' | 'cinema' | 'jpop' | 'ambient' | 'lofi' | 'classical' | 'drumAndBass' | 'techno' | 'metal' | 'trap' | 'rnb' | 'jazz' | 'kpop' | 'trance' | 'gameOst';
+interface StreamingPlatform {
+    name: string;
+    targetLufs: number;
+    ceilingDb: number;
+}
+type SoloProcessor = 'dynamics.brickwallLimiter' | 'dynamics.compressor' | 'dynamics.deesser' | 'dynamics.expander' | 'dynamics.gate' | 'dynamics.limiter' | 'dynamics.parallelComp' | 'dynamics.sidechainRouter' | 'dynamics.duckingProcessor' | 'dynamics.transientShaper' | 'dynamics.upwardCompressor' | 'dynamics.upwardExpander' | 'dynamics.vocalRider' | 'eq.apiStyle' | 'eq.bandPass' | 'eq.cutFilter' | 'eq.dynamic' | 'eq.equalizer' | 'eq.graphic' | 'eq.linearPhase' | 'eq.midSide' | 'eq.minimumPhase' | 'eq.parametric' | 'eq.pultec' | 'eq.shelving' | 'eq.tilt' | 'final.bitDepth' | 'final.dither' | 'final.outputChain' | 'maximizer.adaptiveRelease' | 'maximizer.loudnessOptimize' | 'maximizer.maximizer' | 'maximizer.softKneeMax' | 'maximizer.truePeakLimiter' | 'multiband.compressor' | 'multiband.dynamicEq' | 'multiband.expander' | 'multiband.imager' | 'multiband.limiter' | 'multiband.saturation' | 'repair.declick' | 'repair.declip' | 'repair.decrackle' | 'repair.dehum' | 'repair.denoiseClassical' | 'repair.dereverbClassical' | 'repair.trimSilence' | 'saturation.bitcrusher' | 'saturation.exciter' | 'saturation.hardClipper' | 'saturation.multibandExciter' | 'saturation.softClipper' | 'saturation.tape' | 'saturation.transformer' | 'saturation.tube' | 'saturation.waveshaper' | 'spectral.airBand' | 'spectral.lowEndFocus' | 'spectral.presenceEnhancer' | 'spectral.spectralShaper' | 'stereo.autoPan' | 'stereo.haasEnhancer' | 'stereo.imager' | 'stereo.monoMaker' | 'stereo.phaseAlign' | 'stereo.stereoBalance';
+type PairProcessor = 'match.applyMatchEq' | 'match.alignReferenceToSource' | 'match.abSwitch' | 'match.abCrossfade';
+type PairAnalysis = 'match.referenceLoudness' | 'match.tonalBalance' | 'match.tonalBalanceLogBands' | 'match.matchEqCurve' | 'match.estimateReferenceDelaySamples';
+type StereoAnalysis = 'stereo.monoCompatCheck' | 'stereo.monoCompatCheckLogBands';
 /**
  * Section type
  */
@@ -50,6 +85,7 @@ declare const SectionType: {
     readonly Bridge: 4;
     readonly Instrumental: 5;
     readonly Outro: 6;
+    readonly Unknown: 7;
 };
 type SectionType = (typeof SectionType)[keyof typeof SectionType];
 /**
@@ -62,6 +98,36 @@ interface Key {
     name: string;
     shortName: string;
 }
+interface KeyDetectionOptions {
+    nFft?: number;
+    hopLength?: number;
+    useHpss?: boolean;
+    loudnessWeighted?: boolean;
+    highPassHz?: number;
+    modes?: Mode[] | ('major' | 'minor' | 'dorian' | 'phrygian' | 'lydian' | 'mixolydian' | 'locrian')[] | 'major-minor' | 'all' | 'modal';
+    profile?: KeyProfile | KeyProfileName;
+    genreHint?: 'auto' | 'edm' | 'electronic' | 'dance' | 'pop' | 'classical' | 'jazz' | string;
+}
+interface KeyCandidate {
+    key: Key;
+    correlation: number;
+}
+interface ChordDetectionOptions {
+    minDuration?: number;
+    smoothingWindow?: number;
+    threshold?: number;
+    useTriadsOnly?: boolean;
+    nFft?: number;
+    hopLength?: number;
+    useBeatSync?: boolean;
+    useHmm?: boolean;
+    hmmBeamWidth?: number;
+    useKeyContext?: boolean;
+    keyRoot?: PitchClass;
+    keyMode?: Mode;
+    detectInversions?: boolean;
+    chromaMethod?: 'stft' | 'nnls';
+}
 /**
  * Detected beat
  */
@@ -74,12 +140,16 @@ interface Beat {
  */
 interface Chord {
     root: PitchClass;
+    bass: PitchClass;
     quality: ChordQuality;
     start: number;
     end: number;
     confidence: number;
     name: string;
 }
+interface ChordAnalysisResult {
+    chords: Chord[];
+}
 /**
  * Detected section
  */
@@ -91,6 +161,45 @@ interface Section {
     confidence: number;
     name: string;
 }
+/**
+ * A single melody contour point (mirrors the C `SonareMelodyPoint`).
+ */
+interface MelodyPoint {
+    /** Frame time in seconds. */
+    time: number;
+    /** Estimated fundamental frequency in Hz (0 when unvoiced). */
+    frequency: number;
+    /** Voicing confidence in `[0, 1]`. */
+    confidence: number;
+}
+/**
+ * Melody analysis result (mirrors the C `SonareMelodyResult`).
+ */
+interface MelodyResult {
+    points: MelodyPoint[];
+    pitchRangeOctaves: number;
+    pitchStability: number;
+    meanFrequency: number;
+    vibratoRate: number;
+}
+/**
+ * Constant-Q / Variable-Q transform magnitude result (mirrors the C
+ * `SonareCqtResult`).
+ */
+interface CqtResult {
+    /** Number of frequency bins. */
+    nBins: number;
+    /** Number of time frames. */
+    nFrames: number;
+    /** Hop length in samples. */
+    hopLength: number;
+    /** Sample rate in Hz. */
+    sampleRate: number;
+    /** Row-major `[nBins x nFrames]` magnitude matrix. */
+    magnitude: Float32Array;
+    /** Center frequency (Hz) of each of the `nBins` bins. */
+    frequencies: Float32Array;
+}
 /**
  * Timbre characteristics
  */
@@ -143,6 +252,22 @@ interface AnalysisResult {
     rhythm: RhythmFeatures;
     form: string;
 }
+/**
+ * Room acoustic parameters from an impulse response
+ */
+interface AcousticResult {
+    rt60: number;
+    edt: number;
+    c50: number;
+    c80: number;
+    d50: number;
+    rt60Bands: Float32Array;
+    edtBands: Float32Array;
+    c50Bands: Float32Array;
+    c80Bands: Float32Array;
+    confidence: number;
+    isBlind: boolean;
+}
 /**
  * HPSS (Harmonic-Percussive Source Separation) result
  */
@@ -163,6 +288,68 @@ interface MasteringResult {
     latencySamples?: number;
 }
 type MasteringProcessorParams = Record<string, number | boolean>;
+type PanMode = 'balance' | 'stereoPan' | 'stereo-pan' | 'dualPan' | 'dual-pan' | number;
+interface MixOptions {
+    inputTrimDb?: number | number[];
+    faderDb?: number | number[];
+    pan?: number | number[];
+    panMode?: PanMode | PanMode[];
+    width?: number | number[];
+    muted?: boolean | boolean[];
+}
+interface MixMeterSnapshot {
+    peakDbL: number;
+    peakDbR: number;
+    rmsDbL: number;
+    rmsDbR: number;
+    correlation: number;
+    monoCompatWidth: number;
+    monoCompatPeak: number;
+    monoCompatSideRms: number;
+    likelyMonoCompatible: boolean;
+    momentaryLufs: number;
+    shortTermLufs: number;
+    integratedLufs: number;
+    gainReductionDb: number;
+    truePeakDbL: number;
+    truePeakDbR: number;
+    maxTruePeakDb: number;
+    seq: number;
+}
+interface MixResult {
+    left: Float32Array;
+    right: Float32Array;
+    sampleRate: number;
+    meters: MixMeterSnapshot[];
+}
+/** Mixed stereo master returned by {@link Mixer.processStereo}. */
+interface MixerProcessResult {
+    left: Float32Array;
+    right: Float32Array;
+    sampleRate: number;
+}
+/**
+ * Interpolation curve for scheduled automation events
+ * (see {@link Mixer.scheduleInsertAutomation}).
+ */
+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.
+ */
+type PanLaw = 'const3dB' | 'const4.5dB' | 'const6dB' | 'linear0dB';
+/**
+ * Meter tap point for reading a strip's meter snapshot
+ * (see {@link Mixer.meterTap} and {@link Mixer.stripMeter}).
+ */
+type MeterTap = 'preFader' | 'postFader';
+/** Pre/post-fader send timing (see {@link Mixer.addSend}). */
+type SendTiming = 'preFader' | 'postFader';
+/** A single goniometer (left/right) sample returned by {@link Mixer.readGoniometerLatest}. */
+interface GoniometerPoint {
+    left: number;
+    right: number;
+}
 interface MasteringChainConfig {
     repair?: {
         denoise?: boolean;
@@ -213,6 +400,7 @@ interface MasteringChainConfig {
             attackMs?: number;
             releaseMs?: number;
             rangeDb?: number;
+            bandpassQ?: number;
         };
         transientShaper?: {
             attackGainDb?: number;
@@ -349,6 +537,22 @@ interface MfccResult {
     nFrames: number;
     coefficients: Float32Array;
 }
+/**
+ * STFT power spectrogram result (from inverse Mel reconstruction)
+ */
+interface StftPowerResult {
+    nBins: number;
+    nFrames: number;
+    power: Float32Array;
+}
+/**
+ * Mel power spectrogram result (from inverse MFCC reconstruction)
+ */
+interface MelPowerResult {
+    nMels: number;
+    nFrames: number;
+    power: Float32Array;
+}
 /**
  * Chroma features result
  */
@@ -371,6 +575,87 @@ interface PitchResult {
     medianF0: number;
     meanF0: number;
 }
+/**
+ * Loudness measurement result (EBU R128 / ITU-R BS.1770)
+ */
+interface LufsResult {
+    integratedLufs: number;
+    momentaryLufs: number;
+    shortTermLufs: number;
+    loudnessRange: number;
+}
+/**
+ * Realtime equalizer spectrum snapshot.
+ *
+ * Mirrors the C++ `EqualizerSpectrumSnapshot`: `preLeft`/`preRight` and
+ * `postLeft`/`postRight` are the pre- and post-EQ spectrum streams (trimmed to
+ * their valid count). `bandGainDb` holds per-band applied gain (24 entries),
+ * `profileDb` the smoothed magnitude profile (16 entries), `lastAutoGainDb`
+ * the latest auto-gain compensation, and `seq` increments each time a new
+ * snapshot is published.
+ */
+interface EqSpectrumSnapshot {
+    preLeft: Float32Array;
+    preRight: Float32Array;
+    postLeft: Float32Array;
+    postRight: Float32Array;
+    bandGainDb: Float32Array;
+    profileDb: Float32Array;
+    lastAutoGainDb: number;
+    seq: number;
+}
+/**
+ * Equalizer band type (string union mirroring `sonare::mastering::eq::EqBandType`).
+ */
+type EqBandType = 'Peak' | 'LowShelf' | 'HighShelf' | 'LowPass' | 'HighPass' | 'BandPass' | 'Notch' | 'TiltShelf' | 'FlatTilt';
+/** Biquad coefficient design mode. */
+type EqCoeffMode = 'Rbj' | 'Vicanek';
+/** Stereo placement for an EQ band. */
+type EqStereoPlacement = 'Stereo' | 'Left' | 'Right' | 'Mid' | 'Side';
+/** Per-band phase behaviour. */
+type EqBandPhase = 'Inherit' | 'ZeroLatency' | 'NaturalPhase' | 'LinearPhase';
+/**
+ * Equalizer band configuration accepted by {@link StreamingEqualizer.setBand}.
+ *
+ * All fields are optional; omitted values fall back to the C++ band defaults
+ * (Peak, 1000 Hz, 0 dB gain, Butterworth Q, disabled).
+ */
+interface EqBand {
+    type?: EqBandType;
+    frequencyHz?: number;
+    gainDb?: number;
+    q?: number;
+    enabled?: boolean;
+    coeffMode?: EqCoeffMode;
+    slopeDbOct?: number;
+    placement?: EqStereoPlacement;
+    phase?: EqBandPhase;
+    soloed?: boolean;
+    bypassed?: boolean;
+    proportionalQ?: boolean;
+    proportionalQStrength?: number;
+    dynamic?: boolean;
+    thresholdDb?: number;
+    autoThreshold?: boolean;
+    ratio?: number;
+    rangeDb?: number;
+    attackMs?: number;
+    releaseMs?: number;
+    lookaheadMs?: number;
+    externalSidechain?: boolean;
+    sidechainFreqHz?: number;
+    sidechainQ?: number;
+}
+/** Construction options for {@link StreamingEqualizer}. */
+interface StreamingEqualizerConfig {
+    sampleRate?: number;
+    maxBlockSize?: number;
+}
+/** Options for {@link StreamingEqualizer.match}. */
+interface EqMatchOptions {
+    sampleRate?: number;
+    maxBands?: number;
+}
 
 /**
  * A detected chord change in the progression
@@ -411,6 +696,7 @@ interface ProgressiveEstimate {
     chordRoot: PitchClass;
     chordQuality: ChordQuality;
     chordConfidence: number;
+    chordStartTime: number;
     chordProgression: ChordChange[];
     barChordProgression: BarChord[];
     currentBar: number;
@@ -449,6 +735,28 @@ interface FrameBuffer {
     chordQuality: Int32Array;
     chordConfidence: Float32Array;
 }
+interface StreamFramesU8 {
+    nFrames: number;
+    nMels: number;
+    timestamps: Float32Array;
+    mel: Uint8Array;
+    chroma: Uint8Array;
+    onsetStrength: Uint8Array;
+    rmsEnergy: Uint8Array;
+    spectralCentroid: Uint8Array;
+    spectralFlatness: Uint8Array;
+}
+interface StreamFramesI16 {
+    nFrames: number;
+    nMels: number;
+    timestamps: Float32Array;
+    mel: Int16Array;
+    chroma: Int16Array;
+    onsetStrength: Int16Array;
+    rmsEnergy: Int16Array;
+    spectralCentroid: Int16Array;
+    spectralFlatness: Int16Array;
+}
 /**
  * Configuration for StreamAnalyzer
  */
@@ -457,10 +765,20 @@ interface StreamConfig {
     nFft?: number;
     hopLength?: number;
     nMels?: number;
+    fmin?: number;
+    fmax?: number;
+    tuningRefHz?: number;
+    computeMagnitude?: boolean;
     computeMel?: boolean;
     computeChroma?: boolean;
     computeOnset?: boolean;
+    computeSpectral?: boolean;
     emitEveryNFrames?: number;
+    magnitudeDownsample?: number;
+    keyUpdateIntervalSec?: number;
+    bpmUpdateIntervalSec?: number;
+    window?: number;
+    outputFormat?: number;
 }
 
 type ProgressCallback = (progress: number, stage: string) => void;
@@ -478,6 +796,164 @@ interface WasmTempogramResult {
     winLength: number;
     data: Float32Array;
 }
+interface WasmCyclicTempogramResult {
+    nFrames: number;
+    nBins: number;
+    data: Float32Array;
+}
+interface WasmFourierTempogramResult {
+    nBins: number;
+    nFrames: number;
+    data: Float32Array;
+}
+interface WasmNnlsChromaResult {
+    nChroma: number;
+    nFrames: number;
+    data: Float32Array;
+}
+interface WasmEngineClip {
+    id?: number;
+    channels: Float32Array[];
+    startPpq: number;
+    lengthSamples?: number;
+    clipOffsetSamples?: number;
+    loop?: boolean;
+    gain?: number;
+    fadeInSamples?: number;
+    fadeOutSamples?: number;
+}
+interface WasmEngineParameterInfo {
+    id: number;
+    name: string;
+    unit: string;
+    minValue: number;
+    maxValue: number;
+    defaultValue: number;
+    rtSafe: boolean;
+    defaultCurve: number;
+}
+interface WasmEngineAutomationPoint {
+    ppq: number;
+    value: number;
+    curveToNext?: number;
+}
+interface WasmEngineMarker {
+    id: number;
+    ppq: number;
+    name?: string;
+}
+interface WasmEngineMetronomeConfig {
+    enabled: boolean;
+    beatGain?: number;
+    accentGain?: number;
+    clickSamples?: number;
+}
+interface WasmEngineGraphNode {
+    id: string;
+    type?: number;
+    gainDb?: number;
+    numPorts?: number;
+}
+interface WasmEngineGraphConnection {
+    sourceNode: string;
+    sourcePort: number;
+    destNode: string;
+    destPort: number;
+    mix?: number;
+}
+interface WasmEngineGraphParameterBinding {
+    paramId: number;
+    nodeId: string;
+}
+interface WasmEngineGraphSpec {
+    nodes: WasmEngineGraphNode[];
+    connections: WasmEngineGraphConnection[];
+    inputNode: string;
+    outputNode: string;
+    numChannels: number;
+    parameterBindings?: WasmEngineGraphParameterBinding[];
+}
+interface WasmEngineTelemetry {
+    type: number;
+    error: number;
+    renderFrame: number;
+    timelineSample: number;
+    audibleTimelineSample: number;
+    graphLatencySamplesQ8: number;
+    value: number;
+}
+interface WasmEngineMeterTelemetry {
+    targetId: number;
+    renderFrame: number;
+    seq: number;
+    peakDbL: number;
+    peakDbR: number;
+    rmsDbL: number;
+    rmsDbR: number;
+    truePeakDbL: number;
+    truePeakDbR: number;
+    maxTruePeakDb: number;
+    correlation: number;
+    monoCompatWidth: number;
+    momentaryLufs: number;
+    shortTermLufs: number;
+    integratedLufs: number;
+    gainReductionDb: number;
+    droppedRecords: number;
+}
+interface WasmEngineCaptureStatus {
+    capturedFrames: number;
+    overflowCount: number;
+    armed: boolean;
+    punchEnabled: boolean;
+}
+interface WasmEngineTransportState {
+    playing: boolean;
+    looping: boolean;
+    renderFrame: number;
+    samplePosition: number;
+    ppq: number;
+    bpm: number;
+    loopStartPpq: number;
+    loopEndPpq: number;
+    sampleRate: number;
+}
+interface WasmEngineBounceOptions {
+    totalFrames: number;
+    blockSize?: number;
+    numChannels?: number;
+    targetSampleRate?: number;
+    sourceSampleRate?: number;
+    normalizeLufs?: boolean;
+    targetLufs?: number;
+    dither?: 0 | 1 | 2 | 3;
+    ditherBits?: number;
+    ditherSeed?: number;
+}
+interface WasmEngineBounceResult {
+    interleaved: Float32Array;
+    frames: number;
+    numChannels: number;
+    sampleRate: number;
+    integratedLufs: number;
+}
+interface WasmEngineFreezeOptions {
+    totalFrames: number;
+    blockSize?: number;
+    numChannels?: number;
+    clipId?: number;
+    startPpq?: number;
+    gain?: number;
+}
+interface WasmEngineFreezeResult {
+    clipId: number;
+    frames: number;
+    numChannels: number;
+}
+interface WasmEngineProcessWithMonitorResult {
+    output: Float32Array[];
+    monitor: Float32Array[];
+}
 
 /**
  * sonare - Audio Analysis Library
@@ -499,6 +975,37 @@ interface WasmTempogramResult {
  * ```
  */
 
+type EngineClip = WasmEngineClip;
+type EngineParameterInfo = WasmEngineParameterInfo;
+type EngineAutomationPoint = WasmEngineAutomationPoint;
+type EngineMarker = WasmEngineMarker;
+type EngineMetronomeConfig = WasmEngineMetronomeConfig;
+type EngineGraphSpec = WasmEngineGraphSpec;
+type EngineCaptureStatus = WasmEngineCaptureStatus;
+type EngineBounceOptions = WasmEngineBounceOptions;
+type EngineBounceResult = WasmEngineBounceResult;
+type EngineFreezeOptions = WasmEngineFreezeOptions;
+type EngineFreezeResult = WasmEngineFreezeResult;
+type EngineTelemetry = WasmEngineTelemetry;
+type EngineMeterTelemetry = WasmEngineMeterTelemetry;
+type EngineTransportState = WasmEngineTransportState;
+declare const EXPECTED_ENGINE_ABI_VERSION = 2;
+interface EngineCapabilities {
+    engineAbiVersion: number;
+    expectedEngineAbiVersion: number;
+    abiCompatible: boolean;
+    sharedArrayBuffer: boolean;
+    atomics: boolean;
+    audioWorklet: boolean;
+    mode: 'sab' | 'postMessage';
+}
+interface MixerRealtimeBuffer {
+    leftInputs: Float32Array[];
+    rightInputs: Float32Array[];
+    outLeft: Float32Array;
+    outRight: Float32Array;
+    process: (numSamples?: number) => void;
+}
 /**
  * Initialize the WASM module.
  * Must be called before using any analysis functions.
@@ -517,6 +1024,60 @@ declare function isInitialized(): boolean;
  * Get the library version.
  */
 declare function version(): string;
+declare function engineAbiVersion(): number;
+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;
+    /** Queue a sample-accurate parameter change (engine kSetParam). */
+    setParameter(paramId: number, value: number, renderFrame?: number): void;
+    /** Queue a smoothed parameter change (engine kSetParamSmoothed). */
+    setParameterSmoothed(paramId: number, value: number, renderFrame?: number): void;
+    /** Read back the current transport state snapshot. */
+    getTransportState(): EngineTransportState;
+    play(renderFrame?: number): void;
+    stop(renderFrame?: number): void;
+    seekSample(timelineSample: number, renderFrame?: number): void;
+    seekPpq(ppq: number, renderFrame?: number): void;
+    setTempo(bpm: number): void;
+    setTimeSignature(numerator: number, denominator: number): void;
+    setLoop(startPpq: number, endPpq: number, enabled?: boolean): void;
+    addParameter(info: EngineParameterInfo): void;
+    parameterCount(): number;
+    parameterInfoByIndex(index: number): EngineParameterInfo;
+    parameterInfo(id: number): EngineParameterInfo;
+    setAutomationLane(paramId: number, points: EngineAutomationPoint[]): void;
+    automationLaneCount(): number;
+    setMarkers(markers: EngineMarker[]): void;
+    markerCount(): number;
+    markerByIndex(index: number): EngineMarker;
+    marker(id: number): EngineMarker;
+    seekMarker(markerId: number, renderFrame?: number): void;
+    setLoopFromMarkers(startMarkerId: number, endMarkerId: number): void;
+    setMetronome(config: EngineMetronomeConfig): void;
+    metronome(): Required<EngineMetronomeConfig>;
+    countInEndSample(startSample: number, bars: number): number;
+    setGraph(spec: EngineGraphSpec): void;
+    graphNodeCount(): number;
+    graphConnectionCount(): number;
+    setClips(clips: EngineClip[]): void;
+    clipCount(): number;
+    setCaptureBuffer(numChannels: number, capacityFrames: number): void;
+    armCapture(armed?: boolean): void;
+    setCapturePunch(startSample: number, endSample: number, enabled?: boolean): void;
+    resetCapture(): void;
+    captureStatus(): EngineCaptureStatus;
+    capturedAudio(): Float32Array[];
+    process(channels: Float32Array[]): Float32Array[];
+    processWithMonitor(channels: Float32Array[]): WasmEngineProcessWithMonitorResult;
+    renderOffline(channels: Float32Array[], blockSize?: number): Float32Array[];
+    bounceOffline(options: EngineBounceOptions): EngineBounceResult;
+    freezeOffline(options: EngineFreezeOptions): EngineFreezeResult;
+    drainTelemetry(maxRecords?: number): EngineTelemetry[];
+    drainMeterTelemetry(maxRecords?: number): EngineMeterTelemetry[];
+    destroy(): void;
+}
 /**
  * Detect BPM from audio samples.
  *
@@ -532,7 +1093,8 @@ declare function detectBpm(samples: Float32Array, sampleRate: number): number;
  * @param sampleRate - Sample rate in Hz
  * @returns Detected key
  */
-declare function detectKey(samples: Float32Array, sampleRate: number): Key;
+declare function detectKey(samples: Float32Array, sampleRate: number, options?: KeyDetectionOptions): Key;
+declare function detectKeyCandidates(samples: Float32Array, sampleRate: number, options?: KeyDetectionOptions): KeyCandidate[];
 /**
  * Detect onset times from audio samples.
  *
@@ -549,6 +1111,23 @@ declare function detectOnsets(samples: Float32Array, sampleRate: number): Float3
  * @returns Array of beat times in seconds
  */
 declare function detectBeats(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Detect downbeat times from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Array of downbeat times in seconds
+ */
+declare function detectDownbeats(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Detect chords from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param options - Optional chord detection settings
+ * @returns Detected chord segments
+ */
+declare function detectChords(samples: Float32Array, sampleRate: number, options?: ChordDetectionOptions): ChordAnalysisResult;
 /**
  * Perform complete music analysis.
  *
@@ -557,6 +1136,8 @@ declare function detectBeats(samples: Float32Array, sampleRate: number): Float32
  * @returns Complete analysis result
  */
 declare function analyze(samples: Float32Array, sampleRate: number): AnalysisResult;
+declare function analyzeImpulseResponse(samples: Float32Array, sampleRate: number, nOctaveBands?: number): AcousticResult;
+declare function detectAcoustic(samples: Float32Array, sampleRate: number, nOctaveBands?: number, nThirdOctaveSubbands?: number, minDecayDb?: number, noiseFloorMarginDb?: number): AcousticResult;
 /**
  * Perform complete music analysis with progress reporting.
  *
@@ -610,6 +1191,37 @@ declare function timeStretch(samples: Float32Array, sampleRate: number, rate: nu
  * @returns Pitch-shifted audio
  */
 declare function pitchShift(samples: Float32Array, sampleRate: number, semitones: number): Float32Array;
+/**
+ * Pitch-correct audio from a current MIDI note to a target MIDI note.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param currentMidi - Detected/current MIDI note number
+ * @param targetMidi - Desired MIDI note number
+ * @returns Pitch-corrected audio
+ */
+declare function pitchCorrectToMidi(samples: Float32Array, sampleRate: number, currentMidi: number, targetMidi: number): Float32Array;
+/**
+ * Time-stretch a note region between two sample offsets without changing pitch.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @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)
+ * @returns Audio with the note region stretched
+ */
+declare function noteStretch(samples: Float32Array, sampleRate: number, onsetSample: number, offsetSample: number, stretchRatio: number): Float32Array;
+/**
+ * Apply a voice change by shifting pitch and formants independently.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param pitchSemitones - Pitch shift in semitones
+ * @param formantFactor - Formant scaling factor (1.0 = unchanged)
+ * @returns Voice-changed audio
+ */
+declare function voiceChange(samples: Float32Array, sampleRate: number, pitchSemitones: number, formantFactor: number): Float32Array;
 /**
  * Normalize audio to target peak level.
  *
@@ -630,15 +1242,18 @@ declare function normalize(samples: Float32Array, sampleRate: number, targetDb?:
  * @returns Processed audio and loudness metadata
  */
 declare function mastering(samples: Float32Array, sampleRate: number, targetLufs?: number, ceilingDb?: number, truePeakOversample?: number): MasteringResult;
-declare function masteringProcessorNames(): string[];
-declare function masteringPairProcessorNames(): string[];
-declare function masteringPairAnalysisNames(): string[];
-declare function masteringStereoAnalysisNames(): string[];
-declare function masteringProcess(processorName: string, samples: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringResult;
-declare function masteringProcessStereo(processorName: string, left: Float32Array, right: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringStereoResult;
-declare function masteringPairProcess(processorName: string, source: Float32Array, reference: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringResult;
-declare function masteringPairAnalyze(analysisName: string, source: Float32Array, reference: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
-declare function masteringStereoAnalyze(analysisName: string, left: Float32Array, right: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
+declare function masteringProcessorNames(): SoloProcessor[];
+declare function masteringPairProcessorNames(): PairProcessor[];
+declare function masteringPairAnalysisNames(): PairAnalysis[];
+declare function masteringStereoAnalysisNames(): StereoAnalysis[];
+declare function masteringProcess(processorName: SoloProcessor, samples: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringResult;
+declare function masteringProcessStereo(processorName: SoloProcessor, left: Float32Array, right: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringStereoResult;
+declare function masteringPairProcess(processorName: PairProcessor, source: Float32Array, reference: Float32Array, sampleRate: number, params?: MasteringProcessorParams): MasteringResult;
+declare function masteringPairAnalyze(analysisName: PairAnalysis, source: Float32Array, reference: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
+declare function masteringStereoAnalyze(analysisName: StereoAnalysis, left: Float32Array, right: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
+declare function masteringAssistantSuggest(samples: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
+declare function masteringAudioProfile(samples: Float32Array, sampleRate: number, params?: MasteringProcessorParams): string;
+declare function masteringStreamingPreview(samples: Float32Array, sampleRate: number, platforms?: StreamingPlatform[]): string;
 /**
  * Apply a configurable mastering chain in WASM.
  *
@@ -684,7 +1299,7 @@ declare function masteringChainStereoWithProgress(left: Float32Array, right: Flo
  *
  * @returns Preset names in display order (e.g. "pop", "edm", "aiMusic")
  */
-declare function masteringPresetNames(): string[];
+declare function masteringPresetNames(): MasteringPreset[];
 /**
  * Apply a named mastering preset chain to mono audio.
  *
@@ -694,7 +1309,7 @@ declare function masteringPresetNames(): string[];
  * @param overrides - Optional flat overrides (dot-notation, e.g. `'loudness.targetLufs'`) applied on top of the preset. Pass `null` for preset defaults.
  * @returns Processed audio, loudness metadata, and applied stage names
  */
-declare function masterAudio(samples: Float32Array, sampleRate: number, presetName: string, overrides?: Record<string, number | boolean> | null): MasteringChainResult;
+declare function masterAudio(samples: Float32Array, sampleRate: number, presetName: MasteringPreset, overrides?: Record<string, number | boolean> | null): MasteringChainResult;
 /**
  * Apply a named mastering preset chain to stereo audio.
  *
@@ -705,7 +1320,18 @@ declare function masterAudio(samples: Float32Array, sampleRate: number, presetNa
  * @param overrides - Optional flat overrides (dot-notation, e.g. `'loudness.targetLufs'`) applied on top of the preset. Pass `null` for preset defaults.
  * @returns Processed stereo audio, loudness metadata, and applied stage names
  */
-declare function masterAudioStereo(left: Float32Array, right: Float32Array, sampleRate: number, presetName: string, overrides?: Record<string, number | boolean> | null): MasteringStereoChainResult;
+declare function masterAudioStereo(left: Float32Array, right: Float32Array, sampleRate: number, presetName: MasteringPreset, overrides?: Record<string, number | boolean> | null): MasteringStereoChainResult;
+declare function mixingScenePresetNames(): string[];
+/**
+ * Get a built-in mixing scene preset serialized as JSON. This is the canonical
+ * name shared with the Node and Python bindings; the returned JSON loads
+ * directly into a {@link Mixer} via {@link Mixer.fromSceneJson}.
+ *
+ * @param preset - Preset name (see {@link mixingScenePresetNames})
+ * @returns Scene JSON string
+ */
+declare function mixingScenePresetJson(preset: string): string;
+declare function mixStereo(leftChannels: Float32Array[], rightChannels: Float32Array[], sampleRate?: number, options?: MixOptions): MixResult;
 /**
  * Block-by-block streaming variant of {@link masteringChain}.
  *
@@ -758,6 +1384,305 @@ declare class StreamingMasteringChain {
     /** Release the underlying WASM object. Safe to call only once. */
     delete(): void;
 }
+/**
+ * Block-by-block streaming equalizer wrapping the unified C++
+ * `EqualizerProcessor` (up to 24 bands, RBJ/Vicanek biquads, dynamic EQ,
+ * linear-phase FIR, mid/side processing, and auto-gain).
+ *
+ * State is maintained across {@link processMono}/{@link processStereo} calls.
+ * Call {@link delete} (or use `try/finally`) to release the underlying WASM
+ * object — the embind handle is not garbage-collected automatically.
+ *
+ * @example
+ * ```typescript
+ * const eq = new StreamingEqualizer({ sampleRate: 48000, maxBlockSize: 512 });
+ * try {
+ *   eq.setBand(0, { type: 'HighShelf', frequencyHz: 8000, gainDb: 6, enabled: true });
+ *   const out = eq.processStereo(left, right);
+ *   const snapshot = eq.spectrum();
+ * } finally {
+ *   eq.delete();
+ * }
+ * ```
+ */
+declare class StreamingEqualizer {
+    private eq;
+    constructor(config?: StreamingEqualizerConfig);
+    /**
+     * Configure the band at `index` (0..23). Omitted fields use C++ defaults.
+     */
+    setBand(index: number, band: EqBand): void;
+    /** Disable and reset every band. */
+    clear(): void;
+    /**
+     * Set the global phase mode: 1=ZeroLatency, 2=NaturalPhase, 3=LinearPhase.
+     */
+    setPhaseMode(mode: number): void;
+    /** Enable or disable output auto-gain compensation. */
+    setAutoGain(enabled: boolean): void;
+    /** Set all-band EQ gain scale as a 0.0..2.0 multiplier. */
+    setGainScale(scale: number): void;
+    /** Set post-EQ output gain in dB. */
+    setOutputGainDb(gainDb: number): void;
+    /** Set post-EQ stereo balance in -1.0..1.0; mono input ignores pan. */
+    setOutputPan(pan: number): void;
+    /**
+     * Provide a mono external sidechain key for dynamic bands that opt into
+     * `external_sidechain`. The samples are copied into an owned buffer.
+     */
+    setSidechainMono(samples: Float32Array): void;
+    /**
+     * Provide a stereo external sidechain key. Both channels must match length.
+     */
+    setSidechainStereo(left: Float32Array, right: Float32Array): void;
+    /** Release any borrowed external sidechain buffers. */
+    clearSidechain(): void;
+    /** Auto-gain applied on the most recent block, in dB. */
+    lastAutoGainDb(): number;
+    /** Reported processing latency in samples (non-zero for linear-phase bands). */
+    latencySamples(): number;
+    /**
+     * Process one mono block, returning the equalized samples (same length).
+     */
+    processMono(samples: Float32Array): Float32Array;
+    /**
+     * Process one stereo block, returning the equalized channels.
+     */
+    processStereo(left: Float32Array, right: Float32Array): {
+        left: Float32Array;
+        right: Float32Array;
+    };
+    /**
+     * Read the latest pre/post spectrum snapshot for metering. `seq` increments
+     * each time a new snapshot is published.
+     */
+    spectrum(): EqSpectrumSnapshot;
+    /**
+     * Configure bands so the source spectrum matches the reference spectrum.
+     *
+     * @param source - Source audio (mono samples)
+     * @param reference - Reference audio (mono samples)
+     * @param options - `sampleRate` (default 48000) and `maxBands` (default 8)
+     */
+    match(source: Float32Array, reference: Float32Array, options?: EqMatchOptions): void;
+    /** Release the underlying WASM object. Safe to call only once. */
+    delete(): void;
+}
+/**
+ * Get a built-in mixing scene preset serialized as JSON, normalized through the
+ * C mixer API (the same path {@link Mixer.fromSceneJson} uses to load it).
+ *
+ * @deprecated Use {@link mixingScenePresetJson}, the canonical name shared with
+ * the Node and Python bindings. This alias is retained for backwards
+ * compatibility and may be removed in a future release. Both functions return a
+ * scene JSON string that loads cleanly into a {@link Mixer}.
+ *
+ * @param preset - Preset name (see {@link mixingScenePresetNames})
+ * @returns Scene JSON string
+ */
+declare function mixerScenePresetJson(preset: string): string;
+/**
+ * Persistent, scene-based stereo mixer.
+ *
+ * Build one from a scene JSON string (e.g. {@link mixerScenePresetJson} or a
+ * hand-authored scene), then feed per-strip stereo blocks through
+ * {@link processStereo} to get the routed stereo master. Strips, sends, buses,
+ * and inserts are described entirely by the scene; the routing graph is
+ * compiled lazily on the first {@link processStereo} call (or eagerly via
+ * {@link compile}).
+ *
+ * Call {@link delete} (or use a `try/finally`) to release the underlying WASM
+ * object — the embind handle is not garbage-collected automatically.
+ *
+ * @example
+ * ```typescript
+ * const mixer = Mixer.fromSceneJson(mixerScenePresetJson('basicStereo'), 48000, 512);
+ * try {
+ *   const out = mixer.processStereo([stripL], [stripR]);
+ * } finally {
+ *   mixer.delete();
+ * }
+ * ```
+ */
+declare class Mixer {
+    private mixer;
+    private constructor();
+    /**
+     * Build a mixer from a scene JSON string.
+     *
+     * @param json - Scene JSON (strips, buses, sends, connections, inserts)
+     * @param sampleRate - Sample rate in Hz (default: 48000)
+     * @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. */
+    compile(): void;
+    /**
+     * Mix one block of per-strip stereo audio into the stereo master.
+     *
+     * @param leftChannels - `leftChannels[i]` is the left channel of strip `i`
+     * @param rightChannels - `rightChannels[i]` is the right channel of strip `i`
+     * @returns Mixed stereo master (`left`, `right`, `sampleRate`)
+     */
+    processStereo(leftChannels: Float32Array[], rightChannels: Float32Array[]): MixerProcessResult;
+    /**
+     * Mix one block into caller-owned output arrays.
+     *
+     * This avoids allocating the result object and result `Float32Array`s. It is
+     * intended for realtime bridges such as AudioWorklet; the input channel count
+     * must match the scene strip count and all arrays must have the same length.
+     */
+    processStereoInto(leftChannels: Float32Array[], rightChannels: Float32Array[], outLeft: Float32Array, outRight: Float32Array): void;
+    /**
+     * Create reusable WASM-heap input/output views for realtime-style processing.
+     *
+     * Fill `leftInputs[i]` / `rightInputs[i]`, call `process()`, then read
+     * `outLeft` / `outRight`. The views are owned by this mixer and become invalid
+     * after {@link delete}.
+     */
+    createRealtimeBuffer(): MixerRealtimeBuffer;
+    /** Number of strips in the mixer (e.g. strips loaded from the scene). */
+    stripCount(): number;
+    /**
+     * Schedule sample-accurate insert-parameter automation on a strip's insert.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param insertIndex - Index into the strip's combined insert sequence
+     *   (`[pre-inserts... post-inserts...]`)
+     * @param paramId - Processor-specific parameter id
+     * @param samplePos - Absolute samples from the start of processing (the mixer
+     *   advances an internal position from 0 on the first {@link processStereo}
+     *   call; recompiling resets it to 0)
+     * @param value - Target parameter value
+     * @param curve - Interpolation curve (default: `'linear'`)
+     * @throws If the strip index is out of range or the schedule call fails
+     *   (unknown curve, out-of-range insert index, or full event lane)
+     */
+    scheduleInsertAutomation(stripIndex: number, insertIndex: number, paramId: number, samplePos: number, value: number, curve?: AutomationCurve): void;
+    /**
+     * Resolve a strip's index in `[0, stripCount())` from its scene id, or `null`
+     * when no strip with that id exists (matches the Node binding's `number | null`).
+     */
+    stripById(id: string): number | null;
+    /**
+     * Add a bus to the mixer topology. `role` is one of `'master'`, `'aux'`, or
+     * `'submix'` (defaults to `'aux'`). Marks the routing graph dirty; call
+     * {@link compile} (or {@link processStereo}) to rebuild.
+     */
+    addBus(id: string, role?: string): void;
+    /** Remove a bus by id. Marks the routing graph dirty. */
+    removeBus(id: string): void;
+    /** Number of buses in the mixer topology. */
+    busCount(): number;
+    /**
+     * Add a VCA group with the given gain offset (dB). `members` is a list of
+     * strip ids governed by the group (may be empty).
+     */
+    addVcaGroup(id: string, gainDb?: number, members?: string[]): void;
+    /** Remove a VCA group by id. */
+    removeVcaGroup(id: string): void;
+    /** Number of VCA groups in the mixer topology. */
+    vcaGroupCount(): number;
+    /**
+     * Set a strip's solo state. Takes effect on the next process without a
+     * graph recompile.
+     */
+    setSoloed(stripIndex: number, soloed: boolean): void;
+    /**
+     * Mark a strip solo-safe so it is never implied-muted by another strip's
+     * solo. Takes effect on the next process without a graph recompile.
+     */
+    setSoloSafe(stripIndex: number, soloSafe: boolean): void;
+    /** Invert the polarity of the left and/or right channel of a strip. */
+    setPolarityInvert(stripIndex: number, invertLeft: boolean, invertRight: boolean): void;
+    /** Set the strip's pan law. */
+    setPanLaw(stripIndex: number, panLaw: PanLaw | number): void;
+    /**
+     * Set a per-strip channel delay in samples. This changes the strip's reported
+     * latency; recompile to re-run latency compensation.
+     */
+    setChannelDelaySamples(stripIndex: number, delaySamples: number): void;
+    /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
+    setVcaOffsetDb(stripIndex: number, offsetDb: number): void;
+    /** Set independent left/right pan positions (dual-pan mode). */
+    setDualPan(stripIndex: number, leftPan: number, rightPan: number): void;
+    /**
+     * Add a send to a strip after construction.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param id - Send id
+     * @param destinationBusId - Destination bus id
+     * @param sendDb - Initial send level in dB
+     * @param timing - `'preFader'` or `'postFader'` (default: `'postFader'`)
+     * @returns The new send's index
+     */
+    addSend(stripIndex: number, id: string, destinationBusId: string, sendDb: number, timing?: SendTiming | number): number;
+    /** Set the send level (in dB) for an existing send by index. */
+    setSendDb(stripIndex: number, sendIndex: number, sendDb: number): void;
+    /**
+     * Read a strip's meter snapshot at the given tap point.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+     */
+    meterTap(stripIndex: number, tap?: MeterTap): MixMeterSnapshot;
+    /**
+     * Read a strip's meter snapshot. Alias of {@link meterTap}, provided for
+     * cross-binding (Node/Python) parity.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+     */
+    stripMeter(stripIndex: number, tap?: MeterTap): MixMeterSnapshot;
+    /**
+     * Schedule sample-accurate fader automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param faderDb - Target fader level in dB
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleFaderAutomation(stripIndex: number, samplePos: number, faderDb: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate pan automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param pan - Target pan position
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    schedulePanAutomation(stripIndex: number, samplePos: number, pan: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate width automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param width - Target stereo width
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleWidthAutomation(stripIndex: number, samplePos: number, width: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate send-level automation on a strip's send.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param sendIndex - Send index in the strip's add order
+     * @param samplePos - Absolute samples from the start of processing
+     * @param db - Target send level in dB
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleSendAutomation(stripIndex: number, sendIndex: number, samplePos: number, db: number, curve?: AutomationCurve): void;
+    /**
+     * Read up to `maxPoints` of a strip's most recent goniometer samples
+     * (oldest to newest).
+     */
+    readGoniometerLatest(stripIndex: number, maxPoints: number): GoniometerPoint[];
+    /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
+    toSceneJson(): string;
+    /** Release the underlying WASM object. Safe to call only once. */
+    delete(): void;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
 /**
  * Trim silence from beginning and end of audio.
  *
@@ -814,6 +1739,59 @@ declare function melSpectrogram(samples: Float32Array, sampleRate: number, nFft?
  * @returns MFCC result
  */
 declare function mfcc(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number, nMels?: number, nMfcc?: number): MfccResult;
+/**
+ * Approximate inverse of a Mel filterbank: Mel power spectrogram -> STFT power
+ * spectrogram. Mirrors `feature::mel_to_stft`.
+ *
+ * @param melPower - Mel power spectrogram [nMels x nFrames] row-major
+ * @param nMels - Number of Mel bands
+ * @param nFrames - Number of time frames
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns STFT power spectrogram result
+ */
+declare function melToStft(melPower: Float32Array, nMels: number, nFrames: number, sampleRate: number, nFft?: number, hopLength?: number, fmin?: number, fmax?: number): StftPowerResult;
+/**
+ * Reconstruct audio from a Mel power spectrogram via Griffin-Lim. Mirrors
+ * `feature::mel_to_audio`.
+ *
+ * @param melPower - Mel power spectrogram [nMels x nFrames] row-major
+ * @param nMels - Number of Mel bands
+ * @param nFrames - Number of time frames
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param nIter - Griffin-Lim iterations (default: 32)
+ * @returns Reconstructed audio samples (mono, float32)
+ */
+declare function melToAudio(melPower: Float32Array, nMels: number, nFrames: number, sampleRate: number, nFft?: number, hopLength?: number, nIter?: number, fmin?: number, fmax?: number): Float32Array;
+/**
+ * Invert MFCC coefficients back to a Mel power spectrogram. Mirrors
+ * `feature::mfcc_to_mel`.
+ *
+ * @param mfccCoefficients - MFCC matrix [nMfcc x nFrames] row-major
+ * @param nMfcc - Number of MFCC coefficients
+ * @param nFrames - Number of time frames
+ * @param nMels - Number of Mel bins to reconstruct (default: 128)
+ * @returns Mel power spectrogram result
+ */
+declare function mfccToMel(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels?: number): MelPowerResult;
+/**
+ * Reconstruct audio directly from MFCC coefficients via Griffin-Lim. Mirrors
+ * `feature::mfcc_to_audio`.
+ *
+ * @param mfccCoefficients - MFCC matrix [nMfcc x nFrames] row-major
+ * @param nMfcc - Number of MFCC coefficients
+ * @param nFrames - Number of time frames
+ * @param nMels - Number of Mel bins (default: 128)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param nIter - Griffin-Lim iterations (default: 32)
+ * @returns Reconstructed audio samples (mono, float32)
+ */
+declare function mfccToAudio(mfccCoefficients: Float32Array, nMfcc: number, nFrames: number, nMels: number, sampleRate: number, nFft?: number, hopLength?: number, nIter?: number, fmin?: number, fmax?: number): Float32Array;
 /**
  * Compute chromagram (pitch class distribution).
  *
@@ -989,8 +1967,121 @@ declare function peakPick(values: Float32Array, preMax: number, postMax: number,
 declare function vectorNormalize(values: Float32Array, normType?: number, threshold?: number): Float32Array;
 declare function pcen(values: Float32Array, nBins: number, nFrames: number, options?: Record<string, number>): Float32Array;
 declare function tonnetz(chromagram: Float32Array, nChroma: number, nFrames: number): Float32Array;
-declare function tempogram(onsetEnvelope: Float32Array, sampleRate: number, hopLength?: number, winLength?: number): WasmTempogramResult;
+declare function tempogram(onsetEnvelope: Float32Array, sampleRate: number, hopLength?: number, winLength?: number, mode?: TempogramMode): WasmTempogramResult;
+declare function cyclicTempogram(onsetEnvelope: Float32Array, sampleRate: number, hopLength?: number, winLength?: number, bpmMin?: number, nBins?: number): WasmCyclicTempogramResult;
 declare function plp(onsetEnvelope: Float32Array, sampleRate: number, hopLength?: number, tempoMin?: number, tempoMax?: number, winLength?: number): Float32Array;
+/**
+ * Compute NNLS (non-negative least squares) chromagram.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @returns NNLS chroma result
+ */
+declare function nnlsChroma(samples: Float32Array, sampleRate?: number): WasmNnlsChromaResult;
+/**
+ * Compute the Constant-Q Transform magnitude.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param hopLength - Hop length (default: 512)
+ * @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)
+ * @returns CQT magnitude result
+ */
+declare function cqt(samples: Float32Array, sampleRate?: number, hopLength?: number, fmin?: number, nBins?: number, binsPerOctave?: number): CqtResult;
+/**
+ * Compute the Variable-Q Transform magnitude (gamma controls Q).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param hopLength - Hop length (default: 512)
+ * @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)
+ * @returns VQT magnitude result (same shape as CQT)
+ */
+declare function vqt(samples: Float32Array, sampleRate?: number, hopLength?: number, fmin?: number, nBins?: number, binsPerOctave?: number, gamma?: number): CqtResult;
+/**
+ * Detect song-structure sections (intro/verse/chorus/...).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param minSectionSec - Minimum section duration in seconds (default: 8.0)
+ * @returns Array of detected sections
+ */
+declare function analyzeSections(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, minSectionSec?: number): Section[];
+/**
+ * Extract the melody contour from monophonic audio via YIN.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param fmin - Minimum frequency in Hz (default: 65.0)
+ * @param fmax - Maximum frequency in Hz (default: 2093.0)
+ * @param frameLength - Frame length in samples (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param threshold - YIN threshold; lower is stricter (default: 0.1)
+ * @returns Melody contour with per-frame pitch points and summary stats
+ */
+declare function analyzeMelody(samples: Float32Array, sampleRate?: number, fmin?: number, fmax?: number, frameLength?: number, hopLength?: number, threshold?: number): MelodyResult;
+/**
+ * Compute the onset strength envelope.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param nMels - Number of Mel bands (default: 128)
+ * @returns Onset envelope for each frame
+ */
+declare function onsetEnvelope(samples: Float32Array, sampleRate?: number, nFft?: number, hopLength?: number, nMels?: number): Float32Array;
+/**
+ * Compute the Fourier tempogram from an onset envelope.
+ *
+ * @param onsetEnvelope - Onset strength envelope (float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param hopLength - Hop length (default: 512)
+ * @param winLength - Window length in frames (default: 384)
+ * @returns Fourier tempogram result
+ */
+declare function fourierTempogram(onsetEnvelope: Float32Array, sampleRate?: number, hopLength?: number, winLength?: number): WasmFourierTempogramResult;
+/**
+ * Compute tempogram ratio features.
+ *
+ * @param tempogramData - Tempogram data (float32)
+ * @param winLength - Window length in frames (default: 384)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Tempogram ratio features
+ */
+declare function tempogramRatio(tempogramData: Float32Array, winLength?: number, sampleRate?: number, hopLength?: number): Float32Array;
+/**
+ * Measure loudness (EBU R128 / ITU-R BS.1770).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @returns Loudness measurement result
+ */
+declare function lufs(samples: Float32Array, sampleRate?: number): LufsResult;
+/**
+ * Compute the momentary loudness (LUFS) over time.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @returns Momentary LUFS values over time
+ */
+declare function momentaryLufs(samples: Float32Array, sampleRate?: number): Float32Array;
+/**
+ * Compute the short-term loudness (LUFS) over time.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz (default: 22050)
+ * @returns Short-term LUFS values over time
+ */
+declare function shortTermLufs(samples: Float32Array, sampleRate?: number): Float32Array;
 /**
  * Resample audio to a different sample rate.
  *
@@ -1031,9 +2122,12 @@ declare class Audio {
     /** Duration in seconds. */
     get duration(): number;
     detectBpm(): number;
-    detectKey(): Key;
+    detectKey(options?: KeyDetectionOptions): Key;
+    detectKeyCandidates(options?: KeyDetectionOptions): KeyCandidate[];
     detectOnsets(): Float32Array;
     detectBeats(): Float32Array;
+    detectDownbeats(): Float32Array;
+    detectChords(options?: ChordDetectionOptions): ChordAnalysisResult;
     analyze(): AnalysisResult;
     analyzeWithProgress(onProgress: ProgressCallback): AnalysisResult;
     hpss(kernelHarmonic?: number, kernelPercussive?: number): HpssResult;
@@ -1041,11 +2135,14 @@ declare class Audio {
     percussive(): Float32Array;
     timeStretch(rate: number): Float32Array;
     pitchShift(semitones: number): Float32Array;
+    pitchCorrectToMidi(currentMidi: number, targetMidi: number): Float32Array;
+    noteStretch(onsetSample: number, offsetSample: number, stretchRatio: number): Float32Array;
+    voiceChange(pitchSemitones: number, formantFactor: number): Float32Array;
     normalize(targetDb?: number): Float32Array;
     mastering(targetLufs?: number, ceilingDb?: number, truePeakOversample?: number): MasteringResult;
     masteringChain(config: MasteringChainConfig): MasteringChainResult;
-    masterAudio(presetName: string, overrides?: Record<string, number | boolean> | null): MasteringChainResult;
-    masteringProcess(processorName: string, params?: MasteringProcessorParams): MasteringResult;
+    masterAudio(presetName: MasteringPreset, overrides?: Record<string, number | boolean> | null): MasteringChainResult;
+    masteringProcess(processorName: SoloProcessor, params?: MasteringProcessorParams): MasteringResult;
     trim(thresholdDb?: number): Float32Array;
     stft(nFft?: number, hopLength?: number): StftResult;
     stftDb(nFft?: number, hopLength?: number): {
@@ -1056,6 +2153,11 @@ declare class Audio {
     melSpectrogram(nFft?: number, hopLength?: number, nMels?: number): MelSpectrogramResult;
     mfcc(nFft?: number, hopLength?: number, nMels?: number, nMfcc?: number): MfccResult;
     chroma(nFft?: number, hopLength?: number): ChromaResult;
+    nnlsChroma(): WasmNnlsChromaResult;
+    onsetEnvelope(nFft?: number, hopLength?: number, nMels?: number): Float32Array;
+    lufs(): LufsResult;
+    momentaryLufs(): Float32Array;
+    shortTermLufs(): Float32Array;
     spectralCentroid(nFft?: number, hopLength?: number): Float32Array;
     spectralBandwidth(nFft?: number, hopLength?: number): Float32Array;
     spectralRolloff(nFft?: number, hopLength?: number, rollPercent?: number): Float32Array;
@@ -1119,6 +2221,8 @@ declare class StreamAnalyzer {
      * @returns Frame buffer with analysis results
      */
     readFrames(maxFrames: number): FrameBuffer;
+    readFramesU8(maxFrames: number): StreamFramesU8;
+    readFramesI16(maxFrames: number): StreamFramesI16;
     /**
      * Reset the analyzer state.
      *
@@ -1172,4 +2276,4 @@ declare class StreamAnalyzer {
     dispose(): void;
 }
 
-export { type AnalysisResult, type AnalyzerStats, Audio, type BarChord, type Beat, type Chord, type ChordChange, ChordQuality, type ChromaResult, type Dynamics, type FrameBuffer, type HpssResult, type Key, type MasteringChainConfig, type MasteringChainResult, type MasteringProcessorParams, type MasteringResult, type MasteringStereoChainResult, type MasteringStereoResult, type MelSpectrogramResult, type MfccResult, Mode, type PatternScore, PitchClass as Pitch, PitchClass, type PitchResult, type ProgressCallback, type ProgressiveEstimate, type RhythmFeatures, type Section, SectionType, type StftResult, StreamAnalyzer, type StreamConfig, StreamingMasteringChain, type Timbre, type TimeSignature, amplitudeToDb, analyze, analyzeWithProgress, chroma, dbToAmplitude, dbToPower, deemphasis, detectBeats, detectBpm, detectKey, detectOnsets, fixFrames, fixLength, frameSignal, framesToSamples, framesToTime, harmonic, hpss, hzToMel, hzToMidi, hzToNote, init, isInitialized, masterAudio, masterAudioStereo, mastering, masteringChain, masteringChainStereo, masteringChainStereoWithProgress, masteringChainWithProgress, masteringPairAnalysisNames, masteringPairAnalyze, masteringPairProcess, masteringPairProcessorNames, masteringPresetNames, masteringProcess, masteringProcessStereo, masteringProcessorNames, masteringStereoAnalysisNames, masteringStereoAnalyze, melSpectrogram, melToHz, mfcc, midiToHz, normalize, noteToHz, padCenter, pcen, peakPick, percussive, pitchPyin, pitchShift, pitchYin, plp, powerToDb, preemphasis, resample, rmsEnergy, samplesToFrames, spectralBandwidth, spectralCentroid, spectralFlatness, spectralRolloff, splitSilence, stft, stftDb, tempogram, timeStretch, timeToFrames, tonnetz, trim, trimSilence, vectorNormalize, version, zeroCrossingRate };
+export { type AcousticResult, type AnalysisResult, type AnalyzerStats, Audio, type AutomationCurve, type BarChord, type Beat, type Chord, type ChordAnalysisResult, type ChordChange, type ChordDetectionOptions, ChordQuality, type ChromaResult, type CqtResult, type Dynamics, EXPECTED_ENGINE_ABI_VERSION, type EngineAutomationPoint, type EngineBounceOptions, type EngineBounceResult, type EngineCapabilities, type EngineCaptureStatus, type EngineClip, type EngineFreezeOptions, type EngineFreezeResult, type EngineGraphSpec, type EngineMarker, type EngineMeterTelemetry, type EngineMetronomeConfig, type EngineParameterInfo, type EngineTelemetry, type EngineTransportState, type EqBand, type EqBandPhase, type EqBandType, type EqCoeffMode, type EqMatchOptions, type EqSpectrumSnapshot, type EqStereoPlacement, type FrameBuffer, type GoniometerPoint, type HpssResult, type Key, type KeyCandidate, type KeyDetectionOptions, KeyProfile, type KeyProfileName, type LufsResult, type MasteringChainConfig, type MasteringChainResult, type MasteringPreset, type MasteringProcessorParams, type MasteringResult, type MasteringStereoChainResult, type MasteringStereoResult, type MelSpectrogramResult, type MelodyPoint, type MelodyResult, type MeterTap, type MfccResult, type MixMeterSnapshot, type MixOptions, type MixResult, Mixer, type MixerProcessResult, type MixerRealtimeBuffer, Mode, type PairAnalysis, type PairProcessor, type PanLaw, type PanMode, type PatternScore, PitchClass as Pitch, PitchClass, type PitchResult, type ProgressCallback, type ProgressiveEstimate, RealtimeEngine, type RhythmFeatures, type Section, SectionType, type SendTiming, type SoloProcessor, type StereoAnalysis, type StftResult, StreamAnalyzer, type StreamConfig, type StreamFramesI16, type StreamFramesU8, StreamingEqualizer, type StreamingEqualizerConfig, StreamingMasteringChain, type StreamingPlatform, type Timbre, type TimeSignature, amplitudeToDb, analyze, analyzeImpulseResponse, analyzeMelody, analyzeSections, analyzeWithProgress, chroma, cqt, cyclicTempogram, dbToAmplitude, dbToPower, deemphasis, detectAcoustic, detectBeats, detectBpm, detectChords, detectDownbeats, detectKey, detectKeyCandidates, detectOnsets, engineAbiVersion, engineCapabilities, fixFrames, fixLength, fourierTempogram, frameSignal, framesToSamples, framesToTime, harmonic, hpss, hzToMel, hzToMidi, hzToNote, init, isInitialized, lufs, masterAudio, masterAudioStereo, mastering, masteringAssistantSuggest, masteringAudioProfile, masteringChain, masteringChainStereo, masteringChainStereoWithProgress, masteringChainWithProgress, masteringPairAnalysisNames, masteringPairAnalyze, masteringPairProcess, masteringPairProcessorNames, masteringPresetNames, masteringProcess, masteringProcessStereo, masteringProcessorNames, masteringStereoAnalysisNames, masteringStereoAnalyze, masteringStreamingPreview, melSpectrogram, melToAudio, melToHz, melToStft, mfcc, mfccToAudio, mfccToMel, midiToHz, mixStereo, mixerScenePresetJson, mixingScenePresetJson, mixingScenePresetNames, momentaryLufs, nnlsChroma, normalize, noteStretch, noteToHz, onsetEnvelope, padCenter, pcen, peakPick, percussive, pitchCorrectToMidi, pitchPyin, pitchShift, pitchYin, plp, powerToDb, preemphasis, resample, rmsEnergy, samplesToFrames, shortTermLufs, spectralBandwidth, spectralCentroid, spectralFlatness, spectralRolloff, splitSilence, stft, stftDb, tempogram, tempogramRatio, timeStretch, timeToFrames, tonnetz, trim, trimSilence, vectorNormalize, version, voiceChange, vqt, zeroCrossingRate };