@libraz/libsonare 1.5.3 → 1.5.5

package/src/feature_spectrogram.ts

@@ -34,6 +34,7 @@ export interface ChromaSpectrogramRequest extends GuardedOptions {
   sampleRate?: number;
   hopLength?: number;
   nChroma?: number;
+  binsPerOctave?: number;
 }
 
 export interface MelSpectrogramRequest extends SpectrogramRequest {
@@ -53,6 +54,8 @@ export interface MfccToMelRequest extends GuardedOptions {
   nMfcc: number;
   nFrames: number;
   nMels?: number;
+  /** Lifter used by the forward MFCC transform; zero means no liftering. */
+  lifter?: number;
 }
 
 /** Canonical request form for reconstruction from a Mel power spectrogram. */
@@ -262,6 +265,7 @@ export function chromaCens(
   sampleRate?: number,
   hopLength?: number,
   nChroma?: number,
+  binsPerOctave?: number,
   options?: GuardedOptions,
 ): ChromaResult;
 export function chromaCens(
@@ -269,6 +273,7 @@ export function chromaCens(
   sampleRate = 22050,
   hopLength = 512,
   nChroma = 12,
+  binsPerOctave = 36,
   options: GuardedOptions = {},
 ): ChromaResult {
   if (!(samples instanceof Float32Array)) {
@@ -278,12 +283,16 @@ export function chromaCens(
       request.sampleRate,
       request.hopLength,
       request.nChroma,
+      request.binsPerOctave,
       request,
     );
   }
   validateSpectrogramSamples('chromaCens', samples, sampleRate, options);
-  validatePositiveIntegers('chromaCens', { hopLength, nChroma });
-  return requireModule().chromaCens(samples, sampleRate, hopLength, nChroma);
+  validatePositiveIntegers('chromaCens', { hopLength, nChroma, binsPerOctave });
+  if (binsPerOctave % nChroma !== 0) {
+    throw new RangeError('chromaCens: binsPerOctave must be a multiple of nChroma');
+  }
+  return requireModule().chromaCens(samples, sampleRate, hopLength, nChroma, binsPerOctave);
 }
 
 /**
@@ -301,6 +310,7 @@ export function chromaCqt(
   sampleRate?: number,
   hopLength?: number,
   nChroma?: number,
+  binsPerOctave?: number,
   options?: GuardedOptions,
 ): ChromaResult;
 export function chromaCqt(
@@ -308,6 +318,7 @@ export function chromaCqt(
   sampleRate = 22050,
   hopLength = 512,
   nChroma = 12,
+  binsPerOctave = 36,
   options: GuardedOptions = {},
 ): ChromaResult {
   if (!(samples instanceof Float32Array)) {
@@ -317,12 +328,16 @@ export function chromaCqt(
       request.sampleRate,
       request.hopLength,
       request.nChroma,
+      request.binsPerOctave,
       request,
     );
   }
   validateSpectrogramSamples('chromaCqt', samples, sampleRate, options);
-  validatePositiveIntegers('chromaCqt', { hopLength, nChroma });
-  return requireModule().chromaCqt(samples, sampleRate, hopLength, nChroma);
+  validatePositiveIntegers('chromaCqt', { hopLength, nChroma, binsPerOctave });
+  if (binsPerOctave % nChroma !== 0) {
+    throw new RangeError('chromaCqt: binsPerOctave must be a multiple of nChroma');
+  }
+  return requireModule().chromaCqt(samples, sampleRate, hopLength, nChroma, binsPerOctave);
 }
 
 /**
@@ -664,6 +679,7 @@ export function mfccToMel(
   nMfcc: number,
   nFrames: number,
   nMels?: number,
+  lifter?: number,
   options?: GuardedOptions,
 ): MelPowerResult;
 export function mfccToMel(
@@ -671,6 +687,7 @@ export function mfccToMel(
   nMfcc = 0,
   nFrames = 0,
   nMels = 128,
+  lifter = 0,
   options: GuardedOptions = {},
 ): MelPowerResult {
   if (!(mfccCoefficients instanceof Float32Array)) {
@@ -680,6 +697,7 @@ export function mfccToMel(
       request.nMfcc,
       request.nFrames,
       request.nMels,
+      request.lifter,
       request,
     );
   }
@@ -693,7 +711,7 @@ export function mfccToMel(
     options,
   );
   validatePositiveIntegers('mfccToMel', { nMels });
-  return requireModule().mfccToMel(mfccCoefficients, nMfcc, nFrames, nMels);
+  return requireModule().mfccToMel(mfccCoefficients, nMfcc, nFrames, nMels, lifter);
 }
 
 /**
@@ -726,6 +744,7 @@ export function mfccToAudio(
   fmax?: number,
   nIter?: number,
   htk?: boolean,
+  lifter?: number,
   options?: GuardedOptions,
 ): Float32Array;
 export function mfccToAudio(
@@ -740,6 +759,7 @@ export function mfccToAudio(
   fmax = 0,
   nIter = 32,
   htk = false,
+  lifter = 0,
   options: GuardedOptions = {},
 ): Float32Array {
   if (!(mfccCoefficients instanceof Float32Array)) {
@@ -756,6 +776,7 @@ export function mfccToAudio(
       request.fmax,
       request.nIter,
       request.htk,
+      request.lifter,
       request,
     );
   }
@@ -783,6 +804,7 @@ export function mfccToAudio(
     fmax,
     nIter,
     htk,
+    lifter,
   );
 }
 

package/src/index.ts

@@ -312,6 +312,7 @@ export type {
   MeteringDynamicRangeOptions,
   MeteringDynamicRangeRequest,
   MeteringSamplesRequest,
+  MeteringSilenceRatioRequest,
   MeteringSpectrumFrameRequest,
   MeteringSpectrumRequest,
   MeteringStereoDecimatedRequest,
@@ -336,6 +337,7 @@ export {
   meteringPhaseScope,
   meteringPhaseScopeDecimated,
   meteringRmsDb,
+  meteringSilenceRatio,
   meteringSpectrum,
   meteringSpectrumFrame,
   meteringStereoCorrelation,
@@ -522,6 +524,7 @@ export type {
   DetectKeyRequest,
   DynamicsAnalysisResult,
   EstimateRoomRequest,
+  MusicAnalyzeRequest,
   RhythmAnalysisResult,
   RoomMorphRequest,
   SamplesRequest,

package/src/mastering_core.ts

@@ -152,6 +152,8 @@ export interface MasteringInsertParamInfo {
   id: number;
   /** Whether the param can be changed live from the audio thread. */
   rtSafe: boolean;
+  /** Physical unit when the parameter is not unitless. */
+  unit?: string;
 }
 
 /**

package/src/metering.ts

@@ -128,6 +128,43 @@ export function meteringRmsDb(
   return requireModule().meteringRmsDb(request.samples, request.sampleRate ?? 22050);
 }
 
+export interface MeteringSilenceRatioRequest extends MeteringSamplesRequest {
+  thresholdDb?: number;
+  frameLength?: number;
+  hopLength?: number;
+}
+
+export function meteringSilenceRatio(request: MeteringSilenceRatioRequest): number;
+export function meteringSilenceRatio(
+  samples: Float32Array,
+  sampleRate?: number,
+  thresholdDb?: number,
+  frameLength?: number,
+  hopLength?: number,
+  options?: ValidateOptions,
+): number;
+export function meteringSilenceRatio(
+  samples: Float32Array | MeteringSilenceRatioRequest,
+  sampleRate = 22050,
+  thresholdDb = -45,
+  frameLength = 1024,
+  hopLength = 256,
+  options: ValidateOptions = {},
+): number {
+  const request =
+    samples instanceof Float32Array
+      ? { samples, sampleRate, thresholdDb, frameLength, hopLength, ...options }
+      : samples;
+  assertSamples('meteringSilenceRatio', request.samples, request.validate !== false);
+  return requireModule().meteringSilenceRatio(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.thresholdDb ?? -45,
+    request.frameLength ?? 1024,
+    request.hopLength ?? 256,
+  );
+}
+
 export function meteringCrestFactorDb(request: MeteringSamplesRequest): number;
 export function meteringCrestFactorDb(
   samples: Float32Array,
@@ -206,16 +243,20 @@ export function meteringDetectClipping(
 ): ClippingReport {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples('meteringDetectClipping', request.samples, request.validate !== false);
+  const minRegionSamples = request.minRegionSamples ?? 1;
+  if (!Number.isInteger(minRegionSamples) || minRegionSamples < 0) {
+    throw new RangeError('meteringDetectClipping: minRegionSamples must be a non-negative integer');
+  }
   return requireModule().meteringDetectClipping(
     request.samples,
     request.sampleRate ?? 22050,
     request.threshold ?? 0.999,
-    request.minRegionSamples ?? 1,
+    minRegionSamples,
   );
 }
 
 /**
- * Sliding-window dynamic range. Pass 0 for window/hop to use the library
+ * Sliding-window dynamic range for mono audio. Pass 0 for window/hop to use the library
  * default (window=3 s, hop=1 s). The percentiles use a NEGATIVE sentinel for
  * "use the library default" (low=0.10, high=0.95) because 0 is a literal 0th
  * percentile; omitted percentiles therefore default to -1.
@@ -354,7 +395,7 @@ export interface WaveformPeaksReport {
   samplesPerBucket: number;
 }
 
-/** Pearson correlation in [-1, 1] between two equal-length channels. */
+/** Uncentered correlation (cosine similarity) in [-1, 1] between equal-length channels. */
 export function meteringStereoCorrelation(request: MeteringStereoRequest): number;
 export function meteringStereoCorrelation(
   left: Float32Array,
@@ -383,8 +424,10 @@ export function meteringStereoCorrelation(
 }
 
 /**
- * Side / mid energy ratio, clamped to `[0, 2]`: 0 = pure mono, ~1 = wide
- * stereo, 2 = fully decorrelated / out-of-phase.
+ * Side / mid energy ratio in `[0, +Infinity)`: 0 = pure mono, ~1 = wide stereo,
+ * larger = increasingly decorrelated / out-of-phase. The value is unbounded and
+ * returns `Infinity` when the mid channel is silent (a mono-collapsed / fully
+ * out-of-phase signal).
  */
 export function meteringStereoWidth(request: MeteringStereoRequest): number;
 export function meteringStereoWidth(
@@ -559,7 +602,7 @@ export function meteringPhaseScopeDecimated(
 }
 
 /**
- * Welch-averaged magnitude / power / dB spectrum over the WHOLE signal (split
+ * Welch-averaged magnitude / power / dB spectrum over the WHOLE mono signal (split
  * into Hann-windowed, 50%-overlapping `nFft`-length frames whose power spectra
  * are averaged). For a true single-frame snapshot, use
  * {@link meteringSpectrumFrame}.

package/src/mixer.ts

@@ -74,7 +74,10 @@ export class Mixer {
     return new Mixer(module.createMixerFromSceneJson(json, sampleRate, blockSize), blockSize);
   }
 
-  /** Rebuild and compile the routing graph from the current scene topology. */
+  /**
+   * Rebuild and compile the routing graph without resetting its absolute
+   * automation sample position or queued strip automation.
+   */
   compile(): void {
     this.mixer.compile();
   }
@@ -261,6 +264,11 @@ export class Mixer {
     this.mixer.setVcaGroupGainDb(id, gainDb);
   }
 
+  /** Replace an existing VCA group's strip membership. */
+  setVcaGroupMembers(id: string, members: string[]): void {
+    this.mixer.setVcaGroupMembers(id, members);
+  }
+
   /** Remove a VCA group by id. */
   removeVcaGroup(id: string): void {
     this.mixer.removeVcaGroup(id);
@@ -427,6 +435,11 @@ export class Mixer {
     return this.mixer.meterTap(stripIndex, meterTapCode(tap));
   }
 
+  /** Read the post-insert meter for a compiled bus, including master. */
+  busMeter(busId: string): MixMeterSnapshot {
+    return this.mixer.busMeter(busId);
+  }
+
   /**
    * Schedule sample-accurate fader automation on a strip.
    *

package/src/project_class.ts

@@ -427,6 +427,19 @@ export class Project {
     this.native.redo();
   }
 
+  /** Clear the undo/redo history without changing the current project state. */
+  clearHistory(): void {
+    this.native.clearHistory();
+  }
+
+  /** Cap the undo history depth (clamped to >= 1); evicts oldest entries beyond the cap. */
+  setMaxUndoDepth(depth: number): void {
+    if (!Number.isInteger(depth) || depth < 1) {
+      throw new RangeError('Project.setMaxUndoDepth: depth must be an integer >= 1');
+    }
+    this.native.setMaxUndoDepth(depth);
+  }
+
   /** Replace a MIDI clip's entire event list. */
   setMidiEvents(
     clipId: number,
@@ -436,7 +449,11 @@ export class Project {
     this.native.setMidiEvents(clipId, events);
   }
 
-  /** Import an in-memory SMF buffer; returns the first added clip id. */
+  /**
+   * Import an in-memory SMF buffer; returns the first added clip id.
+   * Malformed or partially truncated tracks are rejected instead of installing
+   * a silently shortened clip.
+   */
   importSmf(data: Uint8Array): number {
     return this.native.importSmf(data);
   }
@@ -485,7 +502,10 @@ export class Project {
     this.native.setProgramOnChannel(clipId, group, channel, program, bank);
   }
 
-  /** Destructively bake a MIDI-FX chain into a clip's stored MIDI events. */
+  /**
+   * Destructively bake a MIDI-FX chain into all stored events. Large clips are
+   * drained without truncation; failure leaves the original clip unchanged.
+   */
   bakeMidiFx(clipId: number, configJson: string): void {
     this.native.bakeMidiFx(clipId, configJson);
   }
@@ -497,9 +517,9 @@ export class Project {
 
   /**
    * Pre-flight check for hanging / unmatched notes in a MIDI clip: reports
-   * whether every note-on has a matching note-off (FIFO per channel+note).
-   * Useful before bouncing to catch a stuck note. Throws if `clipId` is unknown
-   * or not a MIDI clip.
+   * whether every note-on in the exported half-open playback window has a
+   * matching note-off (FIFO per group+channel+note). Useful before bouncing to
+   * catch a stuck note. Throws if `clipId` is unknown or not a MIDI clip.
    */
   validateMidiNotes(clipId: number): ProjectNotePairValidation {
     return this.native.validateMidiNotes(clipId);

package/src/project_internal.ts

@@ -58,6 +58,8 @@ export interface WasmProject {
   setTrackPan: (trackId: number, pan: number) => void;
   undo: () => void;
   redo: () => void;
+  clearHistory: () => void;
+  setMaxUndoDepth: (depth: number) => void;
   setMidiEvents: (
     clipId: number,
     events: ReadonlyArray<ProjectMidiEvent | readonly [number, number, number]>,

package/src/public_types_mastering.ts

@@ -138,6 +138,8 @@ export interface MasteringResult {
   inputLufs: number;
   outputLufs: number;
   appliedGainDb: number;
+  /** True when peak headroom prevented the requested LUFS target. */
+  loudnessTargetLimited?: boolean;
   latencySamples?: number;
 }
 
@@ -329,6 +331,7 @@ export interface MasteringChainConfig {
     monoMaker?: {
       enabled?: boolean;
       amount?: number;
+      frequencyHz?: number;
     };
   };
   maximizer?: {
@@ -407,6 +410,8 @@ export interface MasteringChainResult {
   outputTruePeakDbtp: number;
   /** EBU Tech 3342 Loudness Range of the output (LU). */
   outputLra: number;
+  /** True when peak headroom prevented the requested LUFS target. */
+  loudnessTargetLimited: boolean;
   /** Per-stage gain reductions for the dynamics/maximizer stages (a subset of `stages`). */
   stageGainReductions: StageGainReduction[];
 }
@@ -422,6 +427,7 @@ export interface MasteringChainStereoResult {
   /** See {@link MasteringChainResult} for field semantics. */
   outputTruePeakDbtp: number;
   outputLra: number;
+  loudnessTargetLimited: boolean;
   stageGainReductions: StageGainReduction[];
 }
 

package/src/public_types_music.ts

@@ -233,6 +233,10 @@ export interface Beat {
 export interface Chord {
   root: PitchClass;
   bass: PitchClass;
+  /** Canonical core spelling; stable across all language bindings. */
+  rootName: string;
+  /** Canonical core spelling; stable across all language bindings. */
+  bassName: string;
   quality: ChordQuality;
   start: number;
   end: number;

package/src/public_types_spectral.ts

@@ -30,15 +30,16 @@ export interface PitchCorrectOptions extends ValidateOptions {
 export interface NoteStretchOptions {
   /** Note onset position in samples (selects the region). Default 0. */
   onsetSample?: number;
-  /** Note offset position in samples (selects the region). Default 0. */
+  /** Note offset position in samples (selects the region). Defaults to the input length. */
   offsetSample?: number;
-  /** Stretch ratio (0.5 = double duration, 2.0 = half duration). Default 1. */
+  /** Stretch ratio (0.5 = half duration, 2.0 = double duration). Default 1. */
   stretchRatio?: number;
 }
 
 /** Options for `noteMove`. */
 export interface NoteMoveOptions {
   onsetSample?: number;
+  /** Defaults to the input length. */
   offsetSample?: number;
   targetOnsetSample?: number;
 }
@@ -47,7 +48,7 @@ export interface NoteMoveOptions {
 export type SpectralEditMode = 'gain' | 'attenuate' | 'mute' | 'heal';
 
 /** Analysis/synthesis window used by `spectralEdit`. */
-export type SpectralEditWindow = 'hann' | 'hamming' | 'blackman' | 'rectangular';
+export type SpectralEditWindow = 'hann' | 'hamming' | 'blackman' | 'rectangular' | 'rect';
 
 /** One time x frequency rectangle edit op for `spectralEdit`. */
 export interface SpectralRegionOp {
@@ -186,8 +187,14 @@ export interface PitchResult {
  */
 export interface LufsResult {
   integratedLufs: number;
+  /** Final complete 400 ms window, not Max-M. */
   momentaryLufs: number;
+  /** Final complete 3 s window, not Max-S. */
   shortTermLufs: number;
+  /** Maximum 400 ms window (EBU R128 Max-M). */
+  maxMomentaryLufs: number;
+  /** Maximum 3 s window (EBU R128 Max-S). */
+  maxShortTermLufs: number;
   loudnessRange: number;
 }
 

package/src/quick_analysis.ts

@@ -378,20 +378,38 @@ export function chordFunctionalAnalysis(
  * the UI responsive for long inputs, drive this from a Web Worker and use
  * {@link analyzeWithProgress} to report progress.
  */
-export function analyze(request: SamplesRequest): AnalysisResult;
+export interface MusicAnalyzeOptions {
+  nFft?: number;
+  hopLength?: number;
+  bpmMin?: number;
+  bpmMax?: number;
+  startBpm?: number;
+  useTriadsOnly?: boolean;
+  useHpss?: boolean;
+  chromaHighpassHz?: number;
+  useBassWeighted?: boolean;
+  chromaHopMultiplier?: number;
+  useChordHmm?: boolean;
+  useChordKeyContext?: boolean;
+  chordHmmBeamWidth?: number;
+  detectChordInversions?: boolean;
+}
+export interface MusicAnalyzeRequest extends SamplesRequest, MusicAnalyzeOptions {}
+
+export function analyze(request: MusicAnalyzeRequest): AnalysisResult;
 export function analyze(
   samples: Float32Array,
   sampleRate?: number,
-  options?: GuardedOptions,
+  options?: GuardedOptions & MusicAnalyzeOptions,
 ): AnalysisResult;
 export function analyze(
-  samples: Float32Array | SamplesRequest,
+  samples: Float32Array | MusicAnalyzeRequest,
   sampleRate = 22050,
-  options: GuardedOptions = {},
+  options: GuardedOptions & MusicAnalyzeOptions = {},
 ): AnalysisResult {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput('analyze', request.samples, request.sampleRate ?? 22050, request);
-  const result = requireModule().analyze(request.samples, request.sampleRate ?? 22050);
+  const result = requireModule().analyze(request.samples, request.sampleRate ?? 22050, request);
   return convertAnalysisResult(result);
 }
 

package/src/realtime_engine.ts

@@ -1,7 +1,7 @@
 import { panLawCode, panModeCode, sendTimingCode } from './codes';
 import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
-import type { SynthPatch } from './project';
+import type { ProjectMidiCcBinding, SynthPatch } from './project';
 import type { EqBand, PanLaw, PanMode, SendTiming } from './public_types';
 import type {
   WasmClipPageRequest,
@@ -290,6 +290,11 @@ export class RealtimeEngine {
     );
   }
 
+  /** Bind a 7/14-bit CC, RPN, or NRPN descriptor to a live parameter. */
+  bindMidiCcBinding(binding: ProjectMidiCcBinding): void {
+    this.native.bindMidiCcBinding(binding);
+  }
+
   clearMidiCcBindings(): void {
     this.native.clearMidiCcBindings();
   }
@@ -479,6 +484,7 @@ export class RealtimeEngine {
     this.native.seekPpq(ppq, renderFrame);
   }
 
+  /** Set a finite tempo in the range (0, 100000] BPM. */
   setTempo(bpm: number): void {
     this.native.setTempo(bpm);
   }
@@ -551,6 +557,7 @@ export class RealtimeEngine {
     this.native.setLoopFromMarkers(startMarkerId, endMarkerId);
   }
 
+  /** Set a metronome config; click lengths are limited to one second. */
   setMetronome(config: EngineMetronomeConfig): void {
     this.native.setMetronome(config);
   }
@@ -833,6 +840,7 @@ export class RealtimeEngine {
     this.native.setCaptureSource(source);
   }
 
+  /** Positive values delay capture relative to the punch window. */
   setRecordOffsetSamples(offsetSamples: number): void {
     this.native.setRecordOffsetSamples(offsetSamples);
   }

package/src/realtime_voice_changer.ts

@@ -1,5 +1,77 @@
 import { getSonareModule } from './module_state';
-import type { RealtimeVoiceChangerConfigInput, VoicePresetId } from './public_types';
+import type {
+  RealtimeVoiceChangerConfigInput,
+  RealtimeVoiceChangerPodConfig,
+  VoicePresetId,
+} from './public_types';
+
+/**
+ * True when `config` is a flat POD (the shape `realtimeVoiceChangerPresetConfig`
+ * returns) rather than a preset name or a nested preset. `retuneSemitones` only
+ * exists on the flat POD; the nested form spells it `retune.semitones`.
+ */
+function isFlatVoiceChangerPod(config: unknown): config is RealtimeVoiceChangerPodConfig {
+  return typeof config === 'object' && config !== null && 'retuneSemitones' in config;
+}
+
+/**
+ * Rewrite the flat 36-field POD into the nested shape the native config parser
+ * reads. Passing the flat POD straight to `setConfig` would leave every nested
+ * field at its default (only the three root fields are read flat), silently
+ * discarding retune/EQ/reverb/etc.
+ */
+function flatVoiceChangerPodToNested(pod: RealtimeVoiceChangerPodConfig): Record<string, unknown> {
+  return {
+    inputGainDb: pod.inputGainDb,
+    outputGainDb: pod.outputGainDb,
+    wetMix: pod.wetMix,
+    retune: { semitones: pod.retuneSemitones, mix: pod.retuneMix, grainSize: pod.retuneGrainSize },
+    formant: {
+      factor: pod.formantFactor,
+      amount: pod.formantAmount,
+      body: pod.formantBody,
+      brightness: pod.formantBrightness,
+      nasal: pod.formantNasal,
+    },
+    eq: {
+      highpassHz: pod.eqHighpassHz,
+      bodyDb: pod.eqBodyDb,
+      presenceDb: pod.eqPresenceDb,
+      airDb: pod.eqAirDb,
+    },
+    gate: {
+      thresholdDb: pod.gateThresholdDb,
+      attackMs: pod.gateAttackMs,
+      releaseMs: pod.gateReleaseMs,
+      rangeDb: pod.gateRangeDb,
+    },
+    compressor: {
+      thresholdDb: pod.compressorThresholdDb,
+      ratio: pod.compressorRatio,
+      attackMs: pod.compressorAttackMs,
+      releaseMs: pod.compressorReleaseMs,
+      makeupGainDb: pod.compressorMakeupGainDb,
+    },
+    deesser: {
+      frequencyHz: pod.deesserFrequencyHz,
+      thresholdDb: pod.deesserThresholdDb,
+      ratio: pod.deesserRatio,
+      rangeDb: pod.deesserRangeDb,
+    },
+    reverb: {
+      mix: pod.reverbMix,
+      timeMs: pod.reverbTimeMs,
+      damping: pod.reverbDamping,
+      seed: pod.reverbSeed,
+    },
+    limiter: {
+      ceilingDb: pod.limiterCeilingDb,
+      releaseMs: pod.limiterReleaseMs,
+      enableIspLimiter: pod.limiterEnableIspLimiter,
+      ispCeilingDbtp: pod.limiterIspCeilingDbtp,
+    },
+  };
+}
 
 /**
  * Zero-copy realtime buffer pair for {@link RealtimeVoiceChanger} mono
@@ -58,8 +130,12 @@ export class RealtimeVoiceChanger {
     this.changer.reset();
   }
 
-  setConfig(config: RealtimeVoiceChangerConfigInput): void {
-    this.changer.setConfig(config as Record<string, unknown> | string);
+  setConfig(config: RealtimeVoiceChangerConfigInput | RealtimeVoiceChangerPodConfig): void {
+    // A flat POD (from realtimeVoiceChangerPresetConfig) is rewritten to the
+    // nested shape the native parser reads; a preset name or nested preset is
+    // passed through unchanged.
+    const resolved = isFlatVoiceChangerPod(config) ? flatVoiceChangerPodToNested(config) : config;
+    this.changer.setConfig(resolved as Record<string, unknown> | string);
   }
 
   configJson(): string {