@libraz/libsonare 1.2.0 → 1.2.2

package/src/sonare.js.d.ts

@@ -2,7 +2,7 @@
  * Type declarations for the Emscripten-generated WASM module with embind
  */
 
-interface SonareModuleOptions {
+export interface SonareModuleOptions {
   locateFile?: (path: string, prefix: string) => string;
   onRuntimeInitialized?: () => void;
   print?: (text: string) => void;
@@ -10,7 +10,7 @@ interface SonareModuleOptions {
 }
 
 // Result types
-interface WasmKeyResult {
+export interface WasmKeyResult {
   root: number;
   mode: number;
   confidence: number;
@@ -18,17 +18,56 @@ interface WasmKeyResult {
   shortName: string;
 }
 
-interface WasmKeyCandidateResult {
+export interface WasmKeyCandidateResult {
   key: WasmKeyResult;
   correlation: number;
 }
 
-interface WasmBeatResult {
+// Flat POD mirror of SonareRealtimeVoiceChangerConfig. Field names match the
+// C ABI / Python POD exactly (snake_case).
+export interface WasmRealtimeVoiceChangerPodConfig {
+  input_gain_db: number;
+  output_gain_db: number;
+  wet_mix: number;
+  retune_semitones: number;
+  retune_mix: number;
+  retune_grain_size: number;
+  formant_factor: number;
+  formant_amount: number;
+  formant_body: number;
+  formant_brightness: number;
+  formant_nasal: number;
+  eq_highpass_hz: number;
+  eq_body_db: number;
+  eq_presence_db: number;
+  eq_air_db: number;
+  gate_threshold_db: number;
+  gate_attack_ms: number;
+  gate_release_ms: number;
+  gate_range_db: number;
+  compressor_threshold_db: number;
+  compressor_ratio: number;
+  compressor_attack_ms: number;
+  compressor_release_ms: number;
+  compressor_makeup_gain_db: number;
+  deesser_frequency_hz: number;
+  deesser_threshold_db: number;
+  deesser_ratio: number;
+  deesser_range_db: number;
+  reverb_mix: number;
+  reverb_time_ms: number;
+  reverb_damping: number;
+  reverb_seed: number;
+  limiter_ceiling_db: number;
+  limiter_release_ms: number;
+}
+
+export interface WasmBeatResult {
   time: number;
   strength: number;
 }
 
-interface WasmChordResult {
+export interface WasmChordResult {
   root: number;
   bass: number;
   quality: number;
@@ -38,7 +77,7 @@ interface WasmChordResult {
   name: string;
 }
 
-interface WasmSectionResult {
+export interface WasmSectionResult {
   type: number;
   start: number;
   end: number;
@@ -47,7 +86,7 @@ interface WasmSectionResult {
   name: string;
 }
 
-interface WasmTimbreResult {
+export interface WasmTimbreResult {
   brightness: number;
   warmth: number;
   density: number;
@@ -55,26 +94,26 @@ interface WasmTimbreResult {
   complexity: number;
 }
 
-interface WasmDynamicsResult {
+export interface WasmDynamicsResult {
   dynamicRangeDb: number;
   loudnessRangeDb: number;
   crestFactor: number;
   isCompressed: boolean;
 }
 
-interface WasmRhythmResult {
+export interface WasmRhythmResult {
   syncopation: number;
   grooveType: string;
   patternRegularity: number;
 }
 
-interface WasmTimeSignatureResult {
+export interface WasmTimeSignatureResult {
   numerator: number;
   denominator: number;
   confidence: number;
 }
 
-interface WasmAnalysisResult {
+export interface WasmAnalysisResult {
   bpm: number;
   bpmConfidence: number;
   key: WasmKeyResult;
@@ -88,11 +127,65 @@ interface WasmAnalysisResult {
   form: string;
 }
 
-interface WasmChordAnalysisResult {
+export interface WasmBpmCandidate {
+  bpm: number;
+  confidence: number;
+}
+
+export interface WasmBpmAnalysisResult {
+  bpm: number;
+  confidence: number;
+  candidates: WasmBpmCandidate[];
+  autocorrelation: Float32Array;
+  tempogram: Float32Array;
+}
+
+export interface WasmRhythmAnalysisResult {
+  timeSignature: WasmTimeSignatureResult;
+  syncopation: number;
+  grooveType: string;
+  patternRegularity: number;
+  tempoStability: number;
+  bpm: number;
+  beatIntervals: Float32Array;
+}
+
+export interface WasmDynamicsAnalysisResult {
+  dynamicRangeDb: number;
+  peakDb: number;
+  rmsDb: number;
+  crestFactor: number;
+  loudnessRangeDb: number;
+  isCompressed: boolean;
+  loudnessTimes: Float32Array;
+  loudnessRmsDb: Float32Array;
+}
+
+export interface WasmTimbreFrameResult {
+  brightness: number;
+  warmth: number;
+  density: number;
+  roughness: number;
+  complexity: number;
+}
+
+export interface WasmTimbreAnalysisResult {
+  brightness: number;
+  warmth: number;
+  density: number;
+  roughness: number;
+  complexity: number;
+  spectralCentroid: Float32Array;
+  spectralFlatness: Float32Array;
+  spectralRolloff: Float32Array;
+  timbreOverTime: WasmTimbreFrameResult[];
+}
+
+export interface WasmChordAnalysisResult {
   chords: WasmChordResult[];
 }
 
-interface WasmAcousticResult {
+export interface WasmAcousticResult {
   rt60: number;
   edt: number;
   c50: number;
@@ -106,13 +199,32 @@ interface WasmAcousticResult {
   isBlind: boolean;
 }
 
-interface WasmHpssResult {
+export interface WasmHpssResult {
+  harmonic: Float32Array;
+  percussive: Float32Array;
+  sampleRate: number;
+}
+
+export interface WasmHpssWithResidualResult {
   harmonic: Float32Array;
   percussive: Float32Array;
+  residual: Float32Array;
   sampleRate: number;
 }
 
-interface WasmStftResult {
+/** Row-major 2-D matrix as a flat buffer plus its dimensions. */
+export interface WasmMatrix2dResult {
+  data: Float32Array;
+  rows: number;
+  cols: number;
+}
+
+export interface WasmDecomposeResult {
+  w: Float32Array;
+  h: Float32Array;
+}
+
+export interface WasmStftResult {
   nBins: number;
   nFrames: number;
   nFft: number;
@@ -122,13 +234,13 @@ interface WasmStftResult {
   power: Float32Array;
 }
 
-interface WasmStftDbResult {
+export interface WasmStftDbResult {
   nBins: number;
   nFrames: number;
   db: Float32Array;
 }
 
-interface WasmMelResult {
+export interface WasmMelResult {
   nMels: number;
   nFrames: number;
   sampleRate: number;
@@ -137,25 +249,25 @@ interface WasmMelResult {
   db: Float32Array;
 }
 
-interface WasmMfccResult {
+export interface WasmMfccResult {
   nMfcc: number;
   nFrames: number;
   coefficients: Float32Array;
 }
 
-interface WasmStftPowerResult {
+export interface WasmStftPowerResult {
   nBins: number;
   nFrames: number;
   power: Float32Array;
 }
 
-interface WasmMelPowerResult {
+export interface WasmMelPowerResult {
   nMels: number;
   nFrames: number;
   power: Float32Array;
 }
 
-interface WasmChromaResult {
+export interface WasmChromaResult {
   nChroma: number;
   nFrames: number;
   sampleRate: number;
@@ -164,7 +276,7 @@ interface WasmChromaResult {
   meanEnergy: number[];
 }
 
-interface WasmPitchResult {
+export interface WasmPitchResult {
   f0: Float32Array;
   voicedProb: Float32Array;
   voicedFlag: boolean[];
@@ -173,48 +285,48 @@ interface WasmPitchResult {
   meanF0: number;
 }
 
-interface WasmTrimResult {
+export interface WasmTrimResult {
   audio: Float32Array;
   startSample: number;
   endSample: number;
 }
 
-interface WasmFrameResult {
+export interface WasmFrameResult {
   nFrames: number;
   frames: Float32Array;
 }
 
-interface WasmTempogramResult {
+export interface WasmTempogramResult {
   nFrames: number;
   winLength: number;
   data: Float32Array;
 }
 
-interface WasmCyclicTempogramResult {
+export interface WasmCyclicTempogramResult {
   nFrames: number;
   nBins: number;
   data: Float32Array;
 }
 
-interface WasmFourierTempogramResult {
+export interface WasmFourierTempogramResult {
   nBins: number;
   nFrames: number;
   data: Float32Array;
 }
 
-interface WasmNnlsChromaResult {
+export interface WasmNnlsChromaResult {
   nChroma: number;
   nFrames: number;
   data: Float32Array;
 }
 
-interface WasmMelodyPoint {
+export interface WasmMelodyPoint {
   time: number;
   frequency: number;
   confidence: number;
 }
 
-interface WasmMelodyResult {
+export interface WasmMelodyResult {
   points: WasmMelodyPoint[];
   pitchRangeOctaves: number;
   pitchStability: number;
@@ -222,7 +334,7 @@ interface WasmMelodyResult {
   vibratoRate: number;
 }
 
-interface WasmCqtResult {
+export interface WasmCqtResult {
   nBins: number;
   nFrames: number;
   hopLength: number;
@@ -231,14 +343,14 @@ interface WasmCqtResult {
   frequencies: Float32Array;
 }
 
-interface WasmLufsResult {
+export interface WasmLufsResult {
   integratedLufs: number;
   momentaryLufs: number;
   shortTermLufs: number;
   loudnessRange: number;
 }
 
-interface WasmMasteringResult {
+export interface WasmMasteringResult {
   samples: Float32Array;
   sampleRate: number;
   inputLufs: number;
@@ -247,11 +359,11 @@ interface WasmMasteringResult {
   latencySamples?: number;
 }
 
-interface WasmMasteringChainResult extends WasmMasteringResult {
+export interface WasmMasteringChainResult extends WasmMasteringResult {
   stages: string[];
 }
 
-interface WasmMasteringStereoChainResult {
+export interface WasmMasteringStereoChainResult {
   left: Float32Array;
   right: Float32Array;
   sampleRate: number;
@@ -261,7 +373,7 @@ interface WasmMasteringStereoChainResult {
   stages: string[];
 }
 
-interface WasmMasteringStereoResult {
+export interface WasmMasteringStereoResult {
   left: Float32Array;
   right: Float32Array;
   sampleRate: number;
@@ -271,7 +383,7 @@ interface WasmMasteringStereoResult {
   latencySamples: number;
 }
 
-interface WasmMixMeterSnapshot {
+export interface WasmMixMeterSnapshot {
   peakDbL: number;
   peakDbR: number;
   rmsDbL: number;
@@ -291,14 +403,14 @@ interface WasmMixMeterSnapshot {
   seq: number;
 }
 
-interface WasmMixResult {
+export interface WasmMixResult {
   left: Float32Array;
   right: Float32Array;
   sampleRate: number;
   meters: WasmMixMeterSnapshot[];
 }
 
-interface WasmEngineClip {
+export interface WasmEngineClip {
   id?: number;
   channels: Float32Array[];
   startPpq: number;
@@ -310,7 +422,7 @@ interface WasmEngineClip {
   fadeOutSamples?: number;
 }
 
-interface WasmEngineParameterInfo {
+export interface WasmEngineParameterInfo {
   id: number;
   name: string;
   unit: string;
@@ -321,33 +433,33 @@ interface WasmEngineParameterInfo {
   defaultCurve: number;
 }
 
-interface WasmEngineAutomationPoint {
+export interface WasmEngineAutomationPoint {
   ppq: number;
   value: number;
   curveToNext?: number;
 }
 
-interface WasmEngineMarker {
+export interface WasmEngineMarker {
   id: number;
   ppq: number;
   name?: string;
 }
 
-interface WasmEngineMetronomeConfig {
+export interface WasmEngineMetronomeConfig {
   enabled: boolean;
   beatGain?: number;
   accentGain?: number;
   clickSamples?: number;
 }
 
-interface WasmEngineGraphNode {
+export interface WasmEngineGraphNode {
   id: string;
   type?: number;
   gainDb?: number;
   numPorts?: number;
 }
 
-interface WasmEngineGraphConnection {
+export interface WasmEngineGraphConnection {
   sourceNode: string;
   sourcePort: number;
   destNode: string;
@@ -355,12 +467,12 @@ interface WasmEngineGraphConnection {
   mix?: number;
 }
 
-interface WasmEngineGraphParameterBinding {
+export interface WasmEngineGraphParameterBinding {
   paramId: number;
   nodeId: string;
 }
 
-interface WasmEngineGraphSpec {
+export interface WasmEngineGraphSpec {
   nodes: WasmEngineGraphNode[];
   connections: WasmEngineGraphConnection[];
   inputNode: string;
@@ -369,7 +481,7 @@ interface WasmEngineGraphSpec {
   parameterBindings?: WasmEngineGraphParameterBinding[];
 }
 
-interface WasmEngineTelemetry {
+export interface WasmEngineTelemetry {
   type: number;
   error: number;
   renderFrame: number;
@@ -379,7 +491,7 @@ interface WasmEngineTelemetry {
   value: number;
 }
 
-interface WasmEngineMeterTelemetry {
+export interface WasmEngineMeterTelemetry {
   targetId: number;
   renderFrame: number;
   seq: number;
@@ -399,14 +511,14 @@ interface WasmEngineMeterTelemetry {
   droppedRecords: number;
 }
 
-interface WasmEngineCaptureStatus {
+export interface WasmEngineCaptureStatus {
   capturedFrames: number;
   overflowCount: number;
   armed: boolean;
   punchEnabled: boolean;
 }
 
-interface WasmEngineTransportState {
+export interface WasmEngineTransportState {
   playing: boolean;
   looping: boolean;
   renderFrame: number;
@@ -418,7 +530,7 @@ interface WasmEngineTransportState {
   sampleRate: number;
 }
 
-interface WasmEngineBounceOptions {
+export interface WasmEngineBounceOptions {
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
@@ -431,7 +543,7 @@ interface WasmEngineBounceOptions {
   ditherSeed?: number;
 }
 
-interface WasmEngineBounceResult {
+export interface WasmEngineBounceResult {
   interleaved: Float32Array;
   frames: number;
   numChannels: number;
@@ -439,7 +551,7 @@ interface WasmEngineBounceResult {
   integratedLufs: number;
 }
 
-interface WasmEngineFreezeOptions {
+export interface WasmEngineFreezeOptions {
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
@@ -448,18 +560,18 @@ interface WasmEngineFreezeOptions {
   gain?: number;
 }
 
-interface WasmEngineFreezeResult {
+export interface WasmEngineFreezeResult {
   clipId: number;
   frames: number;
   numChannels: number;
 }
 
-interface WasmEngineProcessWithMonitorResult {
+export interface WasmEngineProcessWithMonitorResult {
   output: Float32Array[];
   monitor: Float32Array[];
 }
 
-interface WasmRealtimeEngine {
+export interface WasmRealtimeEngine {
   prepare: (
     sampleRate: number,
     maxBlockSize: number,
@@ -512,10 +624,10 @@ interface WasmRealtimeEngine {
   delete: () => void;
 }
 
-type ProgressCallback = (progress: number, stage: string) => void;
-type TempogramMode = 'autocorrelation' | 'auto' | 'ac' | 'cosine' | 0 | 1;
+export type ProgressCallback = (progress: number, stage: string) => void;
+export type TempogramMode = 'autocorrelation' | 'auto' | 'ac' | 'cosine' | 0 | 1;
 
-interface SonareModule {
+export interface SonareModule {
   // Quick API (high-level)
   detectBpm: (samples: Float32Array, sampleRate: number) => number;
   detectKey: (samples: Float32Array, sampleRate: number) => WasmKeyResult;
@@ -583,8 +695,139 @@ interface SonareModule {
     sampleRate: number,
     progressCallback: ProgressCallback | null,
   ) => WasmAnalysisResult;
+  analyzeBpm: (
+    samples: Float32Array,
+    sampleRate: number,
+    bpmMin: number,
+    bpmMax: number,
+    startBpm: number,
+    nFft: number,
+    hopLength: number,
+    maxCandidates: number,
+  ) => WasmBpmAnalysisResult;
+  analyzeRhythm: (
+    samples: Float32Array,
+    sampleRate: number,
+    bpmMin: number,
+    bpmMax: number,
+    startBpm: number,
+    nFft: number,
+    hopLength: number,
+  ) => WasmRhythmAnalysisResult;
+  analyzeDynamics: (
+    samples: Float32Array,
+    sampleRate: number,
+    windowSec: number,
+    hopLength: number,
+    compressionThreshold: number,
+  ) => WasmDynamicsAnalysisResult;
+  analyzeTimbre: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    nMels: number,
+    nMfcc: number,
+    windowSec: number,
+  ) => WasmTimbreAnalysisResult;
+  detectKeyCandidates: (samples: Float32Array, sampleRate: number) => WasmKeyCandidateResult[];
+  hasFfmpegSupport: () => boolean;
   version: () => string;
   engineAbiVersion: () => number;
+  voiceChangerAbiVersion: () => number;
+  voiceCharacterPresetId: (preset: number) => string | null;
+  realtimeVoiceChangerPresetConfig: (preset: number) => WasmRealtimeVoiceChangerPodConfig | null;
+
+  meteringPeakDb: (samples: Float32Array, sampleRate: number) => number;
+  meteringRmsDb: (samples: Float32Array, sampleRate: number) => number;
+  meteringCrestFactorDb: (samples: Float32Array, sampleRate: number) => number;
+  meteringDcOffset: (samples: Float32Array, sampleRate: number) => number;
+  meteringTruePeakDb: (
+    samples: Float32Array,
+    sampleRate: number,
+    oversampleFactor: number,
+  ) => number;
+  meteringDetectClipping: (
+    samples: Float32Array,
+    sampleRate: number,
+    threshold: number,
+    minRegionSamples: number,
+  ) => {
+    clippedSamples: number;
+    clippingRatio: number;
+    maxClippedPeak: number;
+    regions: Array<{ startSample: number; endSample: number; length: number; peak: number }>;
+  };
+  meteringDynamicRange: (
+    samples: Float32Array,
+    sampleRate: number,
+    windowSec: number,
+    hopSec: number,
+    lowPercentile: number,
+    highPercentile: number,
+  ) => {
+    dynamicRangeDb: number;
+    lowPercentileDb: number;
+    highPercentileDb: number;
+    windowRmsDb: Float32Array;
+  };
+
+  meteringStereoCorrelation: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+  ) => number;
+  meteringStereoWidth: (left: Float32Array, right: Float32Array, sampleRate: number) => number;
+  meteringVectorscope: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+  ) => { mid: Float32Array; side: Float32Array };
+  meteringPhaseScope: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+  ) => {
+    mid: Float32Array;
+    side: Float32Array;
+    radius: Float32Array;
+    angleRad: Float32Array;
+    correlation: number;
+    averageAbsAngleRad: number;
+    maxRadius: number;
+  };
+  meteringSpectrum: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: {
+      nFft?: number;
+      applyOctaveSmoothing?: boolean;
+      octaveFraction?: number;
+      dbRef?: number;
+      dbAmin?: number;
+    },
+  ) => {
+    frequencies: Float32Array;
+    magnitude: Float32Array;
+    power: Float32Array;
+    db: Float32Array;
+    nFft: number;
+    sampleRate: number;
+  };
+
+  scaleQuantizeMidi: (
+    root: number,
+    modeMask: number,
+    midi: number,
+    referenceMidi: number,
+  ) => number;
+  scaleCorrectionSemitones: (
+    root: number,
+    modeMask: number,
+    midi: number,
+    referenceMidi: number,
+  ) => number;
+  scalePitchClassEnabled: (root: number, modeMask: number, pitchClass: number) => boolean;
 
   // Effects
   hpss: (
@@ -593,6 +836,41 @@ interface SonareModule {
     kernelHarmonic: number,
     kernelPercussive: number,
   ) => WasmHpssResult;
+  hpssWithResidual: (
+    samples: Float32Array,
+    sampleRate: number,
+    kernelHarmonic: number,
+    kernelPercussive: number,
+  ) => WasmHpssWithResidualResult;
+  decompose: (
+    s: Float32Array,
+    nFeatures: number,
+    nFrames: number,
+    nComponents: number,
+    nIter: number,
+    beta: number,
+  ) => WasmDecomposeResult;
+  nnFilter: (
+    s: Float32Array,
+    nFeatures: number,
+    nFrames: number,
+    aggregate: string,
+    k: number,
+    width: number,
+  ) => WasmMatrix2dResult;
+  remix: (
+    samples: Float32Array,
+    intervals: Int32Array,
+    sampleRate: number,
+    alignZeros: boolean,
+  ) => Float32Array;
+  phaseVocoder: (
+    samples: Float32Array,
+    sampleRate: number,
+    rate: number,
+    nFft: number,
+    hopLength: number,
+  ) => Float32Array;
   harmonic: (samples: Float32Array, sampleRate: number) => Float32Array;
   percussive: (samples: Float32Array, sampleRate: number) => Float32Array;
   timeStretch: (samples: Float32Array, sampleRate: number, rate: number) => Float32Array;
@@ -677,6 +955,56 @@ interface SonareModule {
     sampleRate: number,
     platforms: Array<{ name: string; targetLufs: number; ceilingDb: number }>,
   ) => string;
+  masteringRepairDeclick: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairDenoiseClassical: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairDeclip: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairDecrackle: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairDehum: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairDereverbClassical: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringRepairTrimSilence: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => Float32Array;
+  masteringDynamicsCompressor: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => { samples: Float32Array; latencySamples: number };
+  masteringDynamicsGate: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => { samples: Float32Array; latencySamples: number };
+  masteringDynamicsTransientShaper: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => { samples: Float32Array; latencySamples: number };
   masteringChain: (
     samples: Float32Array,
     sampleRate: number,
@@ -715,6 +1043,21 @@ interface SonareModule {
     sampleRate: number,
     overrides: Record<string, number | boolean> | null,
   ) => WasmMasteringStereoChainResult;
+  masterAudioWithProgress: (
+    presetName: string,
+    samples: Float32Array,
+    sampleRate: number,
+    overrides: Record<string, number | boolean> | null,
+    progressCallback: ProgressCallback | null,
+  ) => WasmMasteringChainResult;
+  masterAudioStereoWithProgress: (
+    presetName: string,
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    overrides: Record<string, number | boolean> | null,
+    progressCallback: ProgressCallback | null,
+  ) => WasmMasteringStereoChainResult;
   mixingScenePresetNames: () => string[];
   mixingScenePresetJson: (presetName: string) => string;
   mixStereo: (
@@ -763,7 +1106,6 @@ interface SonareModule {
     nFrames: number,
     sampleRate: number,
     nFft: number,
-    hopLength: number,
     fmin: number,
     fmax: number,
   ) => WasmStftPowerResult;
@@ -774,9 +1116,9 @@ interface SonareModule {
     sampleRate: number,
     nFft: number,
     hopLength: number,
-    nIter: number,
     fmin: number,
     fmax: number,
+    nIter: number,
   ) => Float32Array;
   mfccToMel: (
     mfcc: Float32Array,
@@ -792,9 +1134,9 @@ interface SonareModule {
     sampleRate: number,
     nFft: number,
     hopLength: number,
-    nIter: number,
     fmin: number,
     fmax: number,
+    nIter: number,
   ) => Float32Array;
 
   // Features - Chroma
@@ -843,6 +1185,38 @@ interface SonareModule {
     frameLength: number,
     hopLength: number,
   ) => Float32Array;
+  spectralContrast: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    nBands: number,
+    fmin: number,
+    quantile: number,
+  ) => WasmMatrix2dResult;
+  polyFeatures: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    order: number,
+  ) => WasmMatrix2dResult;
+  zeroCrossings: (
+    samples: Float32Array,
+    threshold: number,
+    refMagnitude: boolean,
+    pad: boolean,
+    zeroPos: boolean,
+  ) => Int32Array;
+  pitchTuning: (frequencies: Float32Array, resolution: number, binsPerOctave: number) => number;
+  estimateTuning: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    resolution: number,
+    binsPerOctave: number,
+  ) => number;
 
   // Features - Pitch
   pitchYin: (
@@ -853,6 +1227,7 @@ interface SonareModule {
     fmin: number,
     fmax: number,
     threshold: number,
+    fillNa: boolean,
   ) => WasmPitchResult;
   pitchPyin: (
     samples: Float32Array,
@@ -862,6 +1237,7 @@ interface SonareModule {
     fmin: number,
     fmax: number,
     threshold: number,
+    fillNa: boolean,
   ) => WasmPitchResult;
 
   // Core - Conversion
@@ -993,6 +1369,8 @@ interface SonareModule {
   lufs: (samples: Float32Array, sampleRate: number) => WasmLufsResult;
   momentaryLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
   shortTermLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
+  lufsInterleaved: (samples: Float32Array, channels: number, sampleRate: number) => WasmLufsResult;
+  ebur128LoudnessRange: (samples: Float32Array, sampleRate: number) => number;
 
   // Core - Resample
   resample: (samples: Float32Array, srcSr: number, targetSr: number) => Float32Array;
@@ -1081,12 +1459,24 @@ interface SonareModule {
   // Streaming - StreamingEqualizer
   createEqualizer: (config: Record<string, unknown>) => WasmStreamingEqualizer;
 
+  // Streaming - StreamingRetune
+  createStreamingRetune: (config: Record<string, unknown>) => WasmStreamingRetune;
+  createRealtimeVoiceChanger: (
+    config: Record<string, unknown> | string,
+  ) => WasmRealtimeVoiceChanger;
+  realtimeVoiceChangerPresetNames: () => string[];
+  realtimeVoiceChangerPresetJson: (id: string) => string;
+  validateRealtimeVoiceChangerPresetJson: (json: string) => {
+    ok: boolean;
+    normalizedJson?: string;
+    error?: string;
+  };
+
   // Mixing - scene-based Mixer
   createMixerFromSceneJson: (json: string, sampleRate: number, blockSize: number) => WasmMixer;
-  mixerPresetJson: (presetName: string) => string;
 }
 
-interface WasmStreamingMasteringChain {
+export interface WasmStreamingMasteringChain {
   prepare: (sampleRate: number, maxBlockSize: number, numChannels: number) => void;
   processMono: (samples: Float32Array) => Float32Array;
   processStereo: (
@@ -1099,7 +1489,7 @@ interface WasmStreamingMasteringChain {
   delete: () => void;
 }
 
-interface WasmEqSpectrumSnapshot {
+export interface WasmEqSpectrumSnapshot {
   preLeft: Float32Array;
   preRight: Float32Array;
   postLeft: Float32Array;
@@ -1110,7 +1500,7 @@ interface WasmEqSpectrumSnapshot {
   seq: number;
 }
 
-interface WasmStreamingEqualizer {
+export interface WasmStreamingEqualizer {
   setBand: (index: number, band: Record<string, unknown>) => void;
   clear: () => void;
   setPhaseMode: (mode: number) => void;
@@ -1133,7 +1523,42 @@ interface WasmStreamingEqualizer {
   delete: () => void;
 }
 
-interface WasmMixer {
+export interface WasmStreamingRetune {
+  prepare: (sampleRate: number, maxBlockSize: number) => void;
+  reset: () => void;
+  setConfig: (config: Record<string, unknown>) => void;
+  config: () => { semitones: number; mix: number; grainSize: number };
+  grainSize: () => number;
+  processMono: (samples: Float32Array) => Float32Array;
+  delete: () => void;
+}
+
+export interface WasmRealtimeVoiceChanger {
+  prepare: (sampleRate: number, maxBlockSize: number, channels: number) => void;
+  reset: () => void;
+  setConfig: (config: Record<string, unknown> | string) => void;
+  configJson: () => string;
+  latencySamples: () => number;
+  processMono: (samples: Float32Array) => Float32Array;
+  processMonoInto: (samples: Float32Array, output: Float32Array) => void;
+  processInterleaved: (samples: Float32Array, channels: number) => Float32Array;
+  processInterleavedInto: (samples: Float32Array, channels: number, output: Float32Array) => void;
+  // Zero-copy "prepared" path. The returned Float32Array is a typed_memory_view
+  // backed by the WASM heap; it is only valid until the next call to a method
+  // that may grow the underlying scratch buffer (i.e. another get*Buffer with a
+  // larger length) or until delete().
+  getMonoInputBuffer: (numSamples: number) => Float32Array;
+  getMonoOutputBuffer: (numSamples: number) => Float32Array;
+  processPreparedMono: (numSamples: number) => void;
+  getInterleavedInputBuffer: (numFrames: number, numChannels: number) => Float32Array;
+  getInterleavedOutputBuffer: (numFrames: number, numChannels: number) => Float32Array;
+  processPreparedInterleaved: (numFrames: number, numChannels: number) => void;
+  getPlanarChannelBuffer: (channel: number, numFrames: number) => Float32Array;
+  processPreparedPlanar: (numFrames: number) => void;
+  delete: () => void;
+}
+
+export interface WasmMixer {
   compile: () => void;
   processStereo: (
     leftChannels: Float32Array[],
@@ -1160,6 +1585,11 @@ interface WasmMixer {
     curve: number,
   ) => void;
   stripById: (id: string) => number;
+  setInputTrimDb: (stripIndex: number, db: number) => void;
+  setFaderDb: (stripIndex: number, db: number) => void;
+  setPan: (stripIndex: number, pan: number, panMode: number) => void;
+  setWidth: (stripIndex: number, width: number) => void;
+  setMuted: (stripIndex: number, muted: boolean) => void;
   setSoloed: (stripIndex: number, soloed: boolean) => void;
   setSoloSafe: (stripIndex: number, soloSafe: boolean) => void;
   setPolarityInvert: (stripIndex: number, invertLeft: boolean, invertRight: boolean) => void;
@@ -1213,20 +1643,20 @@ interface WasmMixer {
   delete: () => void;
 }
 
-interface WasmGoniometerPoint {
+export interface WasmGoniometerPoint {
   left: number;
   right: number;
 }
 
 // Streaming types for StreamAnalyzer
-interface WasmChordChange {
+export interface WasmChordChange {
   root: number;
   quality: number;
   startTime: number;
   confidence: number;
 }
 
-interface WasmBarChord {
+export interface WasmBarChord {
   barIndex: number;
   root: number;
   quality: number;
@@ -1234,12 +1664,12 @@ interface WasmBarChord {
   confidence: number;
 }
 
-interface WasmPatternScore {
+export interface WasmPatternScore {
   name: string;
   score: number;
 }
 
-interface WasmProgressiveEstimate {
+export interface WasmProgressiveEstimate {
   bpm: number;
   bpmConfidence: number;
   bpmCandidateCount: number;
@@ -1264,14 +1694,14 @@ interface WasmProgressiveEstimate {
   updated: boolean;
 }
 
-interface WasmAnalyzerStats {
+export interface WasmAnalyzerStats {
   totalFrames: number;
   totalSamples: number;
   durationSeconds: number;
   estimate: WasmProgressiveEstimate;
 }
 
-interface WasmFrameBuffer {
+export interface WasmFrameBuffer {
   nFrames: number;
   timestamps: Float32Array;
   mel: Float32Array;
@@ -1285,7 +1715,7 @@ interface WasmFrameBuffer {
   chordConfidence: Float32Array;
 }
 
-interface WasmStreamFramesU8 {
+export interface WasmStreamFramesU8 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
@@ -1297,7 +1727,7 @@ interface WasmStreamFramesU8 {
   spectralFlatness: Uint8Array;
 }
 
-interface WasmStreamFramesI16 {
+export interface WasmStreamFramesI16 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
@@ -1309,7 +1739,7 @@ interface WasmStreamFramesI16 {
   spectralFlatness: Int16Array;
 }
 
-interface WasmStreamAnalyzer {
+export interface WasmStreamAnalyzer {
   process: (samples: Float32Array) => void;
   processWithOffset: (samples: Float32Array, sampleOffset: number) => void;
   availableFrames: () => number;