@libraz/libsonare 1.8.0 → 1.8.2

package/src/realtime_engine.ts

@@ -12,16 +12,24 @@ import type {
   ControllerBinding,
   MpeDimension,
   NoteTracking,
+  PartRigInsert,
+  PartRigMode,
   ProjectMidiCcBinding,
   SynthPatch,
 } from './project';
-import { normalizeSynthInstrument } from './project_internal';
+import type { ProjectTimeline } from './project_class';
+import {
+  normalizeSynthInstrument,
+  partRigInsertsJson,
+  projectTimelineNativeId,
+} from './project_internal';
 import type {
   EqBand,
   PanLawInput,
   PanMode,
   SendTiming,
   SidechainSourceKind,
+  SurroundPan,
   UmpWords,
 } from './public_types';
 import type {
@@ -29,6 +37,7 @@ import type {
   WasmEngineAutomationPoint,
   WasmEngineBounceOptions,
   WasmEngineBounceResult,
+  WasmEngineBus,
   WasmEngineCaptureStatus,
   WasmEngineClip,
   WasmEngineFreezeOptions,
@@ -44,6 +53,7 @@ import type {
   WasmEngineTelemetry,
   WasmEngineTempoSegment,
   WasmEngineTimeSignatureSegment,
+  WasmEngineTrackSend,
   WasmEngineTransportState,
   WasmExternalMidiEvent,
   WasmRealtimeEngine,
@@ -574,6 +584,23 @@ export class RealtimeEngine {
     this.native.setArticulation(destinationId, channel, articulation);
   }
 
+  /**
+   * Set the rig of one part (0-15), or of the destination's default when `part`
+   * is `PART_RIG_ALL_PARTS`, on the instrument bound to `destinationId`. A
+   * direct call, not a stored edit: a destination with no instrument is an
+   * invalid parameter, and an instrument without part rigs (a builtin, a
+   * host-callback instrument) is refused as not implemented rather than
+   * succeeding quietly. `'chain'` takes 1-8 `inserts`; no other mode does.
+   */
+  setPartRig(
+    destinationId: number,
+    part: number,
+    mode: PartRigMode | number,
+    inserts?: PartRigInsert[],
+  ): void {
+    this.native.setPartRig(destinationId, part, mode, partRigInsertsJson(inserts));
+  }
+
   /**
    * Read back {@link setArticulation} as the canonical name. An ordinal this
    * build cannot spell is handed back as the number, the way every other enum
@@ -626,7 +653,10 @@ export class RealtimeEngine {
   /**
    * Route a destination's (track lane's) MIDI to the external output queue
    * instead of the internal instrument rack, so the track plays an external
-   * device. Clearing it restores internal-synth playback.
+   * device. Clearing it restores internal-synth playback. Control-thread only.
+   * The change takes effect at the next processed block; switching a
+   * destination's route first releases its notes and resets its controllers
+   * through the old route, and drops its pending MIDI-FX events. Single writer.
    */
   setMidiDestinationExternal(destinationId: number, external: boolean): void {
     this.native.setMidiDestinationExternal(destinationId, external);
@@ -883,8 +913,11 @@ export class RealtimeEngine {
   /**
    * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
    * the full message including the leading 0xF0 and trailing 0xF7 (1..512
-   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Mirrors
-   * the Node/Python/C-ABI `pushMidiSysex`.
+   * bytes). `renderFrame` is the frame to fire at, or -1 for immediate. Throws
+   * `InvalidParameter` when the destination instrument cannot prepare
+   * the SysEx (retrying cannot help), and `OutOfMemory` when the payload
+   * slots or the command queue are full (retry after a processed block).
+   * Mirrors the Node/Python/C-ABI `pushMidiSysex`.
    */
   pushMidiSysex(destinationId: number, data: Uint8Array, renderFrame = -1): void {
     this.native.pushMidiSysex(destinationId, data, renderFrame);
@@ -911,14 +944,34 @@ export class RealtimeEngine {
     return this.native.getTransportState();
   }
 
+  /** Queues an integrated-loudness reset; short-term and momentary windows are retained. */
+  resetMasterLoudnessMeter(renderFrame = -1): void {
+    this.native.resetMasterLoudnessMeter(renderFrame);
+  }
+
+  /** Reads the immutable factory value for a resolved insert parameter id. */
+  insertParameterConstructedValue(paramId: number): number {
+    return this.native.insertParameterConstructedValue(paramId);
+  }
+
   play(renderFrame = -1): void {
     this.native.play(renderFrame);
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   stop(renderFrame = -1): void {
     this.native.stop(renderFrame);
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   seekSample(timelineSample: number, renderFrame = -1): void {
     this.native.seekSample(timelineSample, renderFrame);
   }
@@ -948,6 +1001,11 @@ export class RealtimeEngine {
     this.native.applyCommandsDueNowPreservingFuture();
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   seekPpq(ppq: number, renderFrame = -1): void {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -973,6 +1031,11 @@ export class RealtimeEngine {
     return Number(this.native.sampleAtPpq(ppq));
   }
 
+  /**
+   * A loop wrap, seek or stop sends note-offs plus CC64=0, CC121, CC123 and a
+   * centred pitch bend on every channel played since the last reset, so
+   * controller values set before a loop region are not restored at the wrap.
+   */
   setLoop(startPpq: number, endPpq: number, enabled = true): void {
     this.native.setLoop(startPpq, endPpq, enabled);
   }
@@ -1079,7 +1142,7 @@ export class RealtimeEngine {
    * reads (defaults to post-fader when omitted). Shared by track lanes and
    * buses, which carry the same send shape.
    */
-  private static normalizeSends(sends: EngineTrackSend[]): EngineTrackSend[] {
+  private static normalizeSends(sends: EngineTrackSend[]): WasmEngineTrackSend[] {
     return sends.map((send) => ({
       ...send,
       // Post-fader (0) is the default for an omitted sendTiming.
@@ -1093,10 +1156,10 @@ export class RealtimeEngine {
         if (typeof lane === 'number') {
           return { trackId: lane };
         }
-        if (!lane.sends) {
-          return lane;
-        }
-        return { ...lane, sends: RealtimeEngine.normalizeSends(lane.sends) };
+        return {
+          ...lane,
+          sends: lane.sends ? RealtimeEngine.normalizeSends(lane.sends) : undefined,
+        };
       }),
     );
   }
@@ -1104,11 +1167,44 @@ export class RealtimeEngine {
   /**
    * Keys one insert of a lane strip from another lane's post-strip audio
    * (ducking/sidechainRouter inserts). sourceTrackId 0 removes the binding.
+   * Lanes are processed in key order and the key is delay-compensated to the
+   * destination strip input, so the result depends on neither the lane order
+   * nor the block size. Throws, leaving the bindings unchanged, for a lane
+   * keying itself, a binding that would close a cycle over the lane bindings,
+   * a full binding table and an alignment past the delay ceiling. Not callable
+   * while a block is being processed.
    */
   setLaneSidechain(trackId: number, insertIndex: number, sourceTrackId: number): void {
     this.native.setLaneSidechain(trackId, insertIndex, sourceTrackId);
   }
 
+  /**
+   * Installs a compiled project timeline into this stopped engine, all or
+   * nothing: tempo and time-signature segments, markers, track lanes, track
+   * automation, audio and MIDI clips, and the per-track strips of the project's
+   * mixer scene are replaced in full (a later low-level setter on those domains
+   * is overwritten by the next apply). Instruments, buses, the master strip,
+   * metronome, loop and capture are not touched; bind instruments separately.
+   *
+   * Throws while the transport is playing, for a timeline the engine cannot
+   * hold, and for a scene strip routed from several tracks. A validation
+   * failure leaves the engine unchanged. The engine keeps its own reference, so
+   * {@link ProjectTimeline.dispose} may follow immediately.
+   *
+   * Also throws on an unprepared engine and on a timeline whose sample rate
+   * differs from the engine's. Once a timeline is applied, a later prepare at
+   * another rate is refused until the timeline's clips are cleared.
+   */
+  applyProjectTimeline(timeline: ProjectTimeline): void {
+    // Resolve through the identity registry so no raw native handle crosses the
+    // facade boundary and the realtime bundle needs no value class import.
+    const timelineId = projectTimelineNativeId(timeline);
+    if (timelineId === undefined) {
+      throw new TypeError('timeline must be a ProjectTimeline instance');
+    }
+    this.native.applyProjectTimeline(timelineId);
+  }
+
   setTrackBuses(buses: EngineBus[]): void {
     // Array.isArray guards a caller-fabricated array-like (e.g. `{ length }`)
     // meant to probe the native array-length read: passing it through
@@ -1116,10 +1212,11 @@ export class RealtimeEngine {
     // failing here on a `.map` that array-likes do not implement.
     this.native.setTrackBuses(
       Array.isArray(buses)
-        ? buses.map((bus) =>
-            bus.sends ? { ...bus, sends: RealtimeEngine.normalizeSends(bus.sends) } : bus,
-          )
-        : buses,
+        ? buses.map((bus) => ({
+            ...bus,
+            sends: bus.sends ? RealtimeEngine.normalizeSends(bus.sends) : undefined,
+          }))
+        : (buses as WasmEngineBus[]),
     );
   }
 
@@ -1357,6 +1454,16 @@ export class RealtimeEngine {
    * stages of the offline mastering chain (`repair.*`, `loudness`, and the
    * match stages) have no insert form and no automation id: they buffer the
    * entire signal by construction and do not run on the realtime path.
+   *
+   * The returned id uses the track's current positional lane selector. When
+   * `setTrackLanes` successfully changes lane order or membership, the engine
+   * remaps already queued and published track automation by track id, but it
+   * cannot update a numeric id retained by the caller. Re-resolve every track
+   * insert id after such a topology change before passing it to
+   * `setAutomationLane`, `setParameter`, or `setParameterSmoothed`. Use
+   * `setTrackStripInsertParamByName` when the operation needs a stable track
+   * identity. Master and bus insert ids are separate and are not invalidated by
+   * track-lane changes.
    */
   resolveTrackInsertAutomationId(trackId: number, insertIndex: number, paramName: string): number {
     return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
@@ -1392,12 +1499,9 @@ export class RealtimeEngine {
    * return `-1`: they resize voice pools or swap DSP topology, which is not
    * audio-thread safe. Rebind the instrument with a new patch instead.
    *
-   * `gain`, `busDrive`, `cutoffHz`, `resonanceQ`, `envToCutoffCents`,
-   * `lfoToPitchCents` and `pitchOffsetCents` reach voices that are already
-   * sounding from the next block; the rest are cached into per-voice state at
-   * note-on and take effect from the next note, so a lane that moves one of
-   * them under a held note looks inert until the next one speaks — that is the
-   * behaviour, not a dropped write.
+   * All automatable parameters of a NativeSynth reach already-sounding voices
+   * from the next processed block. Voices using GM program patches are
+   * unaffected; parameters apply to NativeSynth's own patch only.
    *
    * The id survives an unbind/rebind of the same destination and applies
    * nothing while that destination is unbound.
@@ -1426,6 +1530,17 @@ export class RealtimeEngine {
     this.native.setTrackStripDualPan(trackId, leftPan, rightPan);
   }
 
+  /**
+   * Sets a track lane strip's surround placement in realtime (glitch-free; a
+   * constant-power 5 ms one-pole glide). Used when the destination has more than
+   * two channels. Omitted fields default to a centered point source
+   * (`distance` 1); a `distance` of 0 or less is treated as 1. Throws for an
+   * unknown track, a track without a lane strip, or a non-finite field.
+   */
+  setTrackStripSurroundPan(trackId: number, pan: SurroundPan): void {
+    this.native.setTrackStripSurroundPan(trackId, pan);
+  }
+
   /**
    * Sets a bus strip's output pan position in realtime (glitch-free). Throws
    * for an unknown bus or one wider than stereo.
@@ -1450,8 +1565,9 @@ export class RealtimeEngine {
   }
 
   /**
-   * Sets a track lane strip's inter-channel alignment delay (whole samples).
-   * Adjusts strip latency, so PDC and reported graph latency are refreshed.
+   * Sets a track lane strip's alignment delay (whole samples), moving this lane
+   * later relative to every other lane. It is not latency: PDC does not
+   * compensate it and the reported graph latency is unchanged.
    */
   setTrackStripChannelDelaySamples(trackId: number, delaySamples: number): void {
     this.native.setTrackStripChannelDelaySamples(trackId, delaySamples);
@@ -1757,6 +1873,12 @@ export class RealtimeEngine {
   meterScratchRenderFrame(): number {
     return Number(this.native.meterScratchRenderFrame());
   }
+  meterScratchInputPeakDbL(): number {
+    return this.native.meterScratchInputPeakDbL();
+  }
+  meterScratchInputPeakDbR(): number {
+    return this.native.meterScratchInputPeakDbR();
+  }
   meterScratchValue(field: number): number {
     return this.native.meterScratchValue(field);
   }
@@ -1768,15 +1890,26 @@ export class RealtimeEngine {
   /**
    * Drains pending meter telemetry as per-plane (wide) records for a surround
    * target. Use this for a surround mix target; {@link drainMeterTelemetry}
-   * stays the stereo fast path. The two share one queue — call only one per
-   * target. The live AudioWorklet path owns the queue via the stereo drain, so
-   * this wide drain is for an offline (non-worklet) engine instance; per-plane
+   * stays the stereo fast path. The two share one queue and each consumes every
+   * target's records, so an engine uses only one of them. The live AudioWorklet
+   * path owns the queue via the stereo drain, so this wide drain is for an
+   * offline (non-worklet) engine instance; per-plane
    * surround meters are not delivered over the live worklet meter ring.
    */
   drainMeterTelemetryWide(maxRecords = 1024): EngineMeterTelemetryWide[] {
     return this.native.drainMeterTelemetryWide(maxRecords);
   }
 
+  /**
+   * Per-insert gain reduction in dB (each <= 0) of a meter target's strip from the
+   * last rendered block, in combined pre-to-post insert order. `targetId` uses the
+   * meter-record encoding (0 master, 1..32 lanes, 33..40 buses; 0xFFFF monitor
+   * yields an empty array). Throws for an id outside that range.
+   */
+  meterTargetInsertGainReduction(targetId: number): number[] {
+    return this.native.meterTargetInsertGainReduction(targetId);
+  }
+
   /**
    * Enables per-target spectrum + vectorscope capture. @param intervalFrames is
    * the minimum render-frame gap between snapshots (0 disables). @param bandCount

package/src/repair_dereverb.ts

@@ -19,6 +19,7 @@ export interface DereverbClassicalOptions {
   threshold?: number;
   attenuation?: number;
   nFft?: number;
+  /** Hop in samples, in (0, nFft / 2]. */
   hopLength?: number;
   t60Sec?: number;
   lateDelayMs?: number;

package/src/repair_noise.ts

@@ -26,6 +26,7 @@ export interface DenoiseClassicalOptions {
   mode?: DenoiseClassicalMode;
   noiseEstimator?: DenoiseClassicalNoiseEstimator;
   nFft?: number;
+  /** Hop in samples, in (0, nFft / 2]. */
   hopLength?: number;
   ddAlpha?: number;
   reductionDb?: number;

package/src/sonare.js.d.ts

@@ -25,6 +25,7 @@ import type {
   SpectralRegionOp,
   SurroundPan,
 } from './public_types';
+import type { VocalWasmExports } from './vocal_edit';
 
 export interface SonareModuleOptions {
   locateFile?: (path: string, prefix: string) => string;
@@ -829,6 +830,11 @@ export interface WasmLoudnessMatchResult {
   matchedTruePeakDbtp: number;
 }
 
+export interface WasmLoudnessMatchStereoResult extends Omit<WasmLoudnessMatchResult, 'samples'> {
+  left: Float32Array;
+  right: Float32Array;
+}
+
 export interface WasmStageGainReduction {
   stage: string;
   gainReductionDb: number;
@@ -965,6 +971,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 {
@@ -1165,6 +1173,10 @@ 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;
 }
 
@@ -1199,6 +1211,8 @@ export interface WasmEngineMeterTelemetryWide {
   shortTermLufs: number;
   integratedLufs: number;
   gainReductionDb: number;
+  /** Pre-trim input peak for each valid plane, in dBFS. */
+  inputPeakDb: number[];
   droppedRecords: number;
 }
 
@@ -1275,7 +1289,17 @@ export interface WasmEngineBounceOptions {
   totalFrames: number;
   blockSize?: number;
   numChannels?: number;
+  /**
+   * Output sample rate. Omitting it (or `0`) keeps the source rate, so nothing
+   * is resampled; a different rate resamples. The result's `sampleRate`
+   * reports the rate of the returned audio.
+   */
   targetSampleRate?: number;
+  /**
+   * Rate `totalFrames` is counted in. Omitting it (or `0`) means the engine's
+   * prepared rate; a different value throws an `InvalidParameter` `SonareError`,
+   * because the render always runs at the prepared rate.
+   */
   sourceSampleRate?: number;
   normalizeLufs?: boolean;
   /**
@@ -1363,6 +1387,8 @@ export interface WasmRealtimeEngine {
   getTransportState: () => WasmEngineTransportState;
   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;
@@ -1398,6 +1424,7 @@ export interface WasmRealtimeEngine {
   clipCount: () => number;
   setTrackLanes: (lanes: Array<number | WasmEngineTrackLane>) => void;
   setLaneSidechain: (trackId: number, insertIndex: number, sourceTrackId: number) => void;
+  applyProjectTimeline: (timelineId: number) => void;
   setTrackBuses: (buses: WasmEngineBus[]) => void;
   setBusSidechain: (
     busId: number,
@@ -1491,6 +1518,7 @@ export interface WasmRealtimeEngine {
   setTrackStripPanLaw: (trackId: number, panLaw: number) => void;
   setTrackStripPanMode: (trackId: number, panMode: number) => void;
   setTrackStripDualPan: (trackId: number, leftPan: number, rightPan: number) => void;
+  setTrackStripSurroundPan: (trackId: number, pan: SurroundPan) => void;
   setBusStripPan: (busId: number, pan: number) => void;
   setBusStripPanLaw: (busId: number, panLaw: number) => void;
   setBusStripPanMode: (busId: number, panMode: number) => void;
@@ -1564,6 +1592,12 @@ export interface WasmRealtimeEngine {
     channel: number,
   ) => import('./instrument_types').Articulation | number;
   legatoFallbackCount: (destinationId: number) => number;
+  setPartRig: (
+    destinationId: number,
+    part: number,
+    mode: import('./instrument_types').PartRigMode | number,
+    insertsJson: string | undefined,
+  ) => void;
   setMidiFx: (destinationId: number, configJson: string) => void;
   clearMidiFx: (destinationId: number) => void;
   setMidiInputSource: (destinationId: number) => void;
@@ -1707,8 +1741,11 @@ export interface WasmRealtimeEngine {
   meterScratchTargetId: () => number;
   meterScratchRenderFrame: () => number;
   meterScratchValue: (field: number) => number;
+  meterScratchInputPeakDbL: () => number;
+  meterScratchInputPeakDbR: () => number;
   drainMeterTelemetry: (maxRecords: number) => WasmEngineMeterTelemetry[];
   drainMeterTelemetryWide: (maxRecords: number) => WasmEngineMeterTelemetryWide[];
+  meterTargetInsertGainReduction: (targetId: number) => number[];
   configureScopeTelemetry: (intervalFrames: number, bandCount: number) => number;
   drainScopeTelemetry: (maxRecords: number) => WasmEngineScopeTelemetry[];
   popScopeTelemetryToScratch: () => boolean;
@@ -1742,6 +1779,39 @@ export interface WasmSynthEnumTables {
 }
 
 export interface SonareModule {
+  vocalEditApiVersion: VocalWasmExports['vocalEditApiVersion'];
+  vocalEditAvailable: VocalWasmExports['vocalEditAvailable'];
+  vocalEditSessionCreate: VocalWasmExports['vocalEditSessionCreate'];
+  vocalEditSessionRestore: VocalWasmExports['vocalEditSessionRestore'];
+  vocalEditSessionDestroy: VocalWasmExports['vocalEditSessionDestroy'];
+  vocalEditSessionNotes: VocalWasmExports['vocalEditSessionNotes'];
+  vocalEditDraftNotes: VocalWasmExports['vocalEditDraftNotes'];
+  vocalEditSessionToken: VocalWasmExports['vocalEditSessionToken'];
+  vocalEditDraftToken: VocalWasmExports['vocalEditDraftToken'];
+  vocalEditSessionAnalysis: VocalWasmExports['vocalEditSessionAnalysis'];
+  vocalEditSessionCapabilities: VocalWasmExports['vocalEditSessionCapabilities'];
+  vocalEditSessionOutputLength: VocalWasmExports['vocalEditSessionOutputLength'];
+  vocalEditSessionHistory: VocalWasmExports['vocalEditSessionHistory'];
+  vocalEditSessionBeginEdit: VocalWasmExports['vocalEditSessionBeginEdit'];
+  vocalEditDraftApply: VocalWasmExports['vocalEditDraftApply'];
+  vocalEditDraftCommit: VocalWasmExports['vocalEditDraftCommit'];
+  vocalEditDraftCancel: VocalWasmExports['vocalEditDraftCancel'];
+  vocalEditDraftDestroy: VocalWasmExports['vocalEditDraftDestroy'];
+  vocalEditSessionApplyHistory: VocalWasmExports['vocalEditSessionApplyHistory'];
+  vocalEditEvaluatePitch: VocalWasmExports['vocalEditEvaluatePitch'];
+  vocalEditMapCoordinate: VocalWasmExports['vocalEditMapCoordinate'];
+  vocalEditCaptureSnapshot: VocalWasmExports['vocalEditCaptureSnapshot'];
+  vocalEditSnapshotDestroy: VocalWasmExports['vocalEditSnapshotDestroy'];
+  vocalEditSnapshotOutputLength: VocalWasmExports['vocalEditSnapshotOutputLength'];
+  vocalEditSnapshotRender: VocalWasmExports['vocalEditSnapshotRender'];
+  vocalEditRenderJobBegin: VocalWasmExports['vocalEditRenderJobBegin'];
+  vocalEditRenderJobNext: VocalWasmExports['vocalEditRenderJobNext'];
+  vocalEditRenderJobFinalize: VocalWasmExports['vocalEditRenderJobFinalize'];
+  vocalEditRenderJobAbort: VocalWasmExports['vocalEditRenderJobAbort'];
+  vocalEditRenderJobDestroy: VocalWasmExports['vocalEditRenderJobDestroy'];
+  vocalEditSessionExportState: VocalWasmExports['vocalEditSessionExportState'];
+  vocalEditLastErrorDetail: VocalWasmExports['vocalEditLastErrorDetail'];
+
   audioFromMemory: (bytes: Uint8Array) => WasmAudioFromMemoryResult;
 
   // Quick API (high-level)
@@ -2329,12 +2399,14 @@ export interface SonareModule {
     options: {
       fadeMs?: number;
       f0Hz?: Float32Array;
+      voiced?: Float32Array;
       frameRate?: number;
       vibratoCutoffHz?: number;
     },
   ) => Float32Array;
   decomposeNotePitch: (
     f0Hz: Float32Array,
+    voiced: Float32Array | undefined,
     frameRate: number,
     medianHz: number,
     vibratoCutoffHz: number,
@@ -2493,11 +2565,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,
@@ -3521,6 +3609,7 @@ export interface WasmPolyphonicAnalysis {
 
 export interface WasmStreamingMasteringChain {
   prepare: (sampleRate: number, maxBlockSize: number, numChannels: number) => void;
+  setParameter: (key: string, value: number) => void;
   processMono: (samples: Float32Array) => Float32Array;
   processStereo: (
     left: Float32Array,

package/src/streaming_processors.ts

@@ -171,6 +171,14 @@ export class StreamingMasteringChain {
     this.chain.reset();
   }
 
+  /**
+   * Set one realtime-safe full-chain parameter at a serialized block boundary.
+   * Structural, disabled-stage and unknown parameters are rejected.
+   */
+  setParameter(key: string, value: number): void {
+    this.chain.setParameter(key, value);
+  }
+
   /** Total reported latency in samples across all active processors. */
   latencySamples(): number {
     return this.chain.latencySamples();