@libraz/libsonare 1.1.0 → 1.2.1

package/src/sonare.js.d.ts

@@ -18,6 +18,11 @@ interface WasmKeyResult {
   shortName: string;
 }
 
+interface WasmKeyCandidateResult {
+  key: WasmKeyResult;
+  correlation: number;
+}
+
 interface WasmBeatResult {
   time: number;
   strength: number;
@@ -25,6 +30,7 @@ interface WasmBeatResult {
 
 interface WasmChordResult {
   root: number;
+  bass: number;
   quality: number;
   start: number;
   end: number;
@@ -82,6 +88,24 @@ interface WasmAnalysisResult {
   form: string;
 }
 
+interface WasmChordAnalysisResult {
+  chords: WasmChordResult[];
+}
+
+interface WasmAcousticResult {
+  rt60: number;
+  edt: number;
+  c50: number;
+  c80: number;
+  d50: number;
+  rt60Bands: Float32Array;
+  edtBands: Float32Array;
+  c50Bands: Float32Array;
+  c80Bands: Float32Array;
+  confidence: number;
+  isBlind: boolean;
+}
+
 interface WasmHpssResult {
   harmonic: Float32Array;
   percussive: Float32Array;
@@ -119,6 +143,18 @@ interface WasmMfccResult {
   coefficients: Float32Array;
 }
 
+interface WasmStftPowerResult {
+  nBins: number;
+  nFrames: number;
+  power: Float32Array;
+}
+
+interface WasmMelPowerResult {
+  nMels: number;
+  nFrames: number;
+  power: Float32Array;
+}
+
 interface WasmChromaResult {
   nChroma: number;
   nFrames: number;
@@ -154,6 +190,54 @@ interface WasmTempogramResult {
   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 WasmMelodyPoint {
+  time: number;
+  frequency: number;
+  confidence: number;
+}
+
+interface WasmMelodyResult {
+  points: WasmMelodyPoint[];
+  pitchRangeOctaves: number;
+  pitchStability: number;
+  meanFrequency: number;
+  vibratoRate: number;
+}
+
+interface WasmCqtResult {
+  nBins: number;
+  nFrames: number;
+  hopLength: number;
+  sampleRate: number;
+  magnitude: Float32Array;
+  frequencies: Float32Array;
+}
+
+interface WasmLufsResult {
+  integratedLufs: number;
+  momentaryLufs: number;
+  shortTermLufs: number;
+  loudnessRange: number;
+}
+
 interface WasmMasteringResult {
   samples: Float32Array;
   sampleRate: number;
@@ -187,21 +271,320 @@ interface WasmMasteringStereoResult {
   latencySamples: number;
 }
 
+interface WasmMixMeterSnapshot {
+  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 WasmMixResult {
+  left: Float32Array;
+  right: Float32Array;
+  sampleRate: number;
+  meters: WasmMixMeterSnapshot[];
+}
+
+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[];
+}
+
+interface WasmRealtimeEngine {
+  prepare: (
+    sampleRate: number,
+    maxBlockSize: number,
+    commandCapacity: number,
+    telemetryCapacity: number,
+  ) => void;
+  setParameter: (paramId: number, value: number, renderFrame: number) => void;
+  setParameterSmoothed: (paramId: number, value: number, renderFrame: number) => void;
+  getTransportState: () => WasmEngineTransportState;
+  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: WasmEngineParameterInfo) => void;
+  parameterCount: () => number;
+  parameterInfoByIndex: (index: number) => WasmEngineParameterInfo;
+  parameterInfo: (id: number) => WasmEngineParameterInfo;
+  setAutomationLane: (paramId: number, points: WasmEngineAutomationPoint[]) => void;
+  automationLaneCount: () => number;
+  setMarkers: (markers: WasmEngineMarker[]) => void;
+  markerCount: () => number;
+  markerByIndex: (index: number) => WasmEngineMarker;
+  marker: (id: number) => WasmEngineMarker;
+  seekMarker: (id: number, renderFrame: number) => void;
+  setLoopFromMarkers: (startMarkerId: number, endMarkerId: number) => void;
+  setMetronome: (config: WasmEngineMetronomeConfig) => void;
+  metronome: () => Required<WasmEngineMetronomeConfig>;
+  countInEndSample: (startSample: number, bars: number) => number;
+  setGraph: (spec: WasmEngineGraphSpec) => void;
+  graphNodeCount: () => number;
+  graphConnectionCount: () => number;
+  setClips: (clips: WasmEngineClip[]) => void;
+  clipCount: () => number;
+  setCaptureBuffer: (numChannels: number, capacityFrames: number) => void;
+  armCapture: (armed: boolean) => void;
+  setCapturePunch: (startSample: number, endSample: number, enabled: boolean) => void;
+  resetCapture: () => void;
+  captureStatus: () => WasmEngineCaptureStatus;
+  capturedAudio: () => Float32Array[];
+  process: (channels: Float32Array[]) => Float32Array[];
+  processWithMonitor: (channels: Float32Array[]) => WasmEngineProcessWithMonitorResult;
+  renderOffline: (channels: Float32Array[], blockSize: number) => Float32Array[];
+  bounceOffline: (options: WasmEngineBounceOptions) => WasmEngineBounceResult;
+  freezeOffline: (options: WasmEngineFreezeOptions) => WasmEngineFreezeResult;
+  drainTelemetry: (maxRecords: number) => WasmEngineTelemetry[];
+  drainMeterTelemetry: (maxRecords: number) => WasmEngineMeterTelemetry[];
+  delete: () => void;
+}
+
 type ProgressCallback = (progress: number, stage: string) => void;
+type TempogramMode = 'autocorrelation' | 'auto' | 'ac' | 'cosine' | 0 | 1;
 
 interface SonareModule {
   // Quick API (high-level)
   detectBpm: (samples: Float32Array, sampleRate: number) => number;
   detectKey: (samples: Float32Array, sampleRate: number) => WasmKeyResult;
+  _detectKeyWithOptions: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    useHpss: boolean,
+    loudnessWeighted: boolean,
+    highPassHz: number,
+    modes: number[],
+    profileType: number,
+    genreHint: string,
+  ) => WasmKeyResult;
+  _detectKeyCandidates: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    useHpss: boolean,
+    loudnessWeighted: boolean,
+    highPassHz: number,
+    modes: number[],
+    profileType: number,
+    genreHint: string,
+  ) => WasmKeyCandidateResult[];
   detectOnsets: (samples: Float32Array, sampleRate: number) => Float32Array;
   detectBeats: (samples: Float32Array, sampleRate: number) => Float32Array;
+  detectDownbeats: (samples: Float32Array, sampleRate: number) => Float32Array;
+  detectChords: (
+    samples: Float32Array,
+    sampleRate: number,
+    minDuration: number,
+    smoothingWindow: number,
+    threshold: number,
+    useTriadsOnly: boolean,
+    nFft: number,
+    hopLength: number,
+    useBeatSync: boolean,
+    useHmm: boolean,
+    hmmBeamWidth: number,
+    useKeyContext: boolean,
+    keyRoot: number,
+    keyMode: number,
+    detectInversions: boolean,
+    chromaMethod: number,
+  ) => WasmChordAnalysisResult;
   analyze: (samples: Float32Array, sampleRate: number) => WasmAnalysisResult;
+  analyzeImpulseResponse: (
+    samples: Float32Array,
+    sampleRate: number,
+    nOctaveBands: number,
+  ) => WasmAcousticResult;
+  detectAcoustic: (
+    samples: Float32Array,
+    sampleRate: number,
+    nOctaveBands: number,
+    nThirdOctaveSubbands: number,
+    minDecayDb: number,
+    noiseFloorMarginDb: number,
+  ) => WasmAcousticResult;
   analyzeWithProgress: (
     samples: Float32Array,
     sampleRate: number,
     progressCallback: ProgressCallback | null,
   ) => WasmAnalysisResult;
   version: () => string;
+  engineAbiVersion: () => number;
 
   // Effects
   hpss: (
@@ -214,6 +597,25 @@ interface SonareModule {
   percussive: (samples: Float32Array, sampleRate: number) => Float32Array;
   timeStretch: (samples: Float32Array, sampleRate: number, rate: number) => Float32Array;
   pitchShift: (samples: Float32Array, sampleRate: number, semitones: number) => Float32Array;
+  pitchCorrectToMidi: (
+    samples: Float32Array,
+    sampleRate: number,
+    currentMidi: number,
+    targetMidi: number,
+  ) => Float32Array;
+  noteStretch: (
+    samples: Float32Array,
+    sampleRate: number,
+    onsetSample: number,
+    offsetSample: number,
+    stretchRatio: number,
+  ) => Float32Array;
+  voiceChange: (
+    samples: Float32Array,
+    sampleRate: number,
+    pitchSemitones: number,
+    formantFactor: number,
+  ) => Float32Array;
   normalize: (samples: Float32Array, sampleRate: number, targetDb: number) => Float32Array;
   mastering: (
     samples: Float32Array,
@@ -260,6 +662,21 @@ interface SonareModule {
     sampleRate: number,
     params: Record<string, number | boolean>,
   ) => string;
+  masteringAssistantSuggest: (
+    samples: Float32Array,
+    sampleRate: number,
+    params: Record<string, number | boolean>,
+  ) => string;
+  masteringAudioProfile: (
+    samples: Float32Array,
+    sampleRate: number,
+    params: Record<string, number | boolean>,
+  ) => string;
+  masteringStreamingPreview: (
+    samples: Float32Array,
+    sampleRate: number,
+    platforms: Array<{ name: string; targetLufs: number; ceilingDb: number }>,
+  ) => string;
   masteringChain: (
     samples: Float32Array,
     sampleRate: number,
@@ -298,6 +715,14 @@ interface SonareModule {
     sampleRate: number,
     overrides: Record<string, number | boolean> | null,
   ) => WasmMasteringStereoChainResult;
+  mixingScenePresetNames: () => string[];
+  mixingScenePresetJson: (presetName: string) => string;
+  mixStereo: (
+    leftChannels: Float32Array[],
+    rightChannels: Float32Array[],
+    sampleRate: number,
+    options: Record<string, unknown>,
+  ) => WasmMixResult;
   trim: (samples: Float32Array, sampleRate: number, thresholdDb: number) => Float32Array;
 
   // Features - Spectrogram
@@ -331,6 +756,47 @@ interface SonareModule {
     nMfcc: number,
   ) => WasmMfccResult;
 
+  // Features - Inverse reconstruction
+  melToStft: (
+    melPower: Float32Array,
+    nMels: number,
+    nFrames: number,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    fmin: number,
+    fmax: number,
+  ) => WasmStftPowerResult;
+  melToAudio: (
+    melPower: Float32Array,
+    nMels: number,
+    nFrames: number,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    nIter: number,
+    fmin: number,
+    fmax: number,
+  ) => Float32Array;
+  mfccToMel: (
+    mfcc: Float32Array,
+    nMfcc: number,
+    nFrames: number,
+    nMels: number,
+  ) => WasmMelPowerResult;
+  mfccToAudio: (
+    mfcc: Float32Array,
+    nMfcc: number,
+    nFrames: number,
+    nMels: number,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    nIter: number,
+    fmin: number,
+    fmax: number,
+  ) => Float32Array;
+
   // Features - Chroma
   chroma: (
     samples: Float32Array,
@@ -453,7 +919,16 @@ interface SonareModule {
     sampleRate: number,
     hopLength: number,
     winLength: number,
+    mode: TempogramMode,
   ) => WasmTempogramResult;
+  cyclicTempogram: (
+    onsetEnvelope: Float32Array,
+    sampleRate: number,
+    hopLength: number,
+    winLength: number,
+    bpmMin: number,
+    nBins: number,
+  ) => WasmCyclicTempogramResult;
   plp: (
     onsetEnvelope: Float32Array,
     sampleRate: number,
@@ -462,6 +937,62 @@ interface SonareModule {
     tempoMax: number,
     winLength: number,
   ) => Float32Array;
+  nnlsChroma: (samples: Float32Array, sampleRate: number) => WasmNnlsChromaResult;
+  cqt: (
+    samples: Float32Array,
+    sampleRate: number,
+    hopLength: number,
+    fmin: number,
+    nBins: number,
+    binsPerOctave: number,
+  ) => WasmCqtResult;
+  vqt: (
+    samples: Float32Array,
+    sampleRate: number,
+    hopLength: number,
+    fmin: number,
+    nBins: number,
+    binsPerOctave: number,
+    gamma: number,
+  ) => WasmCqtResult;
+  analyzeSections: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    minSectionSec: number,
+  ) => WasmSectionResult[];
+  analyzeMelody: (
+    samples: Float32Array,
+    sampleRate: number,
+    fmin: number,
+    fmax: number,
+    frameLength: number,
+    hopLength: number,
+    threshold: number,
+  ) => WasmMelodyResult;
+  onsetEnvelope: (
+    samples: Float32Array,
+    sampleRate: number,
+    nFft: number,
+    hopLength: number,
+    nMels: number,
+  ) => Float32Array;
+  fourierTempogram: (
+    onsetEnvelope: Float32Array,
+    sampleRate: number,
+    hopLength: number,
+    winLength: number,
+  ) => WasmFourierTempogramResult;
+  tempogramRatio: (
+    tempogramData: Float32Array,
+    winLength: number,
+    sampleRate: number,
+    hopLength: number,
+  ) => Float32Array;
+  lufs: (samples: Float32Array, sampleRate: number) => WasmLufsResult;
+  momentaryLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
+  shortTermLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
 
   // Core - Resample
   resample: (samples: Float32Array, srcSr: number, targetSr: number) => Float32Array;
@@ -495,6 +1026,14 @@ interface SonareModule {
     Minor7: { value: 6 };
     Sus2: { value: 7 };
     Sus4: { value: 8 };
+    Unknown: { value: 9 };
+    Add9: { value: 10 };
+    MinorAdd9: { value: 11 };
+    Dim7: { value: 12 };
+    HalfDim7: { value: 13 };
+    Major9: { value: 14 };
+    Dominant9: { value: 15 };
+    Sus2Add4: { value: 16 };
   };
   SectionType: {
     Intro: { value: 0 };
@@ -504,6 +1043,7 @@ interface SonareModule {
     Bridge: { value: 4 };
     Instrumental: { value: 5 };
     Outro: { value: 6 };
+    Unknown: { value: 7 };
   };
 
   // Streaming - StreamAnalyzer
@@ -512,14 +1052,41 @@ interface SonareModule {
     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,
   ) => WasmStreamAnalyzer;
 
+  RealtimeEngine: new (
+    sampleRate: number,
+    maxBlockSize: number,
+    commandCapacity: number,
+    telemetryCapacity: number,
+  ) => WasmRealtimeEngine;
+
   // Streaming - StreamingMasteringChain
   createStreamingMasteringChain: (config: Record<string, unknown>) => WasmStreamingMasteringChain;
+
+  // Streaming - StreamingEqualizer
+  createEqualizer: (config: Record<string, unknown>) => WasmStreamingEqualizer;
+
+  // Streaming - StreamingRetune
+  createStreamingRetune: (config: Record<string, unknown>) => WasmStreamingRetune;
+
+  // Mixing - scene-based Mixer
+  createMixerFromSceneJson: (json: string, sampleRate: number, blockSize: number) => WasmMixer;
+  mixerPresetJson: (presetName: string) => string;
 }
 
 interface WasmStreamingMasteringChain {
@@ -535,6 +1102,135 @@ interface WasmStreamingMasteringChain {
   delete: () => void;
 }
 
+interface WasmEqSpectrumSnapshot {
+  preLeft: Float32Array;
+  preRight: Float32Array;
+  postLeft: Float32Array;
+  postRight: Float32Array;
+  bandGainDb: Float32Array;
+  profileDb: Float32Array;
+  lastAutoGainDb: number;
+  seq: number;
+}
+
+interface WasmStreamingEqualizer {
+  setBand: (index: number, band: Record<string, unknown>) => void;
+  clear: () => void;
+  setPhaseMode: (mode: number) => void;
+  setAutoGain: (enabled: boolean) => void;
+  setGainScale: (scale: number) => void;
+  setOutputGainDb: (gainDb: number) => void;
+  setOutputPan: (pan: number) => void;
+  setSidechainMono: (samples: Float32Array) => void;
+  setSidechainStereo: (left: Float32Array, right: Float32Array) => void;
+  clearSidechain: () => void;
+  lastAutoGainDb: () => number;
+  latencySamples: () => number;
+  processMono: (samples: Float32Array) => Float32Array;
+  processStereo: (
+    left: Float32Array,
+    right: Float32Array,
+  ) => { left: Float32Array; right: Float32Array };
+  spectrum: () => WasmEqSpectrumSnapshot;
+  match: (source: Float32Array, reference: Float32Array, options: Record<string, unknown>) => void;
+  delete: () => void;
+}
+
+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;
+}
+
+interface WasmMixer {
+  compile: () => void;
+  processStereo: (
+    leftChannels: Float32Array[],
+    rightChannels: Float32Array[],
+  ) => { left: Float32Array; right: Float32Array; sampleRate: number };
+  processStereoInto: (
+    leftChannels: Float32Array[],
+    rightChannels: Float32Array[],
+    outLeft: Float32Array,
+    outRight: Float32Array,
+  ) => void;
+  inputLeftView: (index: number) => Float32Array;
+  inputRightView: (index: number) => Float32Array;
+  outputLeftView: () => Float32Array;
+  outputRightView: () => Float32Array;
+  processPreparedStereo: (numSamples: number) => void;
+  stripCount: () => number;
+  scheduleInsertAutomation: (
+    stripIndex: number,
+    insertIndex: number,
+    paramId: number,
+    samplePos: number,
+    value: number,
+    curve: number,
+  ) => void;
+  stripById: (id: string) => number;
+  setSoloed: (stripIndex: number, soloed: boolean) => void;
+  setSoloSafe: (stripIndex: number, soloSafe: boolean) => void;
+  setPolarityInvert: (stripIndex: number, invertLeft: boolean, invertRight: boolean) => void;
+  setPanLaw: (stripIndex: number, panLaw: number) => void;
+  setChannelDelaySamples: (stripIndex: number, delaySamples: number) => void;
+  setVcaOffsetDb: (stripIndex: number, offsetDb: number) => void;
+  setDualPan: (stripIndex: number, leftPan: number, rightPan: number) => void;
+  addSend: (
+    stripIndex: number,
+    id: string,
+    destinationBusId: string,
+    sendDb: number,
+    timing: number,
+  ) => number;
+  setSendDb: (stripIndex: number, sendIndex: number, sendDb: number) => void;
+  meterTap: (stripIndex: number, tap: number) => WasmMixMeterSnapshot;
+  stripMeter: (stripIndex: number, tap: number) => WasmMixMeterSnapshot;
+  scheduleFaderAutomation: (
+    stripIndex: number,
+    samplePos: number,
+    faderDb: number,
+    curve: number,
+  ) => void;
+  schedulePanAutomation: (
+    stripIndex: number,
+    samplePos: number,
+    pan: number,
+    curve: number,
+  ) => void;
+  scheduleWidthAutomation: (
+    stripIndex: number,
+    samplePos: number,
+    width: number,
+    curve: number,
+  ) => void;
+  scheduleSendAutomation: (
+    stripIndex: number,
+    sendIndex: number,
+    samplePos: number,
+    db: number,
+    curve: number,
+  ) => void;
+  readGoniometerLatest: (stripIndex: number, maxPoints: number) => WasmGoniometerPoint[];
+  addBus: (id: string, role: string) => void;
+  removeBus: (id: string) => void;
+  busCount: () => number;
+  addVcaGroup: (id: string, gainDb: number, members: string[]) => void;
+  removeVcaGroup: (id: string) => void;
+  vcaGroupCount: () => number;
+  toSceneJson: () => string;
+  delete: () => void;
+}
+
+interface WasmGoniometerPoint {
+  left: number;
+  right: number;
+}
+
 // Streaming types for StreamAnalyzer
 interface WasmChordChange {
   root: number;
@@ -566,6 +1262,7 @@ interface WasmProgressiveEstimate {
   chordRoot: number;
   chordQuality: number;
   chordConfidence: number;
+  chordStartTime: number;
   chordProgression: WasmChordChange[];
   barChordProgression: WasmBarChord[];
   currentBar: number;
@@ -601,13 +1298,37 @@ interface WasmFrameBuffer {
   chordConfidence: Float32Array;
 }
 
+interface WasmStreamFramesU8 {
+  nFrames: number;
+  nMels: number;
+  timestamps: Float32Array;
+  mel: Uint8Array;
+  chroma: Uint8Array;
+  onsetStrength: Uint8Array;
+  rmsEnergy: Uint8Array;
+  spectralCentroid: Uint8Array;
+  spectralFlatness: Uint8Array;
+}
+
+interface WasmStreamFramesI16 {
+  nFrames: number;
+  nMels: number;
+  timestamps: Float32Array;
+  mel: Int16Array;
+  chroma: Int16Array;
+  onsetStrength: Int16Array;
+  rmsEnergy: Int16Array;
+  spectralCentroid: Int16Array;
+  spectralFlatness: Int16Array;
+}
+
 interface WasmStreamAnalyzer {
   process: (samples: Float32Array) => void;
   processWithOffset: (samples: Float32Array, sampleOffset: number) => void;
   availableFrames: () => number;
   readFramesSoa: (maxFrames: number) => WasmFrameBuffer;
-  readFramesU8: (maxFrames: number) => unknown;
-  readFramesI16: (maxFrames: number) => unknown;
+  readFramesU8: (maxFrames: number) => WasmStreamFramesU8;
+  readFramesI16: (maxFrames: number) => WasmStreamFramesI16;
   reset: (baseSampleOffset?: number) => void;
   stats: () => WasmAnalyzerStats;
   frameCount: () => number;