@libraz/libsonare 1.5.2 → 1.5.4

package/src/effects_transform.ts

@@ -1,6 +1,7 @@
 import { getSonareModule } from './module_state';
 import type {
   HpssResult,
+  NoteMoveOptions,
   NoteStretchOptions,
   PitchCorrectOptions,
   SpectralEditOptions,
@@ -13,6 +14,81 @@ function requireModule() {
   return getSonareModule();
 }
 
+/** Canonical request form for HPSS. */
+export interface HpssRequest {
+  samples: Float32Array;
+  sampleRate?: number;
+  kernelHarmonic?: number;
+  kernelPercussive?: number;
+}
+
+export interface HarmonicRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+}
+
+export interface PercussiveRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+}
+
+export interface TimeStretchRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+  rate: number;
+}
+
+export interface PitchShiftRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+  semitones: number;
+}
+
+export interface PitchCorrectToMidiRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+  currentMidi?: number;
+  targetMidi?: number;
+}
+
+export interface PitchCorrectToMidiTimevaryingRequest extends ValidateOptions {
+  samples: Float32Array;
+  f0Hz: Float32Array;
+  targetMidi: number;
+  sampleRate?: number;
+  hopLength?: number;
+  voiced?: Int32Array;
+  voicedProb?: Float32Array;
+}
+
+export interface PitchCorrectTimevaryingRequest extends PitchCorrectOptions {
+  samples: Float32Array;
+  f0Hz: Float32Array;
+  sampleRate?: number;
+  hopLength?: number;
+}
+
+export interface NoteStretchRequest extends NoteStretchOptions, ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+}
+export interface NoteMoveRequest extends NoteMoveOptions, ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+}
+
+export interface NormalizeRequest extends ValidateOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+  targetDb?: number;
+}
+
+export interface SpectralEditRequest extends SpectralEditOptions, ValidateOptions {
+  samples: Float32Array;
+  sampleRate: number;
+  ops?: SpectralRegionOp[];
+}
+
 // ============================================================================
 // Effects
 // ============================================================================
