@libraz/libsonare 1.8.0 → 1.8.1

package/src/mastering_core.ts

@@ -2,6 +2,7 @@ import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
 import type {
   LoudnessMatchResult,
+  LoudnessMatchStereoResult,
   MasteringAssistantParams,
   MasteringInsertParamChoice,
   MasteringInsertSlot,
@@ -13,6 +14,7 @@ import type {
   PairProcessor,
   SoloProcessor,
   StereoAnalysis,
+  StereoPairProcessor,
   StreamingPlatform,
 } from './public_types';
 
@@ -52,6 +54,17 @@ export interface MasteringPairProcessRequest {
   params?: MasteringProcessorParams;
 }
 
+/** Canonical request form for a stereo two-input match processor. */
+export interface MasteringPairProcessStereoRequest {
+  processorName: StereoPairProcessor;
+  sourceLeft: Float32Array;
+  sourceRight: Float32Array;
+  referenceLeft: Float32Array;
+  referenceRight: Float32Array;
+  sampleRate?: number;
+  params?: MasteringProcessorParams;
+}
+
 /** Canonical request form for {@link masteringAbMatchLoudness}. */
 export interface MasteringAbMatchLoudnessRequest {
   /** The take to gain-match. */
@@ -61,6 +74,15 @@ export interface MasteringAbMatchLoudnessRequest {
   sampleRate?: number;
 }
 
+/** Canonical request form for stereo AB loudness matching. */
+export interface MasteringAbMatchLoudnessStereoRequest {
+  sourceLeft: Float32Array;
+  sourceRight: Float32Array;
+  referenceLeft: Float32Array;
+  referenceRight: Float32Array;
+  sampleRate?: number;
+}
+
 /** Canonical request form for a two-input match analysis. */
 export interface MasteringPairAnalyzeRequest {
   analysisName: PairAnalysis;
@@ -548,6 +570,60 @@ export function masteringPairProcess(
   );
 }
 
+/**
+ * Apply the stereo `match.abCrossfade` processor. Source and reference stereo
+ * pairs may have independent lengths, but each pair must have equal channels.
+ */
+export function masteringPairProcessStereo(
+  request: MasteringPairProcessStereoRequest,
+): MasteringStereoResult;
+export function masteringPairProcessStereo(
+  processorName: StereoPairProcessor,
+  sourceLeft: Float32Array,
+  sourceRight: Float32Array,
+  referenceLeft: Float32Array,
+  referenceRight: Float32Array,
+  sampleRate?: number,
+  params?: MasteringProcessorParams,
+): MasteringStereoResult;
+export function masteringPairProcessStereo(
+  processorName: StereoPairProcessor | MasteringPairProcessStereoRequest,
+  sourceLeft?: Float32Array,
+  sourceRight?: Float32Array,
+  referenceLeft?: Float32Array,
+  referenceRight?: Float32Array,
+  sampleRate = 22050,
+  params: MasteringProcessorParams = {},
+): MasteringStereoResult {
+  const request =
+    typeof processorName === 'string'
+      ? {
+          processorName,
+          sourceLeft: sourceLeft as Float32Array,
+          sourceRight: sourceRight as Float32Array,
+          referenceLeft: referenceLeft as Float32Array,
+          referenceRight: referenceRight as Float32Array,
+          sampleRate,
+          params,
+        }
+      : processorName;
+  if (request.sourceLeft.length !== request.sourceRight.length) {
+    throw new Error('Source left and right channel lengths must match.');
+  }
+  if (request.referenceLeft.length !== request.referenceRight.length) {
+    throw new Error('Reference left and right channel lengths must match.');
+  }
+  return requireModule().masteringPairProcessStereo(
+    request.processorName,
+    request.sourceLeft,
+    request.sourceRight,
+    request.referenceLeft,
+    request.referenceRight,
+    request.sampleRate ?? 22050,
+    request.params ?? {},
+  );
+}
+
 /**
  * Analyze a `source` against a `reference` with a two-input analysis. The two
  * buffers may have independent lengths.
@@ -616,6 +692,25 @@ export function masteringAbMatchLoudness(
   );
 }
 
+/** Gain-match a stereo source to a stereo reference with one shared gain. */
+export function masteringAbMatchLoudnessStereo(
+  request: MasteringAbMatchLoudnessStereoRequest,
+): LoudnessMatchStereoResult {
+  if (request.sourceLeft.length !== request.sourceRight.length) {
+    throw new Error('Source left and right channel lengths must match.');
+  }
+  if (request.referenceLeft.length !== request.referenceRight.length) {
+    throw new Error('Reference left and right channel lengths must match.');
+  }
+  return requireModule().masteringAbMatchLoudnessStereo(
+    request.sourceLeft,
+    request.sourceRight,
+    request.referenceLeft,
+    request.referenceRight,
+    request.sampleRate ?? 22050,
+  );
+}
+
 export function masteringStereoAnalyze(request: MasteringStereoAnalyzeRequest): string;
 export function masteringStereoAnalyze(
   analysisName: StereoAnalysis,

package/src/mixer.ts

@@ -188,50 +188,70 @@ export class Mixer {
    * after {@link delete}.
    */
   createRealtimeBuffer(): MixerRealtimeBuffer {
-    const stripCount = this.stripCount();
-    let leftInputs: Float32Array[] = [];
-    let rightInputs: Float32Array[] = [];
+    const leftInputs: Float32Array[] = [];
+    const rightInputs: Float32Array[] = [];
     let outLeft = this.mixer.outputLeftView();
     let outRight = this.mixer.outputRightView();
+    let acquiredStripCount = -1;
+
+    // Every view shares one heap buffer, so a growth detaches the output views too.
+    const viewsDetached = (): boolean => outLeft.byteLength === 0 || outRight.byteLength === 0;
+
     const acquire = (): void => {
-      leftInputs = [];
-      rightInputs = [];
-      for (let index = 0; index < stripCount; index++) {
+      const stripCount = this.stripCount();
+      const detached = viewsDetached();
+      if (detached) {
+        // A heap growth detached every view: reacquire all planes.
+        leftInputs.length = 0;
+        rightInputs.length = 0;
+      } else {
+        // Topology growth keeps existing planes in place: append views for new strips only.
+        leftInputs.length = Math.min(leftInputs.length, stripCount);
+        rightInputs.length = Math.min(rightInputs.length, stripCount);
+      }
+      for (let index = leftInputs.length; index < stripCount; index++) {
         leftInputs.push(this.mixer.inputLeftView(index));
+      }
+      for (let index = rightInputs.length; index < stripCount; index++) {
         rightInputs.push(this.mixer.inputRightView(index));
       }
-      outLeft = this.mixer.outputLeftView();
-      outRight = this.mixer.outputRightView();
+      if (detached) {
+        outLeft = this.mixer.outputLeftView();
+        outRight = this.mixer.outputRightView();
+      }
+      acquiredStripCount = stripCount;
     };
     acquire();
+
     // The cached heap views can detach if WASM linear memory grows (the embind
-    // module is built ALLOW_MEMORY_GROWTH). Re-acquire them if detached
-    // (byteLength === 0) before use, mirroring the worklet RT path.
-    const reacquireIfDetached = (): void => {
-      if (outLeft.byteLength === 0 || (leftInputs[0]?.byteLength ?? 1) === 0) {
+    // module is built ALLOW_MEMORY_GROWTH). Also refresh the view list when a
+    // caller adds a strip and recompiles the graph after this buffer was made.
+    const acquireIfNeeded = (): void => {
+      if (acquiredStripCount !== this.stripCount() || viewsDetached()) {
         acquire();
       }
     };
     return {
       get leftInputs(): Float32Array[] {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return leftInputs;
       },
       get rightInputs(): Float32Array[] {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return rightInputs;
       },
       get outLeft(): Float32Array {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outLeft;
       },
       get outRight(): Float32Array {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outRight;
       },
-      process: (numSamples = outLeft.length) => {
-        reacquireIfDetached();
-        this.mixer.processPreparedStereo(numSamples);
+      process: (numSamples?: number) => {
+        acquireIfNeeded();
+        // Resolve the default only after reacquiring: a detached view reports length 0.
+        this.mixer.processPreparedStereo(numSamples ?? outLeft.length);
       },
     };
   }

package/src/project_types.ts

@@ -532,7 +532,7 @@ export interface MidiCcLearnOptions {
   minValue?: number;
   /** Upper end of the mapped parameter range. Default `1`. */
   maxValue?: number;
-  /** Minimum normalized CC movement required to learn a binding. Default `0`. */
+  /** Activity threshold in 7-bit CC units (integer 0-127) a controller must move to be learned. Default `0`. */
   minMovement?: number;
 }
 
@@ -630,12 +630,14 @@ export interface TranscribeOptions {
    */
   referenceHz?: number;
   /**
-   * Monophonic tracker range in Hz. Defaults `65` and `2093`; both must be
-   * finite and positive, and `fmax` must exceed `fmin`. The polyphonic chain
-   * sets its own range and reads neither.
+   * F0 tracker range in Hz. Both paths use these bounds; the polyphonic path
+   * applies them to the salience estimator's F0 axis while its cent-spectrum
+   * bounds remain independent. When omitted, the monophonic defaults are `65`
+   * and `2093`, while the polyphonic defaults are `55` and `1760`. Explicit
+   * values must be finite and positive, and `fmax` must exceed `fmin`.
    */
   fmin?: number;
-  /** Upper end of the monophonic tracker range in Hz. Default `2093`. */
+  /** Upper end of the F0 tracker range in Hz; omitted defaults to `2093` mono or `1760` poly. */
   fmax?: number;
   /** Shortest span kept as a note, in milliseconds. Default `30`; must be positive. */
   minNoteMs?: number;

package/src/public_types_mastering.ts

@@ -80,6 +80,7 @@ export const SOLO_PROCESSORS = [
   'effects.acoustic.roomMorph',
   'effects.delay.stereo',
   'effects.filter.vowel',
+  'effects.gsEfx',
   'effects.modulation.autoWah',
   'effects.modulation.chorus',
   'effects.modulation.ensemble',
@@ -162,6 +163,9 @@ export type PairProcessor =
   | 'match.abSwitch'
   | 'match.abCrossfade';
 
+/** Pair processors with a stereo entry point. */
+export type StereoPairProcessor = 'match.abCrossfade';
+
 export type PairAnalysis =
   | 'match.referenceLoudness'
   | 'match.tonalBalance'
@@ -213,6 +217,23 @@ export interface LoudnessMatchResult {
   matchedTruePeakDbtp: number;
 }
 
+/** Stereo counterpart of {@link LoudnessMatchResult}. */
+export interface LoudnessMatchStereoResult {
+  /** The left source channel, gain-matched to the reference loudness. */
+  left: Float32Array;
+  /** The right source channel, gain-matched with the same gain as `left`. */
+  right: Float32Array;
+  sampleRate: number;
+  /** The reference program's BS.1770 integrated loudness. */
+  referenceLufs: number;
+  /** The stereo source program's loudness before the gain. */
+  sourceLufs: number;
+  /** One gain applied to both source channels, in dB. */
+  appliedGainDb: number;
+  /** Maximum true peak across the matched left and right channels, in dBTP. */
+  matchedTruePeakDbtp: number;
+}
+
 /**
  * Mastering loudness/true-peak processing result
  */

package/src/public_types_playback.ts

@@ -158,6 +158,7 @@ export interface PlaybackDiagnostics {
   loudness_gain_clamped: boolean;
   /** True when an `hrtf` was supplied to a speakers target, which ignores it. */
   hrtf_ignored: boolean;
+  /** Deepest last-block gain reduction across the main and LFE limiters, in dB (<= 0). */
   limiter_gain_reduction_db: number;
   non_finite_discards: number;
 }

package/src/public_types_spectral.ts

@@ -34,10 +34,10 @@ export interface PitchCorrectOptions extends ValidateOptions {
   retuneSpeedMs?: number;
   /** Corrections below this are bypassed to preserve vibrato (cents). Default 20. */
   vibratoThresholdCents?: number;
-  /** Per-frame voiced flags (truthy = voiced); omit to treat all frames as voiced. */
-  voiced?: VoicedFlags;
-  /** Per-frame voicing probability in `[0, 1]`; omit to derive from `voiced`. */
-  voicedProb?: Float32Array;
+  /** Per-frame voiced flags (truthy = voiced); when supplied, these take precedence over `voicedProb`. Omit or pass `null` to use `voicedProb`; with neither, all frames are treated as voiced. */
+  voiced?: VoicedFlags | null;
+  /** Per-frame voicing probability in `[0, 1]`; used only when `voiced` is omitted or `null`, and ignored when flags are supplied. */
+  voicedProb?: Float32Array | null;
 }
 
 /** Options for `noteStretch`. All fields are optional. */
@@ -68,7 +68,7 @@ export interface NoteExtractorOptions {
   referenceHz?: number;
   /**
    * Value of `voicedProb` at or above which a frame counts as voiced, in
-   * `[0, 1]`. Read only when `voiced` is omitted. Default 0.5.
+   * `[0, 1]`. Read only when `voiced` is omitted or `null`. Default 0.5.
    *
    * pYIN's `voicedProb` is a frame's voiced observation mass and rises with F0
    * for a fixed frame length, so this default silently drops low registers —

package/src/realtime_engine.ts

@@ -29,6 +29,7 @@ import type {
   WasmEngineAutomationPoint,
   WasmEngineBounceOptions,
   WasmEngineBounceResult,
+  WasmEngineBus,
   WasmEngineCaptureStatus,
   WasmEngineClip,
   WasmEngineFreezeOptions,
@@ -44,6 +45,7 @@ import type {
   WasmEngineTelemetry,
   WasmEngineTempoSegment,
   WasmEngineTimeSignatureSegment,
+  WasmEngineTrackSend,
   WasmEngineTransportState,
   WasmExternalMidiEvent,
   WasmRealtimeEngine,
@@ -626,7 +628,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 +888,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 +919,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 +976,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 +1006,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 +1117,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 +1131,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,
+        };
       }),
     );
   }
@@ -1116,10 +1154,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 +1396,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);
@@ -1757,6 +1806,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,9 +1823,10 @@ 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[] {

package/src/sonare.js.d.ts

@@ -829,6 +829,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 +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 {
@@ -1165,6 +1172,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 +1210,8 @@ export interface WasmEngineMeterTelemetryWide {
   shortTermLufs: number;
   integratedLufs: number;
   gainReductionDb: number;
+  /** Pre-trim input peak for each valid plane, in dBFS. */
+  inputPeakDb: number[];
   droppedRecords: number;
 }
 
@@ -1363,6 +1376,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;
@@ -1707,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;
@@ -2329,12 +2346,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 +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,
@@ -3521,6 +3556,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();