@libraz/libsonare 1.5.2 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libraz/libsonare",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "type": "module",
   "packageManager": "yarn@4.15.0",
   "description": "Audio analysis library for music information retrieval",
@@ -35,6 +35,7 @@
     "format": "biome format --write src/ tests/",
     "test": "vitest run",
     "test:browser": "node scripts/audio-worklet-smoke.mjs",
+    "test:browser:audit": "node scripts/audit-boundary-smoke.mjs",
     "test:watch": "vitest",
     "prepublishOnly": "yarn clean && cp ../../LICENSE LICENSE && yarn build && yarn lint && yarn test"
   },

package/src/_chain_config.ts

@@ -0,0 +1,46 @@
+import type { MasteringChainConfig } from './public_types';
+
+type ChainSection = { [key: string]: number | boolean | ChainSection | undefined };
+
+/**
+ * Flattens a nested {@link MasteringChainConfig} into the dot-notation
+ * `{ "module.processor.param": value }` map the WASM core consumes. Internal
+ * helper shared by the mastering-chain / master-audio entry points; mirrors the
+ * Node facade so a nested config produces identical overrides on both surfaces.
+ */
+export function flattenChainConfig(config: MasteringChainConfig): Record<string, number | boolean> {
+  const out: Record<string, number | boolean> = {};
+  const walk = (node: ChainSection, prefix: string): void => {
+    for (const [key, value] of Object.entries(node)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === 'number' || typeof value === 'boolean') {
+        out[path] = value;
+      } else if (value !== null && typeof value === 'object') {
+        walk(value, path);
+      }
+    }
+  };
+  walk(config as ChainSection, '');
+
+  // Compatibility aliases for the original WASM-only shorthand. Normalize at
+  // this boundary so every native entry point receives the core parser's one
+  // canonical vocabulary; public types can migrate to the nested spelling
+  // without preserving a second C++ parser indefinitely.
+  const aliases: Record<string, string> = {
+    'repair.denoise': 'repair.denoise.enabled',
+    'repair.nFft': 'repair.denoise.nFft',
+    'repair.hopLength': 'repair.denoise.hopLength',
+    'repair.ddAlpha': 'repair.denoise.ddAlpha',
+    'repair.gainFloor': 'repair.denoise.gainFloor',
+    'eq.tiltDb': 'eq.tilt.tiltDb',
+    'eq.pivotHz': 'eq.tilt.pivotHz',
+  };
+  for (const [legacy, canonical] of Object.entries(aliases)) {
+    const value = out[legacy];
+    if (value !== undefined) {
+      out[canonical] = value;
+      delete out[legacy];
+    }
+  }
+  return out;
+}

package/src/audio.ts

