@libraz/libsonare 1.7.2 → 1.8.1

package/src/sonare.js.d.ts

@@ -1,8 +1,25 @@
 /**
- * Type declarations for the Emscripten-generated WASM module with embind
+ * Hand-written type declarations describing the Emscripten/embind WASM module.
+ *
+ * This file is NOT generated — nothing in the build writes it. A new embind
+ * registration reaches TypeScript only when someone declares it here, in the
+ * same change as the binding, so a missing declaration is a lockstep omission
+ * rather than a stale artifact waiting on a rebuild.
  */
 
+import type { SplitSilenceCommonWithReportResult } from './feature_core';
+import type { StripMeteringOptions } from './mixer';
 import type {
+  NoteEditInput,
+  NoteObject,
+  NoteObjectInput,
+  NoteSetEntry,
+  NoteTarget,
+  NoteTargetAssignResult,
+  NoteTargetUnmatchedPolicy,
+  PercussiveEvent,
+  PercussiveEventInput,
+  PitchDecompositionResult,
   ProgressCallback,
   SonareCapabilities,
   SpectralRegionOp,
@@ -74,9 +91,30 @@ export interface WasmRealtimeVoiceChangerPodConfig {
 
 export interface WasmBeatResult {
   time: number;
+  /**
+   * Onset-envelope value sampled at the beat's frame — a single raw frame, not
+   * a normalized or relative salience. Use
+   * `WasmBeatObservationsResult.onsetStrength` for accent scoring.
+   */
   strength: number;
 }
 
+/** Beat-level evidence behind the downbeat and meter decisions. */
+export interface WasmBeatObservationsResult {
+  onsetStrength: number[];
+  lowFrequencyEnergy: number[];
+  chordChange: number[];
+}
+
+export interface WasmMeterEstimateResult {
+  timeSignature: WasmTimeSignatureResult;
+  downbeatPhase: number;
+  searched: boolean;
+  grouping: number[];
+  candidateScores: number[];
+  candidates: WasmTimeSignatureResult[];
+}
+
 export interface WasmChordResult {
   root: number;
   bass: number;
@@ -87,6 +125,10 @@ export interface WasmChordResult {
   name: string;
 }
 
+export interface WasmAnalysisChordResult extends WasmChordResult {
+  romanNumeral: string;
+}
+
 export interface WasmSectionResult {
   type: number;
   start: number;
@@ -143,7 +185,11 @@ export interface WasmAnalysisResult {
   timeSignature: WasmTimeSignatureResult;
   timeSignatureCandidates: WasmTimeSignatureResult[];
   beats: WasmBeatResult[];
-  chords: WasmChordResult[];
+  downbeatIndices: number[];
+  downbeatPhase: number;
+  beatObservations: WasmBeatObservationsResult;
+  beatLocalBpm: number[];
+  chords: WasmAnalysisChordResult[];
   sections: WasmSectionResult[];
   timbre: WasmTimbreResult;
   dynamics: WasmDynamicsResult;
@@ -270,6 +316,9 @@ export interface WasmRoomGeometryOptions {
   ismOrder?: number;
   seed?: number;
   maxSeconds?: number;
+  airAbsorptionEnabled?: boolean;
+  airTemperatureC?: number;
+  airHumidityPercent?: number;
 }
 
 export interface WasmRirSynthOptions extends WasmRoomGeometryOptions {
@@ -279,10 +328,24 @@ export interface WasmRirSynthOptions extends WasmRoomGeometryOptions {
   crossfadeMs?: number;
 }
 
+export interface WasmRirDiagnostic {
+  code: string;
+  message: string;
+  severity: 'info' | 'warning' | 'error';
+}
+
+export interface WasmRoomMorphResult {
+  audio: Float32Array;
+  sampleRate: number;
+  diagnostics: WasmRirDiagnostic[];
+}
+
 export interface WasmRirResult {
   rir: Float32Array;
   sampleRate: number;
   hasError: boolean;
+  errorMessage: string;
+  diagnostics: WasmRirDiagnostic[];
 }
 
 export interface WasmRoomEstimateOptions {
@@ -307,6 +370,199 @@ export interface WasmRoomEstimateResult {
   rt60Bands: Float32Array;
 }
 
+/** Every field of a dereverb config, as `masteringRepairDereverbConfigForRoom` returns it. */
+export interface WasmDereverbClassicalConfig {
+  threshold: number;
+  attenuation: number;
+  nFft: number;
+  hopLength: number;
+  t60Sec: number;
+  lateDelayMs: number;
+  overSubtraction: number;
+  spectralFloor: number;
+  wpeEnabled: boolean;
+  wpeIterations: number;
+  wpeTaps: number;
+  wpeStrength: number;
+}
+
+/** What a declick analysis found in one channel, as `masteringRepairDeclickStereo` returns it. Runs, not samples. */
+export interface WasmClickDetection {
+  count: number;
+  rejected: number;
+  longestRunSamples: number;
+  perSecond: number;
+}
+
+/** What a declick pass found in one channel of a stereo declick and what it did to it. */
+export interface WasmDeclickReport {
+  detected: WasmClickDetection;
+  repairedRuns: number;
+  repairedSamples: number;
+  linkedRuns: number;
+  lpcModelUsed: boolean;
+}
+
+export interface WasmDeclickStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  leftReport: WasmDeclickReport;
+  rightReport: WasmDeclickReport;
+}
+
+/** What a declip analysis found in one channel, as `masteringRepairDeclipStereo` returns it. */
+export interface WasmClipDetection {
+  sampleCount: number;
+  sampleFraction: number;
+  runCount: number;
+  longestRunSamples: number;
+  flatRunCount: number;
+  longestFlatRunSamples: number;
+  flatSampleCount: number;
+  flatLevel: number;
+}
+
+/** What a declip pass found in one channel of a stereo declip and what it did to it. */
+export interface WasmDeclipReport {
+  detected: WasmClipDetection;
+  lpcReconstructedRuns: number;
+  interpolatedRuns: number;
+  repairedSamples: number;
+  linkedRuns: number;
+}
+
+export interface WasmDeclipStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  leftReport: WasmDeclipReport;
+  rightReport: WasmDeclipReport;
+}
+
+/** What a decrackle analysis found in one channel, as `masteringRepairDecrackleStereo` returns it. */
+export interface WasmCrackleDetection {
+  sampleCount: number;
+  sampleFraction: number;
+  perSecond: number;
+}
+
+/** What a decrackle pass found in one channel of a stereo decrackle and what it did to it. */
+export interface WasmDecrackleReport {
+  detected: WasmCrackleDetection;
+  replacedSamples: number;
+  detailCoefficients: number;
+  shrunkCoefficients: number;
+  noiseSigma: number;
+}
+
+export interface WasmDecrackleStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  leftReport: WasmDecrackleReport;
+  rightReport: WasmDecrackleReport;
+}
+
+/** What a dehum analysis found in one channel, as `masteringRepairDehumStereo` returns it. */
+export interface WasmHumDetection {
+  fundamentalHz: number;
+  fundamentalProminence: number;
+  harmonics: number;
+  harmonicDbfs: Float32Array;
+}
+
+/** What a dehum pass found in one channel of a stereo dehum and what it did to it. */
+export interface WasmDehumReport {
+  detected: WasmHumDetection;
+  notchedHarmonics: number;
+  appliedFundamentalHz: number;
+  fundamentalDriftHz: number;
+}
+
+export interface WasmDehumStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  leftReport: WasmDehumReport;
+  rightReport: WasmDehumReport;
+}
+
+/** What a denoise analysis found, as `masteringRepairDenoiseClassicalStereo` returns it. */
+export interface WasmNoiseDetection {
+  floorDbfs: number;
+  bandFloorDbfs: Float32Array;
+}
+
+/** What a stereo denoise pass found and what it removed. */
+export interface WasmDenoiseReport {
+  detected: WasmNoiseDetection;
+  meanReductionDb: number;
+  maxReductionDb: number;
+  floorLimitedFraction: number;
+}
+
+/** One `report`, not a per-channel pair: the gain mask is one array applied to both channels. */
+export interface WasmDenoiseStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  report: WasmDenoiseReport;
+}
+
+/** The N-channel form: one mask over the set, and one report whose `detected` is the set's. */
+export interface WasmDenoiseLinkedResult {
+  channels: Float32Array[];
+  report: WasmDenoiseReport;
+}
+
+/** What a dereverb analysis found, as `masteringRepairDereverbClassicalStereo` returns it. */
+export interface WasmReverbDetection {
+  lateDecayRatioDb: number;
+  latePredictability: number;
+}
+
+/** What a stereo dereverb pass found and what it removed. */
+export interface WasmDereverbReport {
+  detected: WasmReverbDetection;
+  meanReductionDb: number;
+  suppressedFraction: number;
+  wpePredictorNorm: number;
+}
+
+/** One `report`, not a per-channel pair: the mask and the WPE predictor set are each one
+ * object applied to both channels. */
+export interface WasmDereverbStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  report: WasmDereverbReport;
+}
+
+/** The N-channel form: one mask and one WPE predictor set over the whole channel set. */
+export interface WasmDereverbLinkedResult {
+  channels: Float32Array[];
+  report: WasmDereverbReport;
+}
+
+/** One half-open input-buffer range, as a trim pass reports it. */
+export interface WasmTrimRange {
+  first: number;
+  lastExclusive: number;
+}
+
+/** What a trim pass kept and what it dropped. */
+export interface WasmTrimReport {
+  range: WasmTrimRange;
+  removedHeadSamples: number;
+  removedTailSamples: number;
+}
+
+/** Arrays SHORTER than the input, and empty when neither channel carries signal. `report.range`
+ * is the union applied to both channels; the two per-channel ranges are what it was formed
+ * from. */
+export interface WasmTrimSilenceStereoResult {
+  left: Float32Array;
+  right: Float32Array;
+  report: WasmTrimReport;
+  leftRange: WasmTrimRange;
+  rightRange: WasmTrimRange;
+}
+
 export interface WasmRoomMorphOptions extends WasmRoomGeometryOptions {
   wet?: number;
   sourceTailSuppression?: number;
@@ -464,6 +720,48 @@ export interface WasmMelodyPoint {
   confidence: number;
 }
 
+/**
+ * Boundary options as the embind wrapper reads them. Every field is optional
+ * because the wrapper seeds the bag from `BoundaryConfig`, so an omitted one
+ * takes the core's own default.
+ *
+ * Declaring them required is what obliged the facade to spell all ten defaults
+ * before the call, which made those literals the effective defaults on npm and
+ * put the core's out of reach. That shape did buy one thing — a field name
+ * drifting from the embind reader failed to compile instead of falling back in
+ * silence — and the typed-options test carries it instead: it sends a
+ * wrong-typed value for each of the ten keys and requires the module to refuse,
+ * which stops happening the moment the reader stops reading one of them.
+ */
+export interface WasmBoundaryOptions {
+  nFft?: number;
+  hopLength?: number;
+  kernelSize?: number;
+  threshold?: number;
+  absoluteThreshold?: number;
+  nMfcc?: number;
+  nChroma?: number;
+  peakDistance?: number;
+  useMfcc?: boolean;
+  useChroma?: boolean;
+}
+
+export interface WasmBoundary {
+  time: number;
+  frame: number;
+  strength: number;
+}
+
+export interface WasmBoundaryResult {
+  boundaries: WasmBoundary[];
+  noveltyCurve: Float32Array;
+  noveltyPeak: number;
+  sampleRate: number;
+  hopLength: number;
+  nFrames: number;
+  frameStride: number;
+}
+
 export interface WasmMelodyResult {
   points: WasmMelodyPoint[];
   pitchRangeOctaves: number;
@@ -490,6 +788,17 @@ export interface WasmLufsResult {
   loudnessRange: number;
 }
 
+/**
+ * The two per-block loudness series a multi-channel measurement builds, in
+ * LUFS. A signal shorter than a window yields an empty series for it.
+ */
+export interface WasmLufsSeriesResult {
+  /** 400 ms momentary series. */
+  momentary: Float32Array;
+  /** 3 s short-term series. */
+  shortTerm: Float32Array;
+}
+
 export interface WasmMasteringResult {
   samples: Float32Array;
   sampleRate: number;
@@ -498,6 +807,31 @@ export interface WasmMasteringResult {
   appliedGainDb: number;
   loudnessTargetLimited?: boolean;
   latencySamples?: number;
+  /**
+   * Samples the named processor replaced with a finite in-domain one,
+   * keeping the output finite and in range. A non-finite sample supplied by
+   * the caller is rejected before the processor runs, so a replacement is
+   * always of a value the processor itself produced.
+   *
+   * Whether this can be non-zero depends on which processor was named: one
+   * that does not substitute reports zero because it has nothing to replace
+   * with, not because nothing needed replacing.
+   */
+  nonFiniteSubstitutionCount: number;
+}
+
+export interface WasmLoudnessMatchResult {
+  samples: Float32Array;
+  sampleRate: number;
+  referenceLufs: number;
+  sourceLufs: number;
+  appliedGainDb: number;
+  matchedTruePeakDbtp: number;
+}
+
+export interface WasmLoudnessMatchStereoResult extends Omit<WasmLoudnessMatchResult, 'samples'> {
+  left: Float32Array;
+  right: Float32Array;
 }
 
 export interface WasmStageGainReduction {
@@ -527,6 +861,19 @@ export interface WasmMasteringChainResult extends WasmMasteringResult {
   outputTruePeakDbtp: number;
   outputLra: number;
   loudnessTargetLimited: boolean;
+  /**
+   * Samples a stage replaced with a finite in-domain one, keeping the
+   * output finite and in range. A non-finite sample supplied by the caller
+   * is rejected before any stage runs, so a replacement is always of a
+   * value a stage itself produced.
+   *
+   * Only the true-peak limiters replace anything, so with the maximizer's
+   * limiter and the loudness stage both disabled a zero here means no
+   * stage was able to replace anything rather than that nothing needed
+   * replacing. Overrides the inherited {@link WasmMasteringResult} doc,
+   * which describes a single named processor rather than a chain.
+   */
+  nonFiniteSubstitutionCount: number;
   stageGainReductions: WasmStageGainReduction[];
   report: WasmMasteringReport;
 }
@@ -542,6 +889,8 @@ export interface WasmMasteringStereoChainResult {
   outputTruePeakDbtp: number;
   outputLra: number;
   loudnessTargetLimited: boolean;
+  /** See {@link WasmMasteringChainResult} for field semantics. Aggregated over both channels. */
+  nonFiniteSubstitutionCount: number;
   stageGainReductions: WasmStageGainReduction[];
   report: WasmMasteringReport;
 }
@@ -554,6 +903,9 @@ export interface WasmMasteringStereoResult {
   outputLufs: number;
   appliedGainDb: number;
   latencySamples: number;
+  loudnessTargetLimited: boolean;
+  /** Aggregated over both channels. */
+  nonFiniteSubstitutionCount: number;
 }
 
 export interface WasmMixMeterSnapshot {
@@ -570,13 +922,24 @@ export interface WasmMixMeterSnapshot {
   shortTermLufs: number;
   integratedLufs: number;
   gainReductionDb: number;
+  /**
+   * Left-channel inter-sample (true) peak in dB, from the ITU-R BS.1770-4
+   * polyphase reconstruction at 4x. A streaming measurement: the centered
+   * reconstruction stencil needs a few future samples a realtime path does not
+   * have, so each block's last samples read marginally low (about 0.1 dB across
+   * 64..8192-sample blocks on a near-Nyquist tone, always under-reading). Use
+   * `meteringTruePeakDb` over the whole signal for an exact dBTP number.
+   */
   truePeakDbL: number;
+  /** Right-channel inter-sample (true) peak in dB. See {@link truePeakDbL}. */
   truePeakDbR: number;
+  /** Maximum inter-sample peak across channels in dB. See {@link truePeakDbL}. */
   maxTruePeakDb: number;
   seq: number;
   channelCount: number;
   peakDb: number[];
   rmsDb: number[];
+  /** Per-plane inter-sample peak in dB; [0]/[1] mirror {@link truePeakDbL}/R. */
   truePeakDb: number[];
 }
 
@@ -598,7 +961,7 @@ export interface WasmEngineClip {
   gain?: number;
   fadeInSamples?: number;
   fadeOutSamples?: number;
-  warpMode?: 'off' | 'repitch' | 'tempo-sync' | 0 | 1 | 2;
+  warpMode?: 'off' | 'repitch' | 'tempo-sync' | 'time-stretch' | 0 | 1 | 2 | 3;
   warpAnchors?: Array<{ warpSample: number; sourceSample: number }>;
   pageProvider?: number | { readonly id: number };
 }
@@ -607,6 +970,8 @@ export interface WasmEngineTrackSend {
   busId: number;
   levelDb?: number;
   enabled?: boolean;
+  /** Native send tap: 0 post-fader (default), 1 pre-fader. */
+  sendTiming?: number;
 }
 
 export interface WasmEngineTrackLane {
@@ -628,6 +993,13 @@ export interface WasmEngineBus {
   busId: number;
   gainDb?: number;
   channelLayout?: number;
+  /**
+   * Bus this bus's output sums into instead of the master mix; 0 or absent
+   * keeps it on the master mix.
+   */
+  outputBusId?: number;
+  /** Sends to other buses, in the same shape as a track lane's sends. */
+  sends?: WasmEngineTrackSend[];
 }
 
 export interface WasmClipPageRequest {
@@ -639,12 +1011,18 @@ export interface WasmClipPageRequest {
 export interface WasmEngineParameterInfo {
   id: number;
   name: string;
-  unit: string;
-  minValue: number;
-  maxValue: number;
-  defaultValue: number;
-  rtSafe: boolean;
-  defaultCurve: number;
+  /** Display unit; omit for an empty string. */
+  unit?: string;
+  /** Lower end of the parameter range. Default `0`. */
+  minValue?: number;
+  /** Upper end of the parameter range. Default `1`. */
+  maxValue?: number;
+  /** Value the parameter starts at. Default `0`. */
+  defaultValue?: number;
+  /** Whether the parameter is safe to change from the realtime thread. Default `true`. */
+  rtSafe?: boolean;
+  /** Curve used by automation points that omit `curveToNext`. Default `1` (exponential). */
+  defaultCurve?: number;
 }
 
 export interface WasmEngineAutomationPoint {
@@ -727,6 +1105,13 @@ export interface WasmEngineGraphConnection {
   sourcePort: number;
   destNode: string;
   destPort: number;
+  /**
+   * Mixing intent (`0` = replace, `1` = add).
+   *
+   * NOTE: not currently honored — the compiled graph always sums edges into a
+   * shared destination port in an order-independent way (the first edge into a
+   * port overwrites, every later edge adds), regardless of this value.
+   */
   mix?: number;
 }
 
@@ -755,6 +1140,12 @@ export interface WasmEngineTelemetry {
 }
 
 export interface WasmEngineMeterTelemetry {
+  /**
+   * Telemetry tap target id: `0` master mix, `laneIndex + 1` (1..32) for track
+   * lanes, `33 + busIndex` (33..40) for buses, and `0xFFFF` for the
+   * input-monitor capture tap. Handle `0xFFFF` explicitly -- a naive
+   * `targetId - 1` index into a 32-entry lane array runs past its end.
+   */
   targetId: number;
   renderFrame: number;
   seq: number;
@@ -762,8 +1153,18 @@ export interface WasmEngineMeterTelemetry {
   peakDbR: number;
   rmsDbL: number;
   rmsDbR: number;
+  /**
+   * Left-channel inter-sample (true) peak in dB, from the ITU-R BS.1770-4
+   * polyphase reconstruction at 4x. A streaming measurement: the centered
+   * reconstruction stencil needs a few future samples a realtime path does not
+   * have, so each block's last samples read marginally low (about 0.1 dB across
+   * 64..8192-sample blocks on a near-Nyquist tone, always under-reading). Use
+   * `meteringTruePeakDb` over the whole signal for an exact dBTP number.
+   */
   truePeakDbL: number;
+  /** Right-channel inter-sample (true) peak in dB. See {@link truePeakDbL}. */
   truePeakDbR: number;
+  /** Maximum inter-sample peak across channels in dB. See {@link truePeakDbL}. */
   maxTruePeakDb: number;
   correlation: number;
   monoCompatWidth: number;
@@ -771,17 +1172,37 @@ export interface WasmEngineMeterTelemetry {
   shortTermLufs: number;
   integratedLufs: number;
   gainReductionDb: number;
+  /** Maximum pre-trim input peak for the left channel, in dBFS. */
+  inputPeakDbL: number;
+  /** Maximum pre-trim input peak for the right channel, in dBFS. */
+  inputPeakDbR: number;
   droppedRecords: number;
 }
 
 export interface WasmEngineMeterTelemetryWide {
+  /**
+   * Telemetry tap target id: `0` master mix, `laneIndex + 1` (1..32) for track
+   * lanes, `33 + busIndex` (33..40) for buses, and `0xFFFF` for the
+   * input-monitor capture tap. Handle `0xFFFF` explicitly -- a naive
+   * `targetId - 1` index into a 32-entry lane array runs past its end.
+   */
   targetId: number;
   renderFrame: number;
   seq: number;
   channelCount: number;
   peakDb: number[];
   rmsDb: number[];
+  /**
+   * Per-plane inter-sample (true) peak in dB (length `channelCount`), from the
+   * ITU-R BS.1770-4 polyphase reconstruction at 4x. A streaming measurement: the
+   * centered reconstruction stencil needs a few future samples a realtime path
+   * does not have, so each block's last samples read marginally low (about
+   * 0.1 dB across 64..8192-sample blocks on a near-Nyquist tone, always
+   * under-reading). Use `meteringTruePeakDb` over the whole signal for an exact
+   * dBTP number.
+   */
   truePeakDb: number[];
+  /** Maximum inter-sample peak across channels in dB. See {@link truePeakDb}. */
   maxTruePeakDb: number;
   correlation: number;
   monoCompatWidth: number;
@@ -789,10 +1210,18 @@ export interface WasmEngineMeterTelemetryWide {
   shortTermLufs: number;
   integratedLufs: number;
   gainReductionDb: number;
+  /** Pre-trim input peak for each valid plane, in dBFS. */
+  inputPeakDb: number[];
   droppedRecords: number;
 }
 
 export interface WasmEngineScopeTelemetry {
+  /**
+   * Telemetry tap target id: `0` master mix, `laneIndex + 1` (1..32) for track
+   * lanes, `33 + busIndex` (33..40) for buses, and `0xFFFF` for the
+   * input-monitor capture tap. Handle `0xFFFF` explicitly -- a naive
+   * `targetId - 1` index into a 32-entry lane array runs past its end.
+   */
   targetId: number;
   renderFrame: number;
   seq: number;
@@ -838,12 +1267,37 @@ export interface WasmEngineTransportState {
 }
 
 export interface WasmEngineBounceOptions {
+  /**
+   * Length of the bounce in frames. The whole result is held in memory, so the
+   * span is capped by a 1 GiB peak budget over the full-size float buffers a
+   * bounce holds at once, and exceeding it throws an `InvalidParameter`
+   * `SonareError`.
+   *
+   * The cap is a **frame** count: inversely proportional to `numChannels`, and
+   * independent of the sample rate. Stereo refuses past 44,739,242 frames, or
+   * past 33,554,432 frames when `dither` is set, which adds one more copy; 5.1
+   * refuses past a third of each. Read as a **duration** those two stereo counts
+   * are 15 min 32 s and 11 min 39 s at 48 kHz, and half that at 96 kHz. When
+   * `sourceSampleRate` and `targetSampleRate` differ both the source and the
+   * resampled length are checked, so the longer of the two is what binds.
+   *
+   * Render longer material in chunks via `renderOffline({ finalize: false })`.
+   * The cap is a fixed budget, not a probe of the module's heap, which on wasm32
+   * can run out below it.
+   */
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
   targetSampleRate?: number;
   sourceSampleRate?: number;
   normalizeLufs?: boolean;
+  /**
+   * Target integrated loudness when `normalizeLufs` is set. Omitting it, passing
+   * `0`, and passing a non-finite value all mean the library default of
+   * -14 LUFS: the non-finite case resolves rather than being reported, matching
+   * the C ABI, because the loudness stage derives a per-sample gain from this
+   * and checks nothing itself.
+   */
   targetLufs?: number;
   dither?: 0 | 1 | 2 | 3;
   ditherBits?: number;
@@ -914,18 +1368,22 @@ export interface WasmRealtimeEngine {
     commandCapacity: number,
     telemetryCapacity: number,
   ) => void;
-  setParameter: (paramId: number, value: number, renderFrame: number) => void;
-  setParameterSmoothed: (paramId: number, value: number, renderFrame: number) => void;
+  setParameter: (paramId: number, value: number, renderFrame?: number) => void;
+  setParameterSmoothed: (paramId: number, value: number, renderFrame?: number) => void;
   setParamSmoothingMs: (smoothingMs: number) => void;
-  setSoloMute: (laneIndex: number, solo: boolean, mute: boolean, renderFrame: number) => void;
-  setTrackMonitorMode: (laneIndex: number, mode: number, renderFrame: number) => void;
+  setSoloMute: (laneIndex: number, solo: boolean, mute: boolean, renderFrame?: number) => void;
+  setTrackMonitorMode: (laneIndex: number, mode: number, renderFrame?: number) => void;
   getTransportState: () => WasmEngineTransportState;
-  play: (renderFrame: number) => void;
-  stop: (renderFrame: number) => void;
-  seekSample: (timelineSample: number, renderFrame: number) => void;
+  play: (renderFrame?: number) => void;
+  stop: (renderFrame?: number) => void;
+  resetMasterLoudnessMeter: (renderFrame?: number) => void;
+  insertParameterConstructedValue: (paramId: number) => number;
+  seekSample: (timelineSample: number, renderFrame?: number) => void;
   settleParameters: () => void;
+  settleInsertParameters: () => void;
   flushControlCommands: () => void;
-  seekPpq: (ppq: number, renderFrame: number) => void;
+  applyCommandsDueNowPreservingFuture: () => void;
+  seekPpq: (ppq: number, renderFrame?: number) => void;
   setTempo: (bpm: number) => void;
   setTempoSegments: (segments: WasmEngineTempoSegment[]) => void;
   setTimeSignature: (numerator: number, denominator: number) => void;
@@ -934,15 +1392,15 @@ export interface WasmRealtimeEngine {
   setLoop: (startPpq: number, endPpq: number, enabled: boolean) => void;
   addParameter: (info: WasmEngineParameterInfo) => void;
   parameterCount: () => number;
-  parameterInfoByIndex: (index: number) => WasmEngineParameterInfo;
-  parameterInfo: (id: number) => WasmEngineParameterInfo;
+  parameterInfoByIndex: (index: number) => Required<WasmEngineParameterInfo>;
+  parameterInfo: (id: number) => Required<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;
+  seekMarker: (id: number, renderFrame?: number) => void;
   setLoopFromMarkers: (startMarkerId: number, endMarkerId: number) => void;
   setMetronome: (config: WasmEngineMetronomeConfig) => void;
   metronome: () => Required<WasmEngineMetronomeConfig>;
@@ -956,9 +1414,17 @@ export interface WasmRealtimeEngine {
   setTrackLanes: (lanes: Array<number | WasmEngineTrackLane>) => void;
   setLaneSidechain: (trackId: number, insertIndex: number, sourceTrackId: number) => void;
   setTrackBuses: (buses: WasmEngineBus[]) => void;
+  setBusSidechain: (
+    busId: number,
+    insertIndex: number,
+    sourceKind: number,
+    sourceId: number,
+  ) => void;
+  setMasterSidechain: (insertIndex: number, sourceKind: number, sourceId: number) => void;
   setBusStripJson: (busId: number, sceneJson: string) => void;
   setTrackStripJson: (trackId: number, sceneJson: string) => void;
   setTrackStripEqBandJson: (trackId: number, bandIndex: number, bandJson: string) => void;
+  setBusStripEqBandJson: (busId: number, bandIndex: number, bandJson: string) => void;
   setTrackStripInsertBypassed: (
     trackId: number,
     insertIndex: number,
@@ -978,13 +1444,50 @@ export interface WasmRealtimeEngine {
     paramName: string,
     value: number,
   ) => void;
+  applyTrackStripInsertParamByNameNow: (
+    trackId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => boolean;
+  restoreTrackStripInsertParamByName: (
+    trackId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => void;
   setMasterStripInsertParamByName: (insertIndex: number, paramName: string, value: number) => void;
+  applyMasterStripInsertParamByNameNow: (
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => boolean;
+  restoreMasterStripInsertParamByName: (
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => void;
   setBusStripInsertParamByName: (
     busId: number,
     insertIndex: number,
     paramName: string,
     value: number,
   ) => void;
+  applyBusStripInsertParamByNameNow: (
+    busId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => boolean;
+  restoreBusStripInsertParamByName: (
+    busId: number,
+    insertIndex: number,
+    paramName: string,
+    value: number,
+  ) => void;
+  clearTrackInsertParameterBases: (trackId: number) => void;
+  clearBusInsertParameterBases: (busId: number) => void;
+  clearMasterInsertParameterBases: () => void;
   setBusStripInsertBypassed: (
     busId: number,
     insertIndex: number,
@@ -998,10 +1501,15 @@ export interface WasmRealtimeEngine {
   ) => number;
   resolveMasterInsertAutomationId: (insertIndex: number, paramName: string) => number;
   resolveBusInsertAutomationId: (busId: number, insertIndex: number, paramName: string) => number;
+  resolveInstrumentAutomationId: (destinationId: number, paramName: string) => number;
   setTrackStripPan: (trackId: number, pan: number) => void;
   setTrackStripPanLaw: (trackId: number, panLaw: number) => void;
   setTrackStripPanMode: (trackId: number, panMode: number) => void;
   setTrackStripDualPan: (trackId: number, leftPan: number, rightPan: number) => void;
+  setBusStripPan: (busId: number, pan: number) => void;
+  setBusStripPanLaw: (busId: number, panLaw: number) => void;
+  setBusStripPanMode: (busId: number, panMode: number) => void;
+  setBusStripDualPan: (busId: number, leftPan: number, rightPan: number) => void;
   setTrackStripChannelDelaySamples: (trackId: number, delaySamples: number) => void;
   createClipPageProvider: (numChannels: number, numSamples: number, pageFrames: number) => number;
   supplyClipPage: (providerId: number, pageIndex: number, channels: Float32Array[]) => void;
@@ -1012,6 +1520,11 @@ export interface WasmRealtimeEngine {
   clipPageRequestScratchClipId: () => number;
   clipPageRequestScratchSample: () => number;
   clipPageRequestOverflowCount: () => number;
+  warpStretchOverflowCount: () => number;
+  setWarpVoiceCapacity: (voices: number) => void;
+  warpVoiceCapacity: () => number;
+  setClipPagePrefetchFrames: (frames: number) => void;
+  clipPagePrefetchFrames: () => number;
   setCaptureBuffer: (numChannels: number, capacityFrames: number) => void;
   armCapture: (armed: boolean) => void;
   setCapturePunch: (startSample: number, endSample: number, enabled: boolean) => void;
@@ -1038,6 +1551,34 @@ export interface WasmRealtimeEngine {
   bindMidiCcBinding: (binding: import('./project_types').ProjectMidiCcBinding) => void;
   clearMidiCcBindings: () => void;
   midiCcBindingCount: () => number;
+  setControllerProfile: (destinationId: number, presetName: string) => void;
+  bindController: (
+    destinationId: number,
+    binding: import('./instrument_types').ControllerBinding,
+  ) => void;
+  clearControllerBindings: (destinationId: number) => void;
+  controllerBindingCount: (destinationId: number) => number;
+  setControllerVelocityMeaningful: (destinationId: number, meaningful: boolean) => void;
+  controllerVelocityMeaningful: (destinationId: number) => boolean;
+  setControllerNoteTracking: (
+    destinationId: number,
+    dimension: import('./instrument_types').MpeDimension | number,
+    tracking: import('./instrument_types').NoteTracking | number,
+  ) => void;
+  controllerNoteTracking: (
+    destinationId: number,
+    dimension: import('./instrument_types').MpeDimension | number,
+  ) => import('./instrument_types').NoteTracking | number;
+  setArticulation: (
+    destinationId: number,
+    channel: number,
+    articulation: import('./instrument_types').Articulation | number,
+  ) => void;
+  articulation: (
+    destinationId: number,
+    channel: number,
+  ) => import('./instrument_types').Articulation | number;
+  legatoFallbackCount: (destinationId: number) => number;
   setMidiFx: (destinationId: number, configJson: string) => void;
   clearMidiFx: (destinationId: number) => void;
   setMidiInputSource: (destinationId: number) => void;
@@ -1064,13 +1605,32 @@ export interface WasmRealtimeEngine {
     value: number,
     portTimeSamples: number,
   ) => void;
+  pushMidiInputPitchBend: (
+    group: number,
+    channel: number,
+    bend14: number,
+    portTimeSamples: number,
+  ) => void;
+  pushMidiInputChannelPressure: (
+    group: number,
+    channel: number,
+    pressure: number,
+    portTimeSamples: number,
+  ) => void;
+  pushMidiInputPolyPressure: (
+    group: number,
+    channel: number,
+    note: number,
+    pressure: number,
+    portTimeSamples: number,
+  ) => void;
   pushMidiNoteOn: (
     destinationId: number,
     group: number,
     channel: number,
     note: number,
     velocity: number,
-    renderFrame: number,
+    renderFrame?: number,
   ) => void;
   pushMidiNoteOff: (
     destinationId: number,
@@ -1078,7 +1638,7 @@ export interface WasmRealtimeEngine {
     channel: number,
     note: number,
     velocity: number,
-    renderFrame: number,
+    renderFrame?: number,
   ) => void;
   pushMidiCc: (
     destinationId: number,
@@ -1086,11 +1646,38 @@ export interface WasmRealtimeEngine {
     channel: number,
     controller: number,
     value: number,
-    renderFrame: number,
+    renderFrame?: number,
   ) => void;
-  pushMidiUmp: (destinationId: number, word0: number, renderFrame: number) => void;
-  pushMidiSysex: (destinationId: number, data: Uint8Array, renderFrame: number) => void;
-  pushMidiPanic: (renderFrame: number) => void;
+  pushMidiPitchBend: (
+    destinationId: number,
+    group: number,
+    channel: number,
+    bend14: number,
+    renderFrame?: number,
+  ) => void;
+  pushMidiChannelPressure: (
+    destinationId: number,
+    group: number,
+    channel: number,
+    pressure: number,
+    renderFrame?: number,
+  ) => void;
+  pushMidiPolyPressure: (
+    destinationId: number,
+    group: number,
+    channel: number,
+    note: number,
+    pressure: number,
+    renderFrame?: number,
+  ) => void;
+  pushMidiUmp: (
+    destinationId: number,
+    words: Uint32Array | readonly number[],
+    renderFrame?: number,
+  ) => void;
+  pushMidiInputUmp: (words: Uint32Array | readonly number[], portTimeSamples: number) => void;
+  pushMidiSysex: (destinationId: number, data: Uint8Array, renderFrame?: number) => void;
+  pushMidiPanic: (renderFrame?: number) => void;
   setMidiDestinationExternal: (destinationId: number, external: boolean) => void;
   setExternalMidiClockEnabled: (enabled: boolean) => void;
   externalMidiDroppedCount: () => number;
@@ -1118,7 +1705,8 @@ export interface WasmRealtimeEngine {
   getMonitorChannelBuffer: (channel: number, numFrames: number) => Float32Array;
   processPreparedWithMonitor: (numFrames: number) => void;
   processWithMonitor: (channels: Float32Array[]) => WasmEngineProcessWithMonitorResult;
-  renderOffline: (channels: Float32Array[], blockSize: number) => Float32Array[];
+  renderOffline: (channels: Float32Array[], blockSize: number, finalize: boolean) => Float32Array[];
+  finishOfflineRender: () => void;
   bounceOffline: (options: WasmEngineBounceOptions) => WasmEngineBounceResult;
   freezeOffline: (options: WasmEngineFreezeOptions) => WasmEngineFreezeResult;
   drainTelemetry: (maxRecords: number) => WasmEngineTelemetry[];
@@ -1134,6 +1722,8 @@ export interface WasmRealtimeEngine {
   meterScratchTargetId: () => number;
   meterScratchRenderFrame: () => number;
   meterScratchValue: (field: number) => number;
+  meterScratchInputPeakDbL: () => number;
+  meterScratchInputPeakDbR: () => number;
   drainMeterTelemetry: (maxRecords: number) => WasmEngineMeterTelemetry[];
   drainMeterTelemetryWide: (maxRecords: number) => WasmEngineMeterTelemetryWide[];
   configureScopeTelemetry: (intervalFrames: number, bandCount: number) => number;
@@ -1161,6 +1751,11 @@ export interface WasmSynthEnumTables {
   bodyTypes: string[];
   modSources: string[];
   modDestinations: string[];
+  controllerInputs: string[];
+  controllerAxes: string[];
+  articulations: string[];
+  mpeDimensions: string[];
+  noteTrackings: string[];
 }
 
 export interface SonareModule {
@@ -1213,6 +1808,7 @@ export interface SonareModule {
     keyMode: number,
     detectInversions: boolean,
     chromaMethod: number,
+    tuning: number,
   ) => WasmChordAnalysisResult;
   chordFunctionalAnalysis: (
     samples: Float32Array,
@@ -1231,10 +1827,76 @@ export interface SonareModule {
     useKeyContext: boolean,
     detectInversions: boolean,
     chromaMethod: number,
+    tuning: number,
   ) => string[];
   analyze: (samples: Float32Array, sampleRate: number, options: object) => WasmAnalysisResult;
+  estimateMeter: (
+    beatTimes: ArrayLike<number>,
+    beatStrengths: ArrayLike<number>,
+    options: object,
+  ) => WasmMeterEstimateResult;
   _synthEnumTables: () => WasmSynthEnumTables;
   _synthPatchRoundTrip: (patch: unknown) => unknown;
+  // Arrangement surface. Present only in a build with arrangement support, like
+  // the mixing and voice-changer entries elsewhere in this interface; callers
+  // probe for it at runtime (see projectModule() in project_internal.ts) rather
+  // than through the type. `unknown` marks the shapes the facade owns — this
+  // file describes the raw module and does not depend on the facade's types.
+  projectAbiVersion: () => number;
+  synthPresetNames: () => string[];
+  synthPresetPatch: (name: string) => unknown;
+  synthGsDrumKitName: (program: number) => string | null;
+  synthGsDrumKitIsVoicedApart: (program: number) => number;
+  synthGsVariationIsVoicedApart: (bank: number, program: number) => number;
+  controllerProfileNames: () => string[];
+  midiGmInstrumentName: (program: number) => string | null;
+  midiGmProgramForName: (name: string) => number;
+  midiGmFamilyName: (family: number) => string | null;
+  midiGmFamilyFirstProgram: (family: number) => number;
+  midiGm2InstrumentName: (bankLsb: number, program: number) => string | null;
+  midiGmDrumName: (note: number) => string | null;
+  midiGmDrumNoteForName: (name: string) => number;
+  midiGm2DrumSetName: (bankLsb: number) => string | null;
+  midiGm2DrumName: (bankLsb: number, note: number) => string | null;
+  midiCcName: (controller: number) => string | null;
+  midiCcIndexForName: (name: string) => number;
+  midiPerNoteControllerName: (index: number) => string | null;
+  midiBankProgram: (
+    ppq: number,
+    group: number,
+    channel: number,
+    bankMsb: number,
+    bankLsb: number,
+    program: number,
+  ) => unknown;
+  midiRouteEvents: (events: readonly unknown[], config: unknown) => unknown;
+  midiCcLearn: (
+    events: readonly unknown[],
+    paramId: number,
+    minValue: number,
+    maxValue: number,
+    minMovement: number,
+  ) => unknown;
+  midiCcToBreakpoint: (bindings: readonly unknown[], event: unknown) => unknown;
+  midiParamToCc: (
+    bindings: readonly unknown[],
+    paramId: number,
+    unitValue: number,
+    group: number,
+    ppq: number,
+  ) => unknown;
+  transcribe: (
+    samples: Float32Array,
+    sampleRate: number,
+    tempoBpm: number | undefined,
+    config: unknown,
+  ) => unknown;
+  alignTakeToReference: (
+    reference: Float32Array,
+    take: Float32Array,
+    sampleRate: number,
+    config: unknown,
+  ) => unknown;
   _analysisResultSchemaPaths: () => string[];
   _analysisResultSchemaFixture: () => WasmAnalysisResult;
   analyzeImpulseResponse: (
@@ -1268,10 +1930,11 @@ export interface SonareModule {
     samples: Float32Array,
     sampleRate: number,
     options: WasmRoomMorphOptions,
-  ) => Float32Array;
+  ) => WasmRoomMorphResult;
   analyzeWithProgress: (
     samples: Float32Array,
     sampleRate: number,
+    options: object,
     progressCallback: ProgressCallback | null,
     cancelCallback: (() => boolean) | null,
   ) => WasmAnalysisResult;
@@ -1547,6 +2210,48 @@ export interface SonareModule {
     sampleRate: number,
     alignZeros: boolean,
   ) => Float32Array;
+  decomposeStems: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: {
+      nComponents?: number;
+      nFft?: number;
+      hopLength?: number;
+      nIter?: number;
+      beta?: number;
+      init?: string;
+      maskPower?: number;
+    },
+  ) => {
+    components: Float32Array[];
+    w: Float32Array;
+    h: Float32Array;
+    sampleRate: number;
+  };
+  decomposeStemsLinked: (
+    channels: Float32Array[],
+    sampleRate: number,
+    options: {
+      nComponents?: number;
+      nFft?: number;
+      hopLength?: number;
+      nIter?: number;
+      beta?: number;
+      init?: string;
+      maskPower?: number;
+    },
+  ) => {
+    components: Float32Array[][];
+    w: Float32Array;
+    h: Float32Array;
+    sampleRate: number;
+  };
+  remixAlignedIntervals: (
+    samples: Float32Array,
+    intervals: Int32Array,
+    sampleRate: number,
+    alignZeros: boolean,
+  ) => Int32Array;
   phaseVocoder: (
     samples: Float32Array,
     sampleRate: number,
@@ -1620,6 +2325,116 @@ export interface SonareModule {
     offsetSample: number,
     targetOnsetSample: number,
   ) => Float32Array;
+  extractNotes: (
+    samples: Float32Array,
+    sampleRate: number,
+    f0Hz: Float32Array,
+    voicedProb: Float32Array | undefined,
+    voiced: Float32Array | undefined,
+    frameRate: number,
+    options: {
+      segmentationThresholdCents?: number;
+      minNoteMs?: number;
+      referenceHz?: number;
+      voicedThreshold?: number;
+    },
+  ) => NoteObject[];
+  renderNotes: (
+    samples: Float32Array,
+    sampleRate: number,
+    notes: readonly NoteObjectInput[],
+    options: {
+      fadeMs?: number;
+      f0Hz?: Float32Array;
+      voiced?: Float32Array;
+      frameRate?: number;
+      vibratoCutoffHz?: number;
+    },
+  ) => Float32Array;
+  decomposeNotePitch: (
+    f0Hz: Float32Array,
+    voiced: Float32Array | undefined,
+    frameRate: number,
+    medianHz: number,
+    vibratoCutoffHz: number,
+  ) => PitchDecompositionResult;
+  splitNote: (
+    samples: Float32Array,
+    sampleRate: number,
+    f0Hz: Float32Array,
+    voicedProb: Float32Array | undefined,
+    voiced: Float32Array | undefined,
+    frameRate: number,
+    notes: readonly NoteSetEntry[],
+    index: number,
+    frame: number,
+    options: {
+      segmentationThresholdCents?: number;
+      minNoteMs?: number;
+      referenceHz?: number;
+      voicedThreshold?: number;
+    },
+  ) => NoteObject[];
+  mergeNotes: (
+    samples: Float32Array,
+    sampleRate: number,
+    f0Hz: Float32Array,
+    voicedProb: Float32Array | undefined,
+    voiced: Float32Array | undefined,
+    frameRate: number,
+    notes: readonly NoteSetEntry[],
+    first: number,
+    last: number,
+    options: {
+      segmentationThresholdCents?: number;
+      minNoteMs?: number;
+      referenceHz?: number;
+      voicedThreshold?: number;
+    },
+  ) => NoteObject[];
+  assignNoteTargets: (
+    notes: readonly NoteObject[],
+    sampleRate: number,
+    targets: readonly NoteTarget[],
+    options: {
+      unmatchedPolicy?: NoteTargetUnmatchedPolicy;
+      minOverlapRatio?: number;
+      maxCorrectionSemitones?: number;
+    },
+  ) => NoteTargetAssignResult;
+  /** Absent from a build without arrangement support, which is what links the MIDI reader. */
+  noteTargetsFromSmf?: (data: Uint8Array, trackIndex: number) => NoteTarget[];
+  createPolyphonicAnalysis: (
+    samples: Float32Array,
+    sampleRate: number,
+    config: Record<string, unknown>,
+  ) => WasmPolyphonicAnalysis;
+  extractPercussiveEvents: (
+    samples: Float32Array | readonly number[],
+    sampleRate: number,
+    options: {
+      nFft?: number;
+      hopLength?: number;
+      hpssKernelHarmonic?: number;
+      hpssKernelPercussive?: number;
+      onsetWait?: number;
+      onsetDelta?: number;
+      maxEventMs?: number;
+      minPercussiveRatio?: number;
+    },
+  ) => PercussiveEvent[];
+  renderPercussiveEvents: (
+    samples: Float32Array | readonly number[],
+    sampleRate: number,
+    events: readonly PercussiveEventInput[],
+    options: {
+      nFft?: number;
+      hopLength?: number;
+      hpssKernelHarmonic?: number;
+      hpssKernelPercussive?: number;
+      fadeMs?: number;
+    },
+  ) => Float32Array;
   voiceChange: (
     samples: Float32Array,
     sampleRate: number,
@@ -1639,6 +2454,13 @@ export interface SonareModule {
     targetDb: number,
     mode: string,
   ) => Float32Array;
+  normalizeStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    targetDb: number,
+    mode: string,
+  ) => { left: Float32Array; right: Float32Array; appliedGainDb: number };
   mastering: (
     samples: Float32Array,
     sampleRate: number,
@@ -1652,6 +2474,17 @@ export interface SonareModule {
   masteringPairProcessorNames: () => string[];
   masteringPairAnalysisNames: () => string[];
   masteringStereoAnalysisNames: () => string[];
+  masteringInsertNames: () => string[];
+  masteringInsertParamNames: (name: string) => string[];
+  // These return JSON the facade parses; the raw module has no object shape here.
+  masteringInsertParamInfo: (name: string) => string;
+  masteringProcessorCatalog: () => string;
+  masteringAmpPresetCatalog: () => string;
+  masteringInsertTiming: (
+    name: string,
+    paramsJson: string,
+    sampleRate: number,
+  ) => { latencySamples: number; tailSamples: number };
   masteringProcess: (
     processorName: string,
     samples: Float32Array,
@@ -1679,6 +2512,27 @@ export interface SonareModule {
     sampleRate: number,
     params: Record<string, number | boolean>,
   ) => string;
+  masteringPairProcessStereo: (
+    processorName: string,
+    sourceLeft: Float32Array,
+    sourceRight: Float32Array,
+    referenceLeft: Float32Array,
+    referenceRight: Float32Array,
+    sampleRate: number,
+    params: Record<string, number | boolean>,
+  ) => WasmMasteringStereoResult;
+  masteringAbMatchLoudness: (
+    source: Float32Array,
+    reference: Float32Array,
+    sampleRate: number,
+  ) => WasmLoudnessMatchResult;
+  masteringAbMatchLoudnessStereo: (
+    sourceLeft: Float32Array,
+    sourceRight: Float32Array,
+    referenceLeft: Float32Array,
+    referenceRight: Float32Array,
+    sampleRate: number,
+  ) => WasmLoudnessMatchStereoResult;
   masteringStereoAnalyze: (
     analysisName: string,
     left: Float32Array,
@@ -1689,8 +2543,13 @@ export interface SonareModule {
   masteringAssistantSuggest: (
     samples: Float32Array,
     sampleRate: number,
-    params: Record<string, number | boolean>,
+    params: Record<string, number | boolean | string>,
   ) => string;
+  masteringAssistantSuggestChain: (
+    samples: Float32Array,
+    sampleRate: number,
+    params: Record<string, number | boolean | string>,
+  ) => Record<string, number | boolean>;
   masteringAudioProfile: (
     samples: Float32Array,
     sampleRate: number,
@@ -1705,8 +2564,14 @@ export interface SonareModule {
     left: Float32Array,
     right: Float32Array,
     sampleRate: number,
-    params: Record<string, number | boolean>,
+    params: Record<string, number | boolean | string>,
   ) => string;
+  masteringAssistantSuggestChainStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    params: Record<string, number | boolean | string>,
+  ) => Record<string, number | boolean>;
   masteringAudioProfileStereo: (
     left: Float32Array,
     right: Float32Array,
@@ -1724,36 +2589,134 @@ export interface SonareModule {
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDeclickStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDeclickStereoResult;
   masteringRepairDenoiseClassical: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDenoiseClassicalStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDenoiseStereoResult;
+  masteringRepairDenoiseClassicalLinked: (
+    channels: Float32Array[],
+    sampleRate: number,
+    options: object,
+  ) => WasmDenoiseLinkedResult;
   masteringRepairDeclip: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDeclipStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDeclipStereoResult;
   masteringRepairDecrackle: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDecrackleStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDecrackleStereoResult;
   masteringRepairDehum: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDehumStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDehumStereoResult;
   masteringRepairDereverbClassical: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairDereverbClassicalStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmDereverbStereoResult;
+  masteringRepairDereverbClassicalLinked: (
+    channels: Float32Array[],
+    sampleRate: number,
+    options: object,
+  ) => WasmDereverbLinkedResult;
+  masteringRepairDereverbConfigForRoom: (
+    estimate: WasmRoomEstimateResult,
+    options: object,
+  ) => WasmDereverbClassicalConfig;
   masteringRepairTrimSilence: (
     samples: Float32Array,
     sampleRate: number,
     options: object,
   ) => Float32Array;
+  masteringRepairTrimSilenceStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmTrimSilenceStereoResult;
+  masteringRepairDetectClicks: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmClickDetection;
+  masteringRepairDetectNoiseFloor: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmNoiseDetection;
+  masteringRepairNoiseBandBins: (nFft: number, sampleRate: number) => Int32Array;
+  masteringRepairDetectClipping: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmClipDetection;
+  masteringRepairDetectCrackle: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmCrackleDetection;
+  masteringRepairDetectHum: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmHumDetection;
+  masteringRepairDetectReverb: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmReverbDetection;
+  masteringRepairDetectTrimRange: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmTrimRange;
+  masteringRepairDetectTrimRangeStereo: (
+    left: Float32Array,
+    right: Float32Array,
+    sampleRate: number,
+    options: object,
+  ) => WasmTrimRange;
   masteringDynamicsCompressor: (
     samples: Float32Array,
     sampleRate: number,
@@ -1796,6 +2759,8 @@ export interface SonareModule {
     cancelCallback: (() => boolean) | null,
   ) => WasmMasteringStereoChainResult;
   masteringPresetNames: () => string[];
+  masteringPresetParams: (preset: string) => Record<string, number | boolean>;
+  masteringPlatformNames: () => string[];
   masterAudio: (
     presetName: string,
     samples: Float32Array,
@@ -1834,6 +2799,24 @@ export interface SonareModule {
     sampleRate: number,
     options: Record<string, unknown>,
   ) => WasmMixResult;
+  mixingAssistantSuggest: (
+    leftChannels: Float32Array[],
+    rightChannels: (Float32Array | null)[] | null,
+    trackIds: string[],
+    trackNames: (string | null)[] | null,
+    sampleRate: number,
+    params: Record<string, number | boolean>,
+  ) => string;
+  mixingAssistantSuggestSceneJson: (
+    leftChannels: Float32Array[],
+    rightChannels: (Float32Array | null)[] | null,
+    trackIds: string[],
+    trackNames: (string | null)[] | null,
+    sampleRate: number,
+    params: Record<string, number | boolean>,
+  ) => string;
+  mixingAssistantSourceClassNames: () => string[];
+  mixingAssistantSourceClassFromName: (name: string) => number;
   trim: (samples: Float32Array, sampleRate: number, thresholdDb: number) => Float32Array;
   trimEx: (
     samples: Float32Array,
@@ -2145,6 +3128,7 @@ export interface SonareModule {
       segmentationThresholdCents?: number;
       minNoteMs?: number;
       referenceHz?: number;
+      voicedThreshold?: number;
     },
   ) => WasmNoteSegment[];
 
@@ -2177,6 +3161,18 @@ export interface SonareModule {
     frameLength: number,
     hopLength: number,
   ) => Int32Array;
+  splitSilenceCommon: (
+    signals: Float32Array[],
+    topDb: number,
+    frameLength: number,
+    hopLength: number,
+  ) => Int32Array;
+  splitSilenceCommonWithReport: (
+    signals: Float32Array[],
+    topDb: number,
+    frameLength: number,
+    hopLength: number,
+  ) => SplitSilenceCommonWithReportResult;
   frameSignal: (samples: Float32Array, frameLength: number, hopLength: number) => WasmFrameResult;
   tone: (
     frequency: number,
@@ -2341,6 +3337,11 @@ export interface SonareModule {
     hopLength: number,
     minSectionSec: number,
   ) => WasmSectionResult[];
+  detectBoundaries: (
+    samples: Float32Array,
+    sampleRate: number,
+    options: WasmBoundaryOptions,
+  ) => WasmBoundaryResult;
   analyzeMelody: (
     samples: Float32Array,
     sampleRate: number,
@@ -2386,6 +3387,11 @@ export interface SonareModule {
   momentaryLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
   shortTermLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
   lufsInterleaved: (samples: Float32Array, channels: number, sampleRate: number) => WasmLufsResult;
+  lufsSeriesInterleaved: (
+    samples: Float32Array,
+    channels: number,
+    sampleRate: number,
+  ) => WasmLufsSeriesResult;
   ebur128LoudnessRange: (samples: Float32Array, sampleRate: number) => number;
 
   // Core - Resample
@@ -2428,6 +3434,14 @@ export interface SonareModule {
     Major9: { value: 14 };
     Dominant9: { value: 15 };
     Sus2Add4: { value: 16 };
+    Major6: { value: 17 };
+    Minor6: { value: 18 };
+    MinorMajor7: { value: 19 };
+    Dominant7Sus4: { value: 20 };
+    Dominant11: { value: 21 };
+    Dominant13: { value: 22 };
+    Dominant7Flat9: { value: 23 };
+    Dominant7Sharp9: { value: 24 };
   };
   SectionType: {
     Intro: { value: 0 };
@@ -2492,6 +3506,23 @@ export interface SonareModule {
     error?: string;
   };
 
+  // Playback - renderer, HRTF set and program loudness meter
+  createHrtfSet: (bytes: Uint8Array) => WasmHrtfSet;
+  createPlaybackRenderer: (
+    configJson: string,
+    hrtf: WasmHrtfSet | null,
+    sampleRate: number,
+    maxBlockSize: number,
+  ) => WasmPlaybackRenderer;
+  createPlaybackLoudnessMeter: (channels: number, sampleRate: number) => WasmPlaybackLoudnessMeter;
+  renderPlayback: (
+    samples: Float32Array,
+    channels: number,
+    sampleRate: number,
+    configJson: string,
+    hrtf: WasmHrtfSet | null,
+  ) => { samples: Float32Array; channels: number };
+
   // Mixing - scene-based Mixer
   createMixerFromSceneJson: (json: string, sampleRate: number, blockSize: number) => WasmMixer;
 
@@ -2499,10 +3530,33 @@ export interface SonareModule {
   // surfaces a C++ throw as the raw pointer number) into a structured error.
   // Consumed by the module-error wrapper in module_state.ts.
   sonareExceptionInfo: (ptr: number) => { code: number; codeName: string; message: string };
+
+  // Drops the reference emscripten's __cxa_throw took on the exception object
+  // before rethrowing its pointer into JS. Nothing else ever drops it, so the
+  // module-error wrapper releases every pointer it surfaces.
+  sonareReleaseException: (ptr: number) => void;
+}
+
+// The polyphonic editing analysis. `noteCount` and `frameCount` are embind
+// properties rather than methods; everything else is a call.
+export interface WasmPolyphonicAnalysis {
+  readonly noteCount: number;
+  readonly frameCount: number;
+  notes: () => NoteObject[];
+  setNoteEdit: (note: number, edit: NoteEditInput) => void;
+  polyphony: () => Int32Array;
+  noteF0: (note: number) => Float32Array;
+  noteAmplitude: (note: number) => Float32Array;
+  noteSalience: (note: number) => Float32Array;
+  noteInharmonicity: () => Float32Array;
+  noteEnvelope: (note: number) => Float32Array;
+  render: (options: Record<string, unknown>) => Float32Array;
+  delete: () => void;
 }
 
 export interface WasmStreamingMasteringChain {
   prepare: (sampleRate: number, maxBlockSize: number, numChannels: number) => void;
+  setParameter: (key: string, value: number) => void;
   processMono: (samples: Float32Array) => Float32Array;
   processStereo: (
     left: Float32Array,
@@ -2513,6 +3567,10 @@ export interface WasmStreamingMasteringChain {
   reset: () => void;
   latencySamples: () => number;
   stageNames: () => string[];
+  /** Cumulative since prepare(), which rebuilds the stages and so clears it. */
+  nonFiniteSubstitutionCount: () => number;
+  /** Not the same measurement as nonFiniteSubstitutionCount; see the facade. */
+  nonFiniteDiscardCount: () => number;
   delete: () => void;
 }
 
@@ -2540,11 +3598,13 @@ export interface WasmStreamingEqualizer {
   clearSidechain: () => void;
   lastAutoGainDb: () => number;
   latencySamples: () => number;
+  nonFiniteDiscardCount: () => number;
   processMono: (samples: Float32Array) => Float32Array;
   processStereo: (
     left: Float32Array,
     right: Float32Array,
   ) => { left: Float32Array; right: Float32Array };
+  magnitudeResponse: (placement: number, frequenciesHz: Float32Array) => Float32Array;
   spectrum: () => WasmEqSpectrumSnapshot;
   match: (source: Float32Array, reference: Float32Array, options: Record<string, unknown>) => void;
   delete: () => void;
@@ -2556,6 +3616,7 @@ export interface WasmStreamingRetune {
   setConfig: (config: Record<string, unknown>) => void;
   config: () => { semitones: number; mix: number; grainSize: number };
   grainSize: () => number;
+  latencySamples: () => number;
   processMono: (samples: Float32Array) => Float32Array;
   delete: () => void;
 }
@@ -2567,6 +3628,7 @@ export interface WasmRealtimeVoiceChanger {
   setPodConfig: (config: WasmRealtimeVoiceChangerPodConfig) => void;
   configJson: () => string;
   latencySamples: () => number;
+  nonFiniteDiscardCount: () => number;
   bufferGeneration: () => number;
   processMono: (samples: Float32Array) => Float32Array;
   processMonoInto: (samples: Float32Array, output: Float32Array) => void;
@@ -2587,6 +3649,58 @@ export interface WasmRealtimeVoiceChanger {
   delete: () => void;
 }
 
+export interface WasmHrtfSet {
+  delete: () => void;
+}
+
+export interface WasmPlaybackRenderer {
+  processPlanar: (planes: Float32Array[]) => Float32Array[];
+  processInterleaved: (samples: Float32Array, inChannels: number) => Float32Array;
+  setConfig: (configJson: string) => void;
+  configJson: () => string;
+  setHeadOrientation: (yawDeg: number, pitchDeg: number, rollDeg: number) => void;
+  reset: () => void;
+  latencySamples: () => number;
+  inputChannels: () => number;
+  outputChannels: () => number;
+  diagnosticsJson: () => string;
+  nonFiniteDiscardCount: () => number;
+  // AudioWorklet path: heap views allocated once at construction (they detach
+  // on memory growth and are then re-acquired), and a SonareError code instead
+  // of a throw for a rejected block.
+  inputPlane: (channel: number) => Float32Array;
+  outputPlane: (channel: number) => Float32Array;
+  processPrepared: (inChannels: number, frames: number) => number;
+  processPreparedSilence: (frames: number) => number;
+  delete: () => void;
+}
+
+export interface WasmPlaybackLoudnessMeter {
+  pushInterleaved: (samples: Float32Array) => void;
+  integratedLufs: () => number;
+  delete: () => void;
+}
+
+/** One block's worth of meter readings, all dB fields floored at -120. */
+export interface WasmMixerMeterSnapshot {
+  peakDbL: number;
+  peakDbR: number;
+  rmsDbL: number;
+  rmsDbR: number;
+  correlation: number;
+  /**
+   * Left-channel inter-sample (true) peak in dB, from the ITU-R BS.1770-4
+   * polyphase reconstruction at 4x. A streaming measurement: the centered
+   * reconstruction stencil needs a few future samples a realtime path does not
+   * have, so each block's last samples read marginally low (about 0.1 dB across
+   * 64..8192-sample blocks on a near-Nyquist tone, always under-reading). Use
+   * `meteringTruePeakDb` over the whole signal for an exact dBTP number.
+   */
+  truePeakDbL: number;
+  /** Right-channel inter-sample (true) peak in dB. See {@link truePeakDbL}. */
+  truePeakDbR: number;
+}
+
 export interface WasmMixer {
   compile: () => void;
   processStereo: (
@@ -2604,6 +3718,10 @@ export interface WasmMixer {
   outputLeftView: () => Float32Array;
   outputRightView: () => Float32Array;
   processPreparedStereo: (numSamples: number) => void;
+  configureMeter: (enabled: boolean, truePeakOversample: number) => void;
+  meterSnapshot: () => WasmMixerMeterSnapshot;
+  latchMeterSnapshot: () => boolean;
+  meterScratchValue: (field: number) => number;
   stripCount: () => number;
   sceneWarnings: () => string[];
   scheduleInsertAutomation: (
@@ -2619,6 +3737,7 @@ export interface WasmMixer {
   setFaderDb: (stripIndex: number, db: number) => void;
   setPan: (stripIndex: number, pan: number, panMode: number) => void;
   setWidth: (stripIndex: number, width: number) => void;
+  settle: (stripIndex: number) => void;
   setMuted: (stripIndex: number, muted: boolean) => void;
   setSoloed: (stripIndex: number, soloed: boolean) => void;
   setSoloSafe: (stripIndex: number, soloSafe: boolean) => void;
@@ -2640,6 +3759,8 @@ export interface WasmMixer {
   meterTap: (stripIndex: number, tap: number) => WasmMixMeterSnapshot;
   stripMeter: (stripIndex: number) => WasmMixMeterSnapshot;
   busMeter: (busId: string) => WasmMixMeterSnapshot;
+  stripNonFiniteDiscardCount: (stripIndex: number) => number;
+  busNonFiniteDiscardCount: (busId: string) => number;
   scheduleFaderAutomation: (
     stripIndex: number,
     samplePos: number,
@@ -2666,6 +3787,7 @@ export interface WasmMixer {
     curve: number,
   ) => void;
   readGoniometerLatest: (stripIndex: number, maxPoints: number) => WasmGoniometerPoint[];
+  addStrip: (id: string, metering: StripMeteringOptions) => void;
   addBus: (id: string, role: string) => void;
   removeBus: (id: string) => void;
   busCount: () => number;
@@ -2744,6 +3866,7 @@ export interface WasmAnalyzerStats {
   droppedOutputFrames: number;
   droppedChordProgressionEntries: number;
   droppedBarProgressionEntries: number;
+  nonFiniteDiscardBlocks: number;
   estimate: WasmProgressiveEstimate;
 }
 
@@ -2794,8 +3917,11 @@ export interface WasmStreamFramesI16 {
 }
 
 export interface WasmStreamAnalyzer {
+  /** Throws (invalid state) when the stream was already finalized; reset first. */
   process: (samples: Float32Array) => void;
+  /** Rejects a gap, a seek, a mode switch, and a chunk fed after finalize. */
   processWithOffset: (samples: Float32Array, sampleOffset: number) => void;
+  /** Idempotent on success; a failed call leaves the stream un-finalized. */
   finalize: () => void;
   availableFrames: () => number;
   readFramesSoa: (maxFrames: number) => WasmFrameBuffer;
@@ -2807,7 +3933,9 @@ export interface WasmStreamAnalyzer {
   currentTime: () => number;
   sampleRate: () => number;
   setExpectedDuration: (durationSeconds: number) => void;
+  /** Throws outside 0.01..100; the request is refused, never clamped. */
   setNormalizationGain: (gain: number) => void;
+  /** Throws outside 220..880 Hz; the request is refused, never clamped. */
   setTuningRefHz: (refHz: number) => void;
   delete: () => void;
 }