@libraz/libsonare 1.2.1 → 1.2.3

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,58 @@ 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;
+  limiter_enable_isp_limiter: boolean;
+  limiter_isp_ceiling_dbtp: number;
+}
+
+export interface WasmBeatResult {
   time: number;
   strength: number;
 }
 
-interface WasmChordResult {
+export interface WasmChordResult {
   root: number;
   bass: number;
   quality: number;
@@ -38,7 +79,7 @@ interface WasmChordResult {
   name: string;
 }
 
-interface WasmSectionResult {
+export interface WasmSectionResult {
   type: number;
   start: number;
   end: number;
@@ -47,7 +88,7 @@ interface WasmSectionResult {
   name: string;
 }
 
-interface WasmTimbreResult {
+export interface WasmTimbreResult {
   brightness: number;
   warmth: number;
   density: number;
@@ -55,26 +96,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 +129,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 +201,88 @@ interface WasmAcousticResult {
   isBlind: boolean;
 }
 
-interface WasmHpssResult {
+export interface WasmRoomGeometryOptions {
+  lengthM?: number;
+  widthM?: number;
+  heightM?: number;
+  absorption?: number;
+  sourceX?: number;
+  sourceY?: number;
+  sourceZ?: number;
+  listenerX?: number;
+  listenerY?: number;
+  listenerZ?: number;
+  ismOrder?: number;
+  seed?: number;
+  maxSeconds?: number;
+}
+
+export interface WasmRirSynthOptions extends WasmRoomGeometryOptions {
+  sampleRate?: number;
+  preferEyring?: boolean;
+  mixingTimeMs?: number;
+  crossfadeMs?: number;
+}
+
+export interface WasmRirResult {
+  rir: Float32Array;
+  sampleRate: number;
+  hasError: boolean;
+}
+
+export interface WasmRoomEstimateOptions {
+  aspectHintLw?: number;
+  aspectHintLh?: number;
+  referenceAbsorption?: number;
+  preferEyring?: boolean;
+  nOctaveBands?: number;
+  mode?: number;
+  minDecayDb?: number;
+  noiseFloorMarginDb?: number;
+}
+
+export interface WasmRoomEstimateResult {
+  volume: number;
+  length: number;
+  width: number;
+  height: number;
+  drrDb: number;
+  confidence: number;
+  absorptionBands: Float32Array;
+  rt60Bands: Float32Array;
+}
+
+export interface WasmRoomMorphOptions extends WasmRoomGeometryOptions {
+  wet?: number;
+  sourceTailSuppression?: number;
+}
+
+export interface WasmHpssResult {
   harmonic: Float32Array;
   percussive: Float32Array;
   sampleRate: number;
 }
 
-interface WasmStftResult {
+export interface WasmHpssWithResidualResult {
+  harmonic: Float32Array;
+  percussive: Float32Array;
+  residual: Float32Array;
+  sampleRate: number;
+}
+
+/** 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 +292,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 +307,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 +334,7 @@ interface WasmChromaResult {
   meanEnergy: number[];
 }
 
-interface WasmPitchResult {
+export interface WasmPitchResult {
   f0: Float32Array;
   voicedProb: Float32Array;
   voicedFlag: boolean[];
@@ -173,48 +343,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 +392,7 @@ interface WasmMelodyResult {
   vibratoRate: number;
 }
 
-interface WasmCqtResult {
+export interface WasmCqtResult {
   nBins: number;
   nFrames: number;
   hopLength: number;
@@ -231,14 +401,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 +417,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 +431,7 @@ interface WasmMasteringStereoChainResult {
   stages: string[];
 }
 
-interface WasmMasteringStereoResult {
+export interface WasmMasteringStereoResult {
   left: Float32Array;
   right: Float32Array;
   sampleRate: number;
@@ -271,7 +441,7 @@ interface WasmMasteringStereoResult {
   latencySamples: number;
 }
 
-interface WasmMixMeterSnapshot {
+export interface WasmMixMeterSnapshot {
   peakDbL: number;
   peakDbR: number;
   rmsDbL: number;
@@ -291,14 +461,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 +480,7 @@ interface WasmEngineClip {
   fadeOutSamples?: number;
 }
 
-interface WasmEngineParameterInfo {
+export interface WasmEngineParameterInfo {
   id: number;
   name: string;
   unit: string;
@@ -321,33 +491,35 @@ 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;
+  /** Optional click length in seconds; > 0 overrides the engine 2 ms default. */
+  clickSeconds?: 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 +527,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 +541,7 @@ interface WasmEngineGraphSpec {
   parameterBindings?: WasmEngineGraphParameterBinding[];
 }
 
-interface WasmEngineTelemetry {
+export interface WasmEngineTelemetry {
   type: number;
   error: number;
   renderFrame: number;
@@ -379,7 +551,7 @@ interface WasmEngineTelemetry {
   value: number;
 }
 
-interface WasmEngineMeterTelemetry {
+export interface WasmEngineMeterTelemetry {
   targetId: number;
   renderFrame: number;
   seq: number;
@@ -399,14 +571,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;
@@ -416,9 +588,15 @@ interface WasmEngineTransportState {
   loopStartPpq: number;
   loopEndPpq: number;
   sampleRate: number;
+  /** PPQ of the current bar's downbeat (derived from the tempo map). */
+  barStartPpq: number;
+  /** Zero-based index of the current bar. */
+  barCount: number;
+  /** Time signature in effect at the current PPQ. */
+  timeSignature: { numerator: number; denominator: number; confidence: number };
 }
 
-interface WasmEngineBounceOptions {
+export interface WasmEngineBounceOptions {
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
@@ -431,7 +609,7 @@ interface WasmEngineBounceOptions {
   ditherSeed?: number;
 }
 
-interface WasmEngineBounceResult {
+export interface WasmEngineBounceResult {
   interleaved: Float32Array;
   frames: number;
   numChannels: number;
@@ -439,7 +617,7 @@ interface WasmEngineBounceResult {
   integratedLufs: number;
 }
 
-interface WasmEngineFreezeOptions {
+export interface WasmEngineFreezeOptions {
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
@@ -448,18 +626,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,
@@ -503,6 +681,9 @@ interface WasmRealtimeEngine {
   captureStatus: () => WasmEngineCaptureStatus;
   capturedAudio: () => Float32Array[];
   process: (channels: Float32Array[]) => Float32Array[];
+  prepareChannels: (numChannels: number, maxFrames: number) => void;
+  getChannelBuffer: (channel: number, numFrames: number) => Float32Array;
+  processPrepared: (numFrames: number) => void;
   processWithMonitor: (channels: Float32Array[]) => WasmEngineProcessWithMonitorResult;
   renderOffline: (channels: Float32Array[], blockSize: number) => Float32Array[];
   bounceOffline: (options: WasmEngineBounceOptions) => WasmEngineBounceResult;
@@ -512,10 +693,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;
@@ -578,13 +759,157 @@ interface SonareModule {
     minDecayDb: number,
     noiseFloorMarginDb: number,
   ) => WasmAcousticResult;
+  // Acoustic-simulation entry points are present only in builds compiled with
+  // SONARE_WITH_ACOUSTIC_SIM; absent otherwise (the wrappers throw a clear error).
+  synthesizeRir?: (options: WasmRirSynthOptions) => WasmRirResult;
+  estimateRoom?: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: WasmRoomEstimateOptions,
+  ) => WasmRoomEstimateResult;
+  roomMorph?: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: WasmRoomMorphOptions,
+  ) => Float32Array;
   analyzeWithProgress: (
     samples: Float32Array,
     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 +918,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 +1037,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 +1125,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 +1188,6 @@ interface SonareModule {
     nFrames: number,
     sampleRate: number,
     nFft: number,
-    hopLength: number,
     fmin: number,
     fmax: number,
   ) => WasmStftPowerResult;
@@ -774,9 +1198,9 @@ interface SonareModule {
     sampleRate: number,
     nFft: number,
     hopLength: number,
-    nIter: number,
     fmin: number,
     fmax: number,
+    nIter: number,
   ) => Float32Array;
   mfccToMel: (
     mfcc: Float32Array,
@@ -792,9 +1216,9 @@ interface SonareModule {
     sampleRate: number,
     nFft: number,
     hopLength: number,
-    nIter: number,
     fmin: number,
     fmax: number,
+    nIter: number,
   ) => Float32Array;
 
   // Features - Chroma
@@ -843,6 +1267,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 +1309,7 @@ interface SonareModule {
     fmin: number,
     fmax: number,
     threshold: number,
+    fillNa: boolean,
   ) => WasmPitchResult;
   pitchPyin: (
     samples: Float32Array,
@@ -862,6 +1319,7 @@ interface SonareModule {
     fmin: number,
     fmax: number,
     threshold: number,
+    fillNa: boolean,
   ) => WasmPitchResult;
 
   // Core - Conversion
@@ -993,6 +1451,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;
@@ -1083,13 +1543,22 @@ interface SonareModule {
 
   // 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: (
@@ -1102,7 +1571,7 @@ interface WasmStreamingMasteringChain {
   delete: () => void;
 }
 
-interface WasmEqSpectrumSnapshot {
+export interface WasmEqSpectrumSnapshot {
   preLeft: Float32Array;
   preRight: Float32Array;
   postLeft: Float32Array;
@@ -1113,7 +1582,7 @@ interface WasmEqSpectrumSnapshot {
   seq: number;
 }
 
-interface WasmStreamingEqualizer {
+export interface WasmStreamingEqualizer {
   setBand: (index: number, band: Record<string, unknown>) => void;
   clear: () => void;
   setPhaseMode: (mode: number) => void;
@@ -1136,7 +1605,7 @@ interface WasmStreamingEqualizer {
   delete: () => void;
 }
 
-interface WasmStreamingRetune {
+export interface WasmStreamingRetune {
   prepare: (sampleRate: number, maxBlockSize: number) => void;
   reset: () => void;
   setConfig: (config: Record<string, unknown>) => void;
@@ -1146,7 +1615,32 @@ interface WasmStreamingRetune {
   delete: () => void;
 }
 
-interface WasmMixer {
+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[],
@@ -1173,6 +1667,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;
@@ -1226,20 +1725,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;
@@ -1247,12 +1746,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;
@@ -1277,15 +1776,17 @@ interface WasmProgressiveEstimate {
   updated: boolean;
 }
 
-interface WasmAnalyzerStats {
+export interface WasmAnalyzerStats {
   totalFrames: number;
   totalSamples: number;
   durationSeconds: number;
   estimate: WasmProgressiveEstimate;
 }
 
-interface WasmFrameBuffer {
+export interface WasmFrameBuffer {
   nFrames: number;
+  /** Number of mel bands; flat `mel` is `[nFrames * nMels]` row-major. */
+  nMels: number;
   timestamps: Float32Array;
   mel: Float32Array;
   chroma: Float32Array;
@@ -1298,7 +1799,7 @@ interface WasmFrameBuffer {
   chordConfidence: Float32Array;
 }
 
-interface WasmStreamFramesU8 {
+export interface WasmStreamFramesU8 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
@@ -1310,7 +1811,7 @@ interface WasmStreamFramesU8 {
   spectralFlatness: Uint8Array;
 }
 
-interface WasmStreamFramesI16 {
+export interface WasmStreamFramesI16 {
   nFrames: number;
   nMels: number;
   timestamps: Float32Array;
@@ -1322,7 +1823,7 @@ interface WasmStreamFramesI16 {
   spectralFlatness: Int16Array;
 }
 
-interface WasmStreamAnalyzer {
+export interface WasmStreamAnalyzer {
   process: (samples: Float32Array) => void;
   processWithOffset: (samples: Float32Array, sampleOffset: number) => void;
   availableFrames: () => number;