@@ -7,6 +7,7 @@ import {
   masteringChain,
   masteringProcess,
   normalize,
+  noteMove,
   noteStretch,
   percussive,
   pitchCorrectToMidi,
@@ -332,6 +333,10 @@ export class Audio {
     return noteStretch(this._samples, this._sampleRate, options);
   }
 
+  noteMove(options: import('./public_types.js').NoteMoveOptions = {}): Float32Array {
+    return noteMove(this._samples, this._sampleRate, options);
+  }
+
   voiceChange(options: VoiceChangeOptions = {}): Float32Array {
     return voiceChange(this._samples, this._sampleRate, options);
   }
@@ -344,15 +349,30 @@ export class Audio {
     return mastering(this._samples, this._sampleRate, options);
   }
 
-  masteringChain(config: MasteringChainConfig): MasteringChainResult {
-    return masteringChain(this._samples, this._sampleRate, config);
+  masteringChain(
+    config: MasteringChainConfig = {},
+    onProgress?: ProgressCallback,
+  ): MasteringChainResult {
+    return masteringChain({
+      samples: this._samples,
+      sampleRate: this._sampleRate,
+      config,
+      onProgress,
+    });
   }
 
   masterAudio(
     presetName: MasteringPreset = 'pop',
-    overrides: Record<string, number | boolean> | null = null,
+    overrides: MasteringChainConfig | null = null,
+    onProgress?: ProgressCallback,
   ): MasteringChainResult {
-    return masterAudio(this._samples, this._sampleRate, presetName, overrides ?? {});
+    return masterAudio({
+      samples: this._samples,
+      sampleRate: this._sampleRate,
+      preset: presetName,
+      overrides: overrides ?? {},
+      onProgress,
+    });
   }
 
   masteringProcess(

package/src/effects_mastering.ts

@@ -2,6 +2,7 @@ export {
   harmonic,
   hpss,
   normalize,
+  noteMove,
   noteStretch,
   percussive,
   pitchCorrectTimevarying,
@@ -11,7 +12,12 @@ export {
   spectralEdit,
   timeStretch,
 } from './effects_transform';
-export type { VoiceChangeOptions, VoiceChangeRealtimeOptions } from './effects_voice_change';
+export type {
+  VoiceChangeOptions,
+  VoiceChangeRealtimeOptions,
+  VoiceChangeRealtimeRequest,
+  VoiceChangeRequest,
+} from './effects_voice_change';
 export { voiceChange, voiceChangeRealtime } from './effects_voice_change';
 export {
   masterAudio,
@@ -27,7 +33,14 @@ export {
 export type {
   MasteringChannelPolicy,
   MasteringInsertParamInfo,
+  MasteringPairAnalyzeRequest,
+  MasteringPairProcessRequest,
   MasteringProcessorCatalogEntry,
+  MasteringProcessRequest,
+  MasteringProcessStereoRequest,
+  MasteringSamplesParamsRequest,
+  MasteringStereoAnalyzeRequest,
+  MasteringStreamingPreviewRequest,
 } from './mastering_core';
 export {
   mastering,
@@ -53,6 +66,9 @@ export type {
   CompressorOptions,
   DynamicsResult,
   GateOptions,
+  MasteringDynamicsCompressorRequest,
+  MasteringDynamicsGateRequest,
+  MasteringDynamicsTransientShaperRequest,
   TransientShaperOptions,
 } from './mastering_dynamics';
 export {
@@ -70,6 +86,13 @@ export type {
   DenoiseClassicalNoiseEstimator,
   DenoiseClassicalOptions,
   DereverbClassicalOptions,
+  MasteringRepairDeclickRequest,
+  MasteringRepairDeclipRequest,
+  MasteringRepairDecrackleRequest,
+  MasteringRepairDehumRequest,
+  MasteringRepairDenoiseClassicalRequest,
+  MasteringRepairDereverbClassicalRequest,
+  MasteringRepairTrimSilenceRequest,
   TrimSilenceMode,
   TrimSilenceOptions,
 } from './mastering_repair';
@@ -82,4 +105,5 @@ export {
   masteringRepairDereverbClassical,
   masteringRepairTrimSilence,
 } from './mastering_repair';
+export type { MixStereoRequest } from './mixing_oneshot';
 export { mixingScenePresetJson, mixingScenePresetNames, mixStereo } from './mixing_oneshot';

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,13 +157,20 @@ 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);
 }
 
 /**
@@ -75,14 +181,25 @@ export function percussive(
  * @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: sampleRate as number, rate: rate as number, ...options }
+      : samples;
+  assertSamples('timeStretch', request.samples, request.validate !== false);
+  return requireModule().timeStretch(request.samples, request.sampleRate, request.rate);
 }
 
 /**
@@ -93,14 +210,25 @@ export function timeStretch(
  * @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: sampleRate as number, semitones: semitones as number, ...options }
+      : samples;
+  assertSamples('pitchShift', request.samples, request.validate !== false);
+  return requireModule().pitchShift(request.samples, request.sampleRate, request.semitones);
 }
 
 /**
@@ -112,15 +240,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 +286,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 +359,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 +410,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,
   );
 }
 
@@ -250,14 +463,25 @@ export function noteStretch(
  * @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: sampleRate as number, targetDb, ...options }
+      : samples;
+  assertSamples('normalize', request.samples, request.validate !== false);
+  return requireModule().normalize(request.samples, request.sampleRate, request.targetDb ?? 0.0);
 }
 
 /**
@@ -274,13 +498,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>,
+  );
 }