@@ -26,13 +102,29 @@ function requireModule() {
  * @param kernelPercussive - Vertical median filter size for percussive (default: 31)
  * @returns Separated harmonic and percussive components
  */
+export function hpss(request: HpssRequest): HpssResult;
 export function hpss(
   samples: Float32Array,
+  sampleRate?: number,
+  kernelHarmonic?: number,
+  kernelPercussive?: number,
+): HpssResult;
+export function hpss(
+  samples: Float32Array | HpssRequest,
   sampleRate = 22050,
   kernelHarmonic = 31,
   kernelPercussive = 31,
 ): HpssResult {
-  return requireModule().hpss(samples, sampleRate, kernelHarmonic, kernelPercussive);
+  const request =
+    samples instanceof Float32Array
+      ? { samples, sampleRate, kernelHarmonic, kernelPercussive }
+      : samples;
+  return requireModule().hpss(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.kernelHarmonic ?? 31,
+    request.kernelPercussive ?? 31,
+  );
 }
 
 /**
@@ -42,13 +134,20 @@ export function hpss(
  * @param sampleRate - Sample rate in Hz
  * @returns Harmonic component
  */
+export function harmonic(request: HarmonicRequest): Float32Array;
 export function harmonic(
   samples: Float32Array,
-  sampleRate: number,
+  sampleRate?: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function harmonic(
+  samples: Float32Array | HarmonicRequest,
+  sampleRate = 22050,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('harmonic', samples, options.validate !== false);
-  return requireModule().harmonic(samples, sampleRate);
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples('harmonic', request.samples, request.validate !== false);
+  return requireModule().harmonic(request.samples, request.sampleRate ?? 22050);
 }
 
 /**
@@ -58,49 +157,82 @@ export function harmonic(
  * @param sampleRate - Sample rate in Hz
  * @returns Percussive component
  */
+export function percussive(request: PercussiveRequest): Float32Array;
 export function percussive(
   samples: Float32Array,
-  sampleRate: number,
+  sampleRate?: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function percussive(
+  samples: Float32Array | PercussiveRequest,
+  sampleRate = 22050,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('percussive', samples, options.validate !== false);
-  return requireModule().percussive(samples, sampleRate);
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples('percussive', request.samples, request.validate !== false);
+  return requireModule().percussive(request.samples, request.sampleRate ?? 22050);
 }
 
 /**
  * Time-stretch audio without changing pitch.
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz
+ * @param sampleRate - Sample rate in Hz (default: 22050)
  * @param rate - Time stretch rate (0.5 = double duration, 2.0 = half duration)
  * @returns Time-stretched audio
  */
+export function timeStretch(request: TimeStretchRequest): Float32Array;
 export function timeStretch(
   samples: Float32Array,
   sampleRate: number,
   rate: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function timeStretch(
+  samples: Float32Array | TimeStretchRequest,
+  sampleRate?: number,
+  rate?: number,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('timeStretch', samples, options.validate !== false);
-  return requireModule().timeStretch(samples, sampleRate, rate);
+  const request: TimeStretchRequest =
+    samples instanceof Float32Array
+      ? { samples, sampleRate, rate: rate as number, ...options }
+      : samples;
+  assertSamples('timeStretch', request.samples, request.validate !== false);
+  return requireModule().timeStretch(request.samples, request.sampleRate ?? 22050, request.rate);
 }
 
 /**
  * Pitch-shift audio without changing duration.
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz
+ * @param sampleRate - Sample rate in Hz (default: 22050)
  * @param semitones - Pitch shift in semitones (+12 = one octave up, -12 = one octave down)
  * @returns Pitch-shifted audio
  */
+export function pitchShift(request: PitchShiftRequest): Float32Array;
 export function pitchShift(
   samples: Float32Array,
   sampleRate: number,
   semitones: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function pitchShift(
+  samples: Float32Array | PitchShiftRequest,
+  sampleRate?: number,
+  semitones?: number,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('pitchShift', samples, options.validate !== false);
-  return requireModule().pitchShift(samples, sampleRate, semitones);
+  const request: PitchShiftRequest =
+    samples instanceof Float32Array
+      ? { samples, sampleRate, semitones: semitones as number, ...options }
+      : samples;
+  assertSamples('pitchShift', request.samples, request.validate !== false);
+  return requireModule().pitchShift(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.semitones,
+  );
 }
 
 /**
@@ -112,15 +244,32 @@ export function pitchShift(
  * @param targetMidi - Desired MIDI note number
  * @returns Pitch-corrected audio
  */
+export function pitchCorrectToMidi(request: PitchCorrectToMidiRequest): Float32Array;
 export function pitchCorrectToMidi(
   samples: Float32Array,
+  sampleRate?: number,
+  currentMidi?: number,
+  targetMidi?: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function pitchCorrectToMidi(
+  samples: Float32Array | PitchCorrectToMidiRequest,
   sampleRate = 22050,
   currentMidi = 69.0,
   targetMidi = 69.0,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('pitchCorrectToMidi', samples, options.validate !== false);
-  return requireModule().pitchCorrectToMidi(samples, sampleRate, currentMidi, targetMidi);
+  const request =
+    samples instanceof Float32Array
+      ? { samples, sampleRate, currentMidi, targetMidi, ...options }
+      : samples;
+  assertSamples('pitchCorrectToMidi', request.samples, request.validate !== false);
+  return requireModule().pitchCorrectToMidi(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.currentMidi ?? 69.0,
+    request.targetMidi ?? 69.0,
+  );
 }
 
 /**
@@ -141,34 +290,60 @@ export function pitchCorrectToMidi(
  * @param voicedProb - Optional per-frame voicing probability in [0, 1]
  * @returns Pitch-corrected audio
  */
+export function pitchCorrectToMidiTimevarying(
+  request: PitchCorrectToMidiTimevaryingRequest,
+): Float32Array;
 export function pitchCorrectToMidiTimevarying(
   samples: Float32Array,
   f0Hz: Float32Array,
   targetMidi: number,
+  sampleRate?: number,
+  hopLength?: number,
+  voiced?: Int32Array,
+  voicedProb?: Float32Array,
+  options?: ValidateOptions,
+): Float32Array;
+export function pitchCorrectToMidiTimevarying(
+  samples: Float32Array | PitchCorrectToMidiTimevaryingRequest,
+  f0Hz?: Float32Array,
+  targetMidi?: number,
   sampleRate = 22050,
   hopLength = 512,
   voiced?: Int32Array,
   voicedProb?: Float32Array,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('pitchCorrectToMidiTimevarying', samples, options.validate !== false);
-  if (voiced && voiced.length !== f0Hz.length) {
+  const request: PitchCorrectToMidiTimevaryingRequest =
+    samples instanceof Float32Array
+      ? {
+          samples,
+          f0Hz: f0Hz as Float32Array,
+          targetMidi: targetMidi as number,
+          sampleRate,
+          hopLength,
+          voiced,
+          voicedProb,
+          ...options,
+        }
+      : samples;
+  assertSamples('pitchCorrectToMidiTimevarying', request.samples, request.validate !== false);
+  if (request.voiced && request.voiced.length !== request.f0Hz.length) {
     throw new RangeError('pitchCorrectToMidiTimevarying: voiced length must match f0Hz length');
   }
-  if (voicedProb && voicedProb.length !== f0Hz.length) {
+  if (request.voicedProb && request.voicedProb.length !== request.f0Hz.length) {
     throw new RangeError('pitchCorrectToMidiTimevarying: voicedProb length must match f0Hz length');
   }
   // The embind layer reads the companion arrays as Float32Array (voiced uses
   // 0.0/1.0); convert here so a single native conversion path suffices.
-  const voicedF32 = voiced ? Float32Array.from(voiced) : undefined;
+  const voicedF32 = request.voiced ? Float32Array.from(request.voiced) : undefined;
   return requireModule().pitchCorrectToMidiTimevarying(
-    samples,
-    sampleRate,
-    f0Hz,
-    targetMidi,
-    hopLength,
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.f0Hz,
+    request.targetMidi,
+    request.hopLength ?? 512,
     voicedF32,
-    voicedProb,
+    request.voicedProb,
   );
 }
 
@@ -188,31 +363,43 @@ export function pitchCorrectToMidiTimevarying(
  * @param options - Target mode + retune knobs + optional voiced/voicedProb arrays
  * @returns Pitch-corrected audio
  */
+export function pitchCorrectTimevarying(request: PitchCorrectTimevaryingRequest): Float32Array;
 export function pitchCorrectTimevarying(
   samples: Float32Array,
   f0Hz: Float32Array,
+  sampleRate?: number,
+  hopLength?: number,
+  options?: PitchCorrectOptions,
+): Float32Array;
+export function pitchCorrectTimevarying(
+  samples: Float32Array | PitchCorrectTimevaryingRequest,
+  f0Hz?: Float32Array,
   sampleRate = 22050,
   hopLength = 512,
   options: PitchCorrectOptions = {},
 ): Float32Array {
-  assertSamples('pitchCorrectTimevarying', samples, options.validate !== false);
-  if (options.voiced && options.voiced.length !== f0Hz.length) {
+  const request: PitchCorrectTimevaryingRequest =
+    samples instanceof Float32Array
+      ? { samples, f0Hz: f0Hz as Float32Array, sampleRate, hopLength, ...options }
+      : samples;
+  assertSamples('pitchCorrectTimevarying', request.samples, request.validate !== false);
+  if (request.voiced && request.voiced.length !== request.f0Hz.length) {
     throw new RangeError('pitchCorrectTimevarying: voiced length must match f0Hz length');
   }
-  if (options.voicedProb && options.voicedProb.length !== f0Hz.length) {
+  if (request.voicedProb && request.voicedProb.length !== request.f0Hz.length) {
     throw new RangeError('pitchCorrectTimevarying: voicedProb length must match f0Hz length');
   }
   // The embind layer reads the companion arrays as Float32Array (voiced uses
   // 0.0/1.0); convert here so a single native conversion path suffices.
   const nativeOptions = {
-    ...options,
-    voiced: options.voiced ? Float32Array.from(options.voiced) : undefined,
+    ...request,
+    voiced: request.voiced ? Float32Array.from(request.voiced) : undefined,
   };
   return requireModule().pitchCorrectTimevarying(
-    samples,
-    sampleRate,
-    f0Hz,
-    hopLength,
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.f0Hz,
+    request.hopLength ?? 512,
     nativeOptions,
   );
 }
@@ -227,18 +414,48 @@ export function pitchCorrectTimevarying(
  * @param stretchRatio - Stretch ratio (0.5 = double duration, 2.0 = half duration)
  * @returns Audio with the note region stretched
  */
+export function noteStretch(request: NoteStretchRequest): Float32Array;
 export function noteStretch(
   samples: Float32Array,
+  sampleRate?: number,
+  options?: NoteStretchOptions & ValidateOptions,
+): Float32Array;
+export function noteStretch(
+  samples: Float32Array | NoteStretchRequest,
   sampleRate = 22050,
   options: NoteStretchOptions & ValidateOptions = {},
 ): Float32Array {
-  assertSamples('noteStretch', samples, options.validate !== false);
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples('noteStretch', request.samples, request.validate !== false);
   return requireModule().noteStretch(
-    samples,
-    sampleRate,
-    options.onsetSample ?? 0,
-    options.offsetSample ?? 0,
-    options.stretchRatio ?? 1.0,
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.onsetSample ?? 0,
+    request.offsetSample ?? 0,
+    request.stretchRatio ?? 1.0,
+  );
+}
+
+/** Move a note region to a new onset without changing its duration. */
+export function noteMove(request: NoteMoveRequest): Float32Array;
+export function noteMove(
+  samples: Float32Array,
+  sampleRate?: number,
+  options?: NoteMoveOptions & ValidateOptions,
+): Float32Array;
+export function noteMove(
+  samples: Float32Array | NoteMoveRequest,
+  sampleRate = 22050,
+  options: NoteMoveOptions & ValidateOptions = {},
+): Float32Array {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples('noteMove', request.samples, request.validate !== false);
+  return requireModule().noteMove(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.onsetSample ?? 0,
+    request.offsetSample ?? 0,
+    request.targetOnsetSample ?? 0,
   );
 }
 
@@ -246,18 +463,31 @@ export function noteStretch(
  * Normalize audio to target peak level.
  *
  * @param samples - Audio samples (mono, float32)
- * @param sampleRate - Sample rate in Hz
+ * @param sampleRate - Sample rate in Hz (default: 22050)
  * @param targetDb - Target peak level in dB (default: 0 dB = full scale)
  * @returns Normalized audio
  */
+export function normalize(request: NormalizeRequest): Float32Array;
 export function normalize(
   samples: Float32Array,
   sampleRate: number,
+  targetDb?: number,
+  options?: ValidateOptions,
+): Float32Array;
+export function normalize(
+  samples: Float32Array | NormalizeRequest,
+  sampleRate?: number,
   targetDb = 0.0,
   options: ValidateOptions = {},
 ): Float32Array {
-  assertSamples('normalize', samples, options.validate !== false);
-  return requireModule().normalize(samples, sampleRate, targetDb);
+  const request: NormalizeRequest =
+    samples instanceof Float32Array ? { samples, sampleRate, targetDb, ...options } : samples;
+  assertSamples('normalize', request.samples, request.validate !== false);
+  return requireModule().normalize(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.targetDb ?? 0.0,
+  );
 }
 
 /**
@@ -274,13 +504,29 @@ export function normalize(
  * @param options - STFT + heal configuration ({@link SpectralEditOptions})
  * @returns Edited audio
  */
+export function spectralEdit(request: SpectralEditRequest): Float32Array;
 export function spectralEdit(
   samples: Float32Array,
   sampleRate: number,
+  ops?: SpectralRegionOp[],
+  options?: SpectralEditOptions & ValidateOptions,
+): Float32Array;
+export function spectralEdit(
+  samples: Float32Array | SpectralEditRequest,
+  sampleRate?: number,
   ops: SpectralRegionOp[] = [],
   options: SpectralEditOptions & ValidateOptions = {},
 ): Float32Array {
-  assertSamples('spectralEdit', samples, options.validate !== false);
-  assertSampleRate('spectralEdit', sampleRate);
-  return requireModule().spectralEdit(samples, sampleRate, ops, options as Record<string, unknown>);
+  const request: SpectralEditRequest =
+    samples instanceof Float32Array
+      ? { samples, sampleRate: sampleRate as number, ops, ...options }
+      : samples;
+  assertSamples('spectralEdit', request.samples, request.validate !== false);
+  assertSampleRate('spectralEdit', request.sampleRate);
+  return requireModule().spectralEdit(
+    request.samples,
+    request.sampleRate,
+    request.ops ?? [],
+    request as unknown as Record<string, unknown>,
+  );
 }

package/src/effects_voice_change.ts

@@ -1,6 +1,5 @@
 import { getSonareModule } from './module_state';
 import type { RealtimeVoiceChangerConfigInput } from './public_types';
-import { RealtimeVoiceChanger } from './streaming_mixing';
 import type { ValidateOptions } from './validation';
 import { assertSamples } from './validation';
 
@@ -16,6 +15,12 @@ export interface VoiceChangeOptions extends ValidateOptions {
   formantFactor?: number;
 }
 
+/** Canonical request form for one-shot voice changing. */
+export interface VoiceChangeRequest extends VoiceChangeOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+}
+
 /**
  * Apply a voice change by shifting pitch and formants independently.
  *
@@ -24,17 +29,24 @@ export interface VoiceChangeOptions extends ValidateOptions {
  * @param options - Pitch/formant settings ({@link VoiceChangeOptions})
  * @returns Voice-changed audio
  */
+export function voiceChange(request: VoiceChangeRequest): Float32Array;
 export function voiceChange(
   samples: Float32Array,
+  sampleRate?: number,
+  options?: VoiceChangeOptions,
+): Float32Array;
+export function voiceChange(
+  samples: Float32Array | VoiceChangeRequest,
   sampleRate = 22050,
   options: VoiceChangeOptions = {},
 ): Float32Array {
-  assertSamples('voiceChange', samples, options.validate !== false);
+  const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
+  assertSamples('voiceChange', request.samples, request.validate !== false);
   return requireModule().voiceChange(
-    samples,
-    sampleRate,
-    options.pitchSemitones ?? 0.0,
-    options.formantFactor ?? 1.0,
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.pitchSemitones ?? 0.0,
+    request.formantFactor ?? 1.0,
   );
 }
 
@@ -42,50 +54,23 @@ export function voiceChange(
 export interface VoiceChangeRealtimeOptions extends ValidateOptions {
   /** Channel count (1 = mono, 2 = interleaved stereo). */
   channels?: 1 | 2;
-  /** Block size for the internal render loop (default 512). */
+  /** @deprecated The shared C-ABI renderer uses a fixed cross-surface block size. */
   blockSize?: number;
 }
 
-function latencyCompensatedVoiceChange(
-  changer: RealtimeVoiceChanger,
-  samples: Float32Array,
-  channels: 1 | 2,
-  blockFrames: number,
-): Float32Array {
-  const latencyFrames = Math.max(0, changer.latencySamples());
-  if (channels === 1) {
-    const total = samples.length + latencyFrames;
-    const input = new Float32Array(total);
-    input.set(samples);
-    const processed = new Float32Array(total);
-    for (let offset = 0; offset < total; offset += blockFrames) {
-      const block = input.subarray(offset, Math.min(offset + blockFrames, total));
-      processed.set(changer.processMono(block), offset);
-    }
-    return processed.slice(latencyFrames, latencyFrames + samples.length);
-  }
-
-  const frames = samples.length / 2;
-  const totalFrames = frames + latencyFrames;
-  const input = new Float32Array(totalFrames * 2);
-  input.set(samples);
-  const processed = new Float32Array(totalFrames * 2);
-  const frameStride = blockFrames * 2;
-  for (let offset = 0; offset < input.length; offset += frameStride) {
-    const block = input.subarray(offset, Math.min(offset + frameStride, input.length));
-    processed.set(changer.processInterleaved(block, 2), offset);
-  }
-  const start = latencyFrames * 2;
-  return processed.slice(start, start + samples.length);
+/** Canonical request form for offline realtime voice changing. */
+export interface VoiceChangeRealtimeRequest extends VoiceChangeRealtimeOptions {
+  samples: Float32Array;
+  sampleRate?: number;
+  preset?: RealtimeVoiceChangerConfigInput;
 }
 
 /**
  * Applies the realtime voice-changer chain to a whole buffer in one call.
  *
- * Constructs and prepares a {@link RealtimeVoiceChanger}, runs the block loop
- * for the caller, then disposes it — matching the Python `voice_change_realtime`
- * and Node `voiceChangeRealtime` convenience wrappers. For mono, `samples` is a
- * plain mono buffer; for stereo, `samples` is interleaved (L0,R0,L1,R1,...).
+ * Uses the shared C-ABI renderer, so Python, Node, and WASM use the same
+ * fixed block size and latency compensation. For mono, `samples` is a plain
+ * buffer; for stereo, it is interleaved (L0,R0,L1,R1,...).
  *
  * @param samples - Audio samples (mono, or interleaved stereo when channels=2)
  * @param sampleRate - Sample rate in Hz (default 48000, matching Python/Node)
@@ -93,26 +78,34 @@ function latencyCompensatedVoiceChange(
  * @param options - Channel count and block size ({@link VoiceChangeRealtimeOptions})
  * @returns The processed buffer (same layout/length as the input).
  */
+export function voiceChangeRealtime(request: VoiceChangeRealtimeRequest): Float32Array;
 export function voiceChangeRealtime(
   samples: Float32Array,
+  sampleRate?: number,
+  preset?: RealtimeVoiceChangerConfigInput,
+  options?: VoiceChangeRealtimeOptions,
+): Float32Array;
+export function voiceChangeRealtime(
+  samples: Float32Array | VoiceChangeRealtimeRequest,
   sampleRate = 48000,
   preset: RealtimeVoiceChangerConfigInput = 'neutral-monitor',
   options: VoiceChangeRealtimeOptions = {},
 ): Float32Array {
-  assertSamples('voiceChangeRealtime', samples, options.validate !== false);
-  const channels = options.channels ?? 1;
+  const request =
+    samples instanceof Float32Array ? { samples, sampleRate, preset, ...options } : samples;
+  assertSamples('voiceChangeRealtime', request.samples, request.validate !== false);
+  const channels = request.channels ?? 1;
   if (channels !== 1 && channels !== 2) {
     throw new Error('voiceChangeRealtime: channels must be 1 or 2.');
   }
-  if (channels === 2 && samples.length % 2 !== 0) {
+  if (channels === 2 && request.samples.length % 2 !== 0) {
     throw new Error('voiceChangeRealtime: stereo input length must be a multiple of 2.');
   }
-  const blockSize = Math.max(1, Math.floor(options.blockSize ?? 512));
-  const changer = new RealtimeVoiceChanger(preset);
-  try {
-    changer.prepare(sampleRate, blockSize, channels);
-    return latencyCompensatedVoiceChange(changer, samples, channels, blockSize);
-  } finally {
-    changer.delete();
-  }
+  const presetConfig = request.preset ?? 'neutral-monitor';
+  return requireModule().voiceChangeRealtime(
+    request.samples,
+    request.sampleRate ?? 48000,
+    typeof presetConfig === 'string' ? presetConfig : JSON.stringify(presetConfig),
+    channels,
+  );
 }