@libraz/libsonare 1.7.2 → 1.8.1

package/src/mastering_core.ts

@@ -1,5 +1,11 @@
+import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
 import type {
+  LoudnessMatchResult,
+  LoudnessMatchStereoResult,
+  MasteringAssistantParams,
+  MasteringInsertParamChoice,
+  MasteringInsertSlot,
   MasteringOptions,
   MasteringProcessorParams,
   MasteringResult,
@@ -8,9 +14,12 @@ import type {
   PairProcessor,
   SoloProcessor,
   StereoAnalysis,
+  StereoPairProcessor,
   StreamingPlatform,
 } from './public_types';
 
+export type { MasteringInsertParamChoice, MasteringInsertSlot };
+
 function requireModule() {
   return getSonareModule();
 }
@@ -45,6 +54,35 @@ 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. */
+  source: Float32Array;
+  /** The take whose loudness `source` is matched to; returned untouched. */
+  reference: Float32Array;
+  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;
@@ -70,6 +108,13 @@ export interface MasteringSamplesParamsRequest {
   params?: MasteringProcessorParams;
 }
 
+/** Canonical request form for the assistant, whose params carry a target platform. */
+export interface MasteringAssistantParamsRequest {
+  samples: Float32Array;
+  sampleRate?: number;
+  params?: MasteringAssistantParams;
+}
+
 /** Canonical request form for streaming-platform preview. */
 export interface MasteringStreamingPreviewRequest {
   samples: Float32Array;
@@ -85,6 +130,14 @@ export interface MasteringStereoParamsRequest {
   params?: MasteringProcessorParams;
 }
 
+/** Stereo counterpart of {@link MasteringAssistantParamsRequest}. */
+export interface MasteringAssistantStereoParamsRequest {
+  left: Float32Array;
+  right: Float32Array;
+  sampleRate?: number;
+  params?: MasteringAssistantParams;
+}
+
 /** Canonical request form for the stereo streaming-platform preview. */
 export interface MasteringStreamingPreviewStereoRequest {
   left: Float32Array;
@@ -137,9 +190,7 @@ export function masteringProcessorNames(): SoloProcessor[] {
  * `sonare_mastering_insert_names` (which joins this list) as a `string[]`.
  */
 export function masteringInsertNames(): string[] {
-  return (
-    requireModule() as unknown as { masteringInsertNames: () => string[] }
-  ).masteringInsertNames();
+  return requireModule().masteringInsertNames();
 }
 
 /**
@@ -153,43 +204,165 @@ export function masteringInsertNames(): string[] {
  * @param name - Insert processor name (see {@link masteringInsertNames}).
  */
 export function masteringInsertParamNames(name: string): string[] {
-  return Array.from(
-    (
-      requireModule() as unknown as { masteringInsertParamNames: (name: string) => string[] }
-    ).masteringInsertParamNames(name),
-  );
+  return Array.from(requireModule().masteringInsertParamNames(name));
 }
 
-/** One realtime-automatable parameter of an insert processor. */
+/**
+ * One parameter an insert processor's construction reads, whether or not it
+ * is realtime-automatable.
+ */
 export interface MasteringInsertParamInfo {
   /** JSON-key parameter name, as used in scene insert params. */
   name: string;
-  /** Integer param id for realtime automation lanes / MIDI-CC binding. */
-  id: number;
-  /** Whether the param can be changed live from the audio thread. */
+  /**
+   * Integer param id for realtime automation lanes / MIDI-CC binding, or null
+   * for a construction-only key with no automation target.
+   */
+  id: number | null;
+  /** Whether the param can be changed live from the audio thread; false when `id` is null. */
   rtSafe: boolean;
-  /** Physical unit when the parameter is not unitless. */
-  unit?: string;
+  /**
+   * The C++ type the processor's config builder reads the key as. `"enum"` is
+   * sent as the number in its `choices` entry; `"string"` / `"array"` (an
+   * embedded impulse response, a per-band list) is construction-only and
+   * reports null for `min`, `max`, `default` and `choices`.
+   */
+  type: 'boolean' | 'number' | 'enum' | 'string' | 'array';
+  /**
+   * Smallest value construction accepts, or null when the catalog states no
+   * limit or `choices` is non-null. Measured, so it is a hard constraint
+   * rather than a UI range; see {@link CapabilityCatalogParameter} for what a
+   * measured bound does and does not promise.
+   */
+  min: number | null;
+  /** Largest value construction accepts, or null when the catalog states no limit or `choices` is non-null. */
+  max: number | null;
+  /**
+   * Value the processor uses when the key is absent — the config struct's own
+   * field initializer, an enum as its number. Null for a param id with no
+   * construction key, a `"string"` / `"array"` key, or a construction key with
+   * no fallback.
+   */
+  default: boolean | number | null;
+  /** Physical unit, or null when the parameter is unitless. */
+  unit: string | null;
+  /**
+   * The closed set of values construction accepts, in value order, or null
+   * when the accepted values are not a closed set. Non-null only for `"enum"`
+   * (every declared enumerator construction accepts) or a `"number"` key
+   * whose accepted integers have holes; `min` / `max` are then both null.
+   */
+  choices: MasteringInsertParamChoice[] | null;
+  /**
+   * The {@link MasteringInsertSlot} this key belongs to, or null for a key that
+   * always exists.
+   */
+  slot: string | null;
 }
 
 /**
- * Returns the realtime-automatable parameter descriptors for an insert / FX
- * processor: each entry maps a JSON-key parameter name to the integer id used by
- * realtime automation and reports whether it is realtime-safe. Unlike
- * {@link masteringInsertParamNames} (every construction key), this lists only the
- * realtime-controllable subset — the keys accepted by
- * {@link RealtimeEngine.setTrackStripInsertParamByName}. Returns an empty array
- * for an unknown name or a processor with no automatable parameters.
+ * Returns every parameter an insert / FX processor's construction reads,
+ * including construction-time-only keys with no realtime automation target.
+ * Entries come in two runs: first the processor's realtime automation
+ * targets in id order (the keys accepted by
+ * {@link RealtimeEngine.setTrackStripInsertParamByName}, `id` non-null); then,
+ * sorted by name, every other construction key with `id` null and `rtSafe`
+ * false. The name set matches {@link masteringInsertParamNames} plus any
+ * automation target construction does not read. Returns an empty array for an
+ * unknown name.
  *
  * @param name - Insert processor name (see {@link masteringInsertNames}).
  */
 export function masteringInsertParamInfo(name: string): MasteringInsertParamInfo[] {
-  const json = (
-    requireModule() as unknown as { masteringInsertParamInfo: (name: string) => string }
-  ).masteringInsertParamInfo(name);
+  const json = requireModule().masteringInsertParamInfo(name);
   return JSON.parse(json) as MasteringInsertParamInfo[];
 }
 
+/** Latency and tail of one insert instance, in samples. */
+export interface MasteringInsertTiming {
+  /** Latency in samples at the queried sample rate. */
+  latencySamples: number;
+  /** Audible decay tail in samples at the queried sample rate. */
+  tailSamples: number;
+}
+
+/** One built-in amp-sim rig with its resolved starting configuration. */
+export interface MasteringAmpPresetCatalogEntry {
+  /** Stable index used by the amp-sim `presetIndex` parameter. */
+  index: number;
+  /** Canonical preset identifier accepted by the amp-sim insert. */
+  name: string;
+  /** Effective values from the core preset, before sparse user overrides. */
+  params: Record<string, number | boolean>;
+}
+
+/**
+ * Returns the built-in amp-sim rigs and their resolved control values.
+ *
+ * The catalog is read-only metadata for hosts such as Studio. Persist only the
+ * preset index and explicit overrides in a project so future core updates can
+ * continue to define the canonical DSP configuration.
+ */
+export function masteringAmpPresetCatalog(): MasteringAmpPresetCatalogEntry[] {
+  const json = requireModule().masteringAmpPresetCatalog();
+  return JSON.parse(json) as MasteringAmpPresetCatalogEntry[];
+}
+
+/**
+ * Reject a `params` value {@link masteringInsertTiming} cannot serialize:
+ * anything other than a finite number or a boolean, naming the offending key.
+ * Booleans serialize as JSON booleans, not 0/1, since the C++ reader accepts
+ * `is_bool` alongside a number.
+ */
+function insertTimingParamsToJson(fnName: string, params: Record<string, number | boolean>) {
+  const out: Record<string, number | boolean> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === 'boolean') {
+      out[key] = value;
+      continue;
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+      throw new SonareError(
+        ErrorCode.InvalidParameter,
+        'InvalidParameter',
+        `${fnName}: params.${key} must be a finite number or boolean`,
+      );
+    }
+    out[key] = value;
+  }
+  return JSON.stringify(out);
+}
+
+/**
+ * Latency and tail of insert `name` built from `params` and prepared at
+ * `sampleRate` (`mastering::api::insert_timing`). Answers for the exact
+ * instance a scene or strip would build — an oversampled saturation path, a
+ * linear-phase crossover, a lookahead all change the reported latency. The
+ * capability catalog's `latencySamples` / `tailSamples` are this query at
+ * default parameters and 48 kHz. `effects.reverb.convolution` answers for its
+ * configuration without an impulse response: its latency is its fixed
+ * partition size and does not depend on one.
+ *
+ * A key `name`'s construction does not read is refused rather than ignored,
+ * because an ignored key would answer for a configuration the caller did not
+ * ask for.
+ *
+ * @param name - Insert processor name (see {@link masteringInsertNames}).
+ * @param params - Flat parameter values, keyed as in {@link masteringInsertParamInfo}.
+ * @param sampleRate - Rate the insert is prepared at.
+ * @throws For an unknown `name`, a key the insert does not read, a value its
+ *   construction or `prepare` refuses, or a `params` value that is not a
+ *   finite number or boolean.
+ */
+export function masteringInsertTiming(
+  name: string,
+  params: Record<string, number | boolean>,
+  sampleRate: number,
+): MasteringInsertTiming {
+  const json = insertTimingParamsToJson('masteringInsertTiming', params);
+  return requireModule().masteringInsertTiming(name, json, sampleRate);
+}
+
 /**
  * How a processor handles a buffer with more than two channels (a surround
  * bed). "multichannel" processes every plane in one call; "stereoPairOnly"
@@ -205,6 +378,25 @@ export type MasteringChannelPolicy =
 /** Coarse algorithmic work estimate for a realtime insert; not a benchmark. */
 export type MasteringRealtimeCost = 'low' | 'moderate' | 'high';
 
+/**
+ * Catalog grouping for a processor picker, derived from the id's prefix
+ * ("eq.*" -> "eq", "match.*" -> "reference"); anything unprefixed is "other".
+ */
+export type MasteringProcessorCategory =
+  | 'dynamics'
+  | 'effects'
+  | 'eq'
+  | 'final'
+  | 'maximizer'
+  | 'multiband'
+  | 'other'
+  | 'reference'
+  | 'repair'
+  | 'saturation'
+  | 'spectral'
+  | 'stereo'
+  | 'utility';
+
 /** One processor's realtime/offline/pair classification in the catalog. */
 export interface MasteringProcessorCatalogEntry {
   /** Processor id (the name used for scene inserts / named processors). */
@@ -237,6 +429,19 @@ export interface MasteringProcessorCatalogEntry {
    * surround planes passed through dry).
    */
   channelPolicy: MasteringChannelPolicy;
+  /** Grouping for a processor picker; see {@link MasteringProcessorCategory}. */
+  category: MasteringProcessorCategory;
+  /**
+   * The processor's construction parameters, the same list
+   * {@link masteringInsertParamInfo} returns. Empty for entries that are not
+   * realtime-insertable.
+   */
+  params: MasteringInsertParamInfo[];
+  /**
+   * The insert's conditional key groups in declaration order, named by each
+   * parameter's `slot`. Empty for entries that are not realtime-insertable.
+   */
+  slots: MasteringInsertSlot[];
 }
 
 /**
@@ -246,9 +451,7 @@ export interface MasteringProcessorCatalogEntry {
  * instead of offering ids the realtime strip would reject.
  */
 export function masteringProcessorCatalog(): MasteringProcessorCatalogEntry[] {
-  const json = (
-    requireModule() as unknown as { masteringProcessorCatalog: () => string }
-  ).masteringProcessorCatalog();
+  const json = requireModule().masteringProcessorCatalog();
   return JSON.parse(json) as MasteringProcessorCatalogEntry[];
 }
 
@@ -367,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.
@@ -405,6 +662,55 @@ export function masteringPairAnalyze(
   );
 }
 
+/**
+ * Gain-match `source` to `reference`'s integrated loudness, so an A/B between
+ * the two is not decided by level. `source` and `reference` may have
+ * independent lengths.
+ *
+ * The gain is applied with no upper bound and `matchedTruePeakDbtp` reports
+ * where that left the peak, rather than the call capping it: a headroom clamp
+ * would return `source` at its own loudness whenever it started near full
+ * scale. Both loudness values are non-finite for a silent or below-gate take,
+ * and `appliedGainDb` is then 0.
+ *
+ * @example
+ * ```ts
+ * const { samples, appliedGainDb, matchedTruePeakDbtp } = masteringAbMatchLoudness({
+ *   source: take,
+ *   reference: master,
+ *   sampleRate: 48000,
+ * });
+ * ```
+ */
+export function masteringAbMatchLoudness(
+  request: MasteringAbMatchLoudnessRequest,
+): LoudnessMatchResult {
+  return requireModule().masteringAbMatchLoudness(
+    request.source,
+    request.reference,
+    request.sampleRate ?? 22050,
+  );
+}
+
+/** 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,
@@ -439,16 +745,16 @@ export function masteringStereoAnalyze(
   );
 }
 
-export function masteringAssistantSuggest(request: MasteringSamplesParamsRequest): string;
+export function masteringAssistantSuggest(request: MasteringAssistantParamsRequest): string;
 export function masteringAssistantSuggest(
   samples: Float32Array,
   sampleRate?: number,
-  params?: MasteringProcessorParams,
+  params?: MasteringAssistantParams,
 ): string;
 export function masteringAssistantSuggest(
-  samples: Float32Array | MasteringSamplesParamsRequest,
+  samples: Float32Array | MasteringAssistantParamsRequest,
   sampleRate = 22050,
-  params: MasteringProcessorParams = {},
+  params: MasteringAssistantParams = {},
 ): string {
   const request = samples instanceof Float32Array ? { samples, sampleRate, params } : samples;
   return requireModule().masteringAssistantSuggest(
@@ -458,6 +764,91 @@ export function masteringAssistantSuggest(
   );
 }
 
+/**
+ * Suggest a mastering chain, as the flat `{key: number|boolean}` params map
+ * {@link masteringAssistantSuggest}'s `chainConfig` carries, without needing to
+ * pull it out of the full assistant document. The returned map can be passed
+ * straight through as `overrides` to {@link mastering} / {@link masterAudio}.
+ */
+export function masteringAssistantSuggestChain(
+  request: MasteringAssistantParamsRequest,
+): Record<string, number | boolean> {
+  return requireModule().masteringAssistantSuggestChain(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.params ?? {},
+  );
+}
+
+/**
+ * The shape {@link masteringAudioProfile}'s JSON parses to.
+ *
+ * The profile crosses as a string, so nothing type-checks it on arrival; this
+ * declaration is what a conformance check compares against the paths the C++
+ * writer publishes, so a field added on one side and not the other fails there
+ * rather than reaching a caller as `undefined`.
+ */
+export interface MasteringAudioProfile {
+  durationSec: number;
+  bpm: number;
+  bpmConfidence: number;
+  loudness: {
+    integratedLufs: number;
+    lraLu: number;
+    truePeakDb: number;
+    crestFactorDb: number;
+  };
+  spectral: {
+    subRmsDb: number;
+    lowRmsDb: number;
+    lowMidRmsDb: number;
+    midRmsDb: number;
+    highMidRmsDb: number;
+    highRmsDb: number;
+    airRmsDb: number;
+    centroidHz: number;
+    flatness: number;
+    rolloffHz: number;
+  };
+  dynamics: {
+    shortTermLufsStd: number;
+    attackDensity: number;
+    sustainRatio: number;
+  };
+  /**
+   * What the repair detectors measured. `measured` is false when nothing ran —
+   * either `detectDefects` was not asked for or the input was too short — and
+   * every other field is then at its default rather than a reading.
+   */
+  defects: {
+    measured: boolean;
+    clickCount: number;
+    clickRejected: number;
+    clickLongestRunSamples: number;
+    clickPerSecond: number;
+    crackleSampleCount: number;
+    crackleSampleFraction: number;
+    cracklePerSecond: number;
+    clipSampleCount: number;
+    clipRunCount: number;
+    clipLongestRunSamples: number;
+    clipSampleFraction: number;
+    clipFlatRunCount: number;
+    clipFlatSampleCount: number;
+    clipLongestFlatRunSamples: number;
+    clipFlatLevel: number;
+    noiseFloorDbfs: number;
+    noiseBandPeakDbfs: number;
+    noiseBandPeakIndex: number;
+    humFundamentalHz: number;
+    humFundamentalProminence: number;
+    humHarmonics: number;
+    humFundamentalDbfs: number;
+    humPeakHarmonicDbfs: number;
+    lateDecayRatioDb: number;
+  };
+}
+
 export function masteringAudioProfile(request: MasteringSamplesParamsRequest): string;
 export function masteringAudioProfile(
   samples: Float32Array,
@@ -503,7 +894,9 @@ export function masteringStreamingPreview(
  * of the suggestion is built on the channel-summed program rather than a
  * downmix that reads roughly 6 dB low.
  */
-export function masteringAssistantSuggestStereo(request: MasteringStereoParamsRequest): string {
+export function masteringAssistantSuggestStereo(
+  request: MasteringAssistantStereoParamsRequest,
+): string {
   return requireModule().masteringAssistantSuggestStereo(
     request.left,
     request.right,
@@ -512,6 +905,22 @@ export function masteringAssistantSuggestStereo(request: MasteringStereoParamsRe
   );
 }
 
+/**
+ * Stereo counterpart of {@link masteringAssistantSuggestChain}: the flat
+ * `{key: number|boolean}` params map without the surrounding assistant
+ * document, ready to pass through as `overrides` to {@link masterAudioStereo}.
+ */
+export function masteringAssistantSuggestChainStereo(
+  request: MasteringAssistantStereoParamsRequest,
+): Record<string, number | boolean> {
+  return requireModule().masteringAssistantSuggestChainStereo(
+    request.left,
+    request.right,
+    request.sampleRate ?? 22050,
+    request.params ?? {},
+  );
+}
+
 /**
  * Mastering assistant profile of a stereo pair, as shared JSON.
  *

package/src/mastering_dynamics.ts

@@ -72,8 +72,17 @@ export interface MasteringDynamicsTransientShaperRequest extends TransientShaper
   sampleRate: number;
 }
 
-/** Result envelope returned by offline mastering dynamics processors. */
-export interface DynamicsResult {
+/**
+ * Result envelope returned by offline mastering dynamics processors.
+ *
+ * Named for what it is rather than for the module it lives in. {@link
+ * DynamicsResult} is the *analysis* shape on every binding, so having that one
+ * identifier mean two disjoint field lists across the Node and WASM packages
+ * made a shared TypeScript module type-check against one and fail against the
+ * other — with the identifier resolving either way, so only the member list
+ * gave it away.
+ */
+export interface DynamicsProcessorResult {
   samples: Float32Array;
   latencySamples: number;
 }
@@ -87,17 +96,17 @@ const COMPRESSOR_DETECTOR_MAP: Record<CompressorDetector, number> = {
 /** Offline feed-forward compressor (soft knee, optional auto-makeup / sidechain HPF). */
 export function masteringDynamicsCompressor(
   request: MasteringDynamicsCompressorRequest,
-): DynamicsResult;
+): DynamicsProcessorResult;
 export function masteringDynamicsCompressor(
   samples: Float32Array,
   sampleRate: number,
   options?: CompressorOptions,
-): DynamicsResult;
+): DynamicsProcessorResult;
 export function masteringDynamicsCompressor(
   samples: Float32Array | MasteringDynamicsCompressorRequest,
   sampleRate?: number,
   options: CompressorOptions = {},
-): DynamicsResult {
+): DynamicsProcessorResult {
   const request =
     samples instanceof Float32Array
       ? { samples, sampleRate: sampleRate as number, ...options }
@@ -121,17 +130,19 @@ export function masteringDynamicsCompressor(
 }
 
 /** Offline noise gate (hysteresis, hold, optional key HPF). */
-export function masteringDynamicsGate(request: MasteringDynamicsGateRequest): DynamicsResult;
+export function masteringDynamicsGate(
+  request: MasteringDynamicsGateRequest,
+): DynamicsProcessorResult;
 export function masteringDynamicsGate(
   samples: Float32Array,
   sampleRate: number,
   options?: GateOptions,
-): DynamicsResult;
+): DynamicsProcessorResult;
 export function masteringDynamicsGate(
   samples: Float32Array | MasteringDynamicsGateRequest,
   sampleRate?: number,
   options: GateOptions = {},
-): DynamicsResult {
+): DynamicsProcessorResult {
   const request =
     samples instanceof Float32Array
       ? { samples, sampleRate: sampleRate as number, ...options }
@@ -143,17 +154,17 @@ export function masteringDynamicsGate(
 /** Offline transient shaper (envelope-difference attack/sustain control). */
 export function masteringDynamicsTransientShaper(
   request: MasteringDynamicsTransientShaperRequest,
-): DynamicsResult;
+): DynamicsProcessorResult;
 export function masteringDynamicsTransientShaper(
   samples: Float32Array,
   sampleRate: number,
   options?: TransientShaperOptions,
-): DynamicsResult;
+): DynamicsProcessorResult;
 export function masteringDynamicsTransientShaper(
   samples: Float32Array | MasteringDynamicsTransientShaperRequest,
   sampleRate?: number,
   options: TransientShaperOptions = {},
-): DynamicsResult {
+): DynamicsProcessorResult {
   const request =
     samples instanceof Float32Array
       ? { samples, sampleRate: sampleRate as number, ...options }