@libraz/libsonare 1.5.5 → 1.7.0

package/dist/index.js

@@ -8,6 +8,7 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2[ErrorCode2["OutOfMemory"] = 5] = "OutOfMemory";
   ErrorCode2[ErrorCode2["NotSupported"] = 6] = "NotSupported";
   ErrorCode2[ErrorCode2["InvalidState"] = 7] = "InvalidState";
+  ErrorCode2[ErrorCode2["Cancelled"] = 8] = "Cancelled";
   ErrorCode2[ErrorCode2["Unknown"] = 99] = "Unknown";
   return ErrorCode2;
 })(ErrorCode || {});
@@ -226,13 +227,59 @@ function assertInterleavedSamples(fnName, samples, channels, validate) {
 function requireModule() {
   return getSonareModule();
 }
-function hpss(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, kernelHarmonic, kernelPercussive } : samples;
-  return requireModule().hpss(
+function resolveEffectFftOptions(fnName, nFft, hopLength) {
+  const resolvedNFft = nFft === void 0 ? 2048 : nFft;
+  const resolvedHopLength = hopLength === void 0 ? 512 : hopLength;
+  if (typeof resolvedNFft !== "number" || !Number.isInteger(resolvedNFft)) {
+    throw new TypeError(`${fnName}: nFft must be an integer`);
+  }
+  if (resolvedNFft < 2 || resolvedNFft > 2 ** 30) {
+    throw new RangeError(`${fnName}: nFft must be an even power of two >= 2`);
+  }
+  if ((resolvedNFft & resolvedNFft - 1) !== 0) {
+    throw new RangeError(`${fnName}: nFft must be an even power of two >= 2`);
+  }
+  if (typeof resolvedHopLength !== "number" || !Number.isInteger(resolvedHopLength)) {
+    throw new TypeError(`${fnName}: hopLength must be an integer`);
+  }
+  if (resolvedHopLength <= 0 || resolvedHopLength > 2 ** 31 - 1) {
+    throw new RangeError(`${fnName}: hopLength must be a positive integer`);
+  }
+  return { nFft: resolvedNFft, hopLength: resolvedHopLength };
+}
+function resolveNormalizeMode(value) {
+  if (value === void 0) {
+    return "peak";
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("normalize: mode must be the string 'peak' or 'rms'");
+  }
+  if (value !== "peak" && value !== "rms") {
+    throw new RangeError("normalize: mode must be the string 'peak' or 'rms'");
+  }
+  return value;
+}
+function resolveHardMask(value, fnName) {
+  if (value === void 0) {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    throw new TypeError(`${fnName}: hardMask must be a boolean`);
+  }
+  return value;
+}
+function hpss(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31, nFft, hopLength, hardMask) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, kernelHarmonic, kernelPercussive, nFft, hopLength, hardMask } : samples;
+  const fftOptions = resolveEffectFftOptions("hpss", request.nFft, request.hopLength);
+  const resolvedHardMask = resolveHardMask(request.hardMask, "hpss");
+  return requireModule().hpssEx(
     request.samples,
     request.sampleRate ?? 22050,
     request.kernelHarmonic ?? 31,
-    request.kernelPercussive ?? 31
+    request.kernelPercussive ?? 31,
+    fftOptions.nFft,
+    fftOptions.hopLength,
+    resolvedHardMask
   );
 }
 function harmonic(samples, sampleRate = 22050, options = {}) {
@@ -245,18 +292,58 @@ function percussive(samples, sampleRate = 22050, options = {}) {
   assertSamples("percussive", request.samples, request.validate !== false);
   return requireModule().percussive(request.samples, request.sampleRate ?? 22050);
 }
-function timeStretch(samples, sampleRate, rate, options = {}) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, rate, ...options } : samples;
+function timeStretch(samples, sampleRate, rate, nFftOrOptions, hopLength, options = {}) {
+  if (nFftOrOptions !== void 0 && nFftOrOptions !== null && typeof nFftOrOptions !== "number" && typeof nFftOrOptions !== "object") {
+    throw new TypeError("timeStretch: nFft must be an integer or options object");
+  }
+  if (nFftOrOptions === null) {
+    throw new TypeError("timeStretch: nFft must be an integer or options object");
+  }
+  const positionalOptions = typeof nFftOrOptions === "object" && nFftOrOptions !== null ? nFftOrOptions : options;
+  const positionalNFft = typeof nFftOrOptions === "number" ? nFftOrOptions : void 0;
+  const request = samples instanceof Float32Array ? {
+    samples,
+    sampleRate,
+    rate,
+    nFft: positionalNFft,
+    hopLength,
+    ...positionalOptions
+  } : samples;
   assertSamples("timeStretch", request.samples, request.validate !== false);
-  return requireModule().timeStretch(request.samples, request.sampleRate ?? 22050, request.rate);
+  const fftOptions = resolveEffectFftOptions("timeStretch", request.nFft, request.hopLength);
+  return requireModule().timeStretchEx(
+    request.samples,
+    request.sampleRate ?? 22050,
+    request.rate,
+    fftOptions.nFft,
+    fftOptions.hopLength
+  );
 }
-function pitchShift(samples, sampleRate, semitones, options = {}) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, semitones, ...options } : samples;
+function pitchShift(samples, sampleRate, semitones, nFftOrOptions, hopLength, options = {}) {
+  if (nFftOrOptions !== void 0 && nFftOrOptions !== null && typeof nFftOrOptions !== "number" && typeof nFftOrOptions !== "object") {
+    throw new TypeError("pitchShift: nFft must be an integer or options object");
+  }
+  if (nFftOrOptions === null) {
+    throw new TypeError("pitchShift: nFft must be an integer or options object");
+  }
+  const positionalOptions = typeof nFftOrOptions === "object" && nFftOrOptions !== null ? nFftOrOptions : options;
+  const positionalNFft = typeof nFftOrOptions === "number" ? nFftOrOptions : void 0;
+  const request = samples instanceof Float32Array ? {
+    samples,
+    sampleRate,
+    semitones,
+    nFft: positionalNFft,
+    hopLength,
+    ...positionalOptions
+  } : samples;
   assertSamples("pitchShift", request.samples, request.validate !== false);
-  return requireModule().pitchShift(
+  const fftOptions = resolveEffectFftOptions("pitchShift", request.nFft, request.hopLength);
+  return requireModule().pitchShiftEx(
     request.samples,
     request.sampleRate ?? 22050,
-    request.semitones
+    request.semitones,
+    fftOptions.nFft,
+    fftOptions.hopLength
   );
 }
 function pitchCorrectToMidi(samples, sampleRate = 22050, currentMidi = 69, targetMidi = 69, options = {}) {
@@ -341,13 +428,23 @@ function noteMove(samples, sampleRate = 22050, options = {}) {
     request.targetOnsetSample ?? 0
   );
 }
-function normalize(samples, sampleRate, targetDb = 0, options = {}) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, targetDb, ...options } : samples;
+function normalize(samples, sampleRate, targetDb = 0, modeOrOptions = "peak", options = {}) {
+  if (modeOrOptions !== void 0 && modeOrOptions !== null && typeof modeOrOptions !== "string" && typeof modeOrOptions !== "object") {
+    throw new TypeError("normalize: mode must be the string 'peak' or 'rms'");
+  }
+  if (modeOrOptions === null) {
+    throw new TypeError("normalize: mode must be the string 'peak' or 'rms'");
+  }
+  const positionalOptions = typeof modeOrOptions === "object" && modeOrOptions !== null ? modeOrOptions : options;
+  const positionalMode = typeof modeOrOptions === "string" ? modeOrOptions : void 0;
+  const request = samples instanceof Float32Array ? { samples, sampleRate, targetDb, mode: positionalMode, ...positionalOptions } : samples;
   assertSamples("normalize", request.samples, request.validate !== false);
-  return requireModule().normalize(
+  const mode = resolveNormalizeMode(request.mode);
+  return requireModule().normalizeEx(
     request.samples,
     request.sampleRate ?? 22050,
-    request.targetDb ?? 0
+    request.targetDb ?? 0,
+    mode
   );
 }
 function spectralEdit(samples, sampleRate, ops = [], options = {}) {
@@ -405,6 +502,8 @@ function flattenChainConfig(config) {
         out[path] = value;
       } else if (value !== null && typeof value === "object") {
         walk(value, path);
+      } else if (value !== void 0) {
+        throw new TypeError(`Mastering override '${path}' must be a number or boolean.`);
       }
     }
   };
@@ -446,12 +545,14 @@ function masterAudioStereoRequest(requestOrLeft, right, sampleRate, preset, over
 }
 function masteringChain(samples, sampleRate = 22050, config = {}, onProgress) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, config, onProgress } : samples;
-  if (request.onProgress) {
+  if (request.onProgress || request.cancel) {
     return requireModule3().masteringChainWithProgress(
       request.samples,
       request.sampleRate ?? 22050,
       canonicalChainConfig(request.config ?? {}),
-      request.onProgress
+      request.onProgress ?? (() => {
+      }),
+      request.cancel ?? (() => false)
     );
   }
   return requireModule3().masteringChain(
@@ -465,13 +566,15 @@ function masteringChainStereo(left, right, sampleRate = 22050, config = {}, onPr
   if (request.left.length !== request.right.length) {
     throw new Error("Stereo channel lengths must match.");
   }
-  if (request.onProgress) {
+  if (request.onProgress || request.cancel) {
     return requireModule3().masteringChainStereoWithProgress(
       request.left,
       request.right,
       request.sampleRate ?? 22050,
       canonicalChainConfig(request.config ?? {}),
-      request.onProgress
+      request.onProgress ?? (() => {
+      }),
+      request.cancel ?? (() => false)
     );
   }
   return requireModule3().masteringChainStereo(
@@ -490,7 +593,8 @@ function masteringChainWithProgress(samples, sampleRate = 22050, config = {}, on
     request.samples,
     request.sampleRate ?? 22050,
     canonicalChainConfig(request.config ?? {}),
-    request.onProgress
+    request.onProgress,
+    request.cancel ?? (() => false)
   );
 }
 function masteringChainStereoWithProgress(left, right, sampleRate = 22050, config = {}, onProgress) {
@@ -506,7 +610,8 @@ function masteringChainStereoWithProgress(left, right, sampleRate = 22050, confi
     request.right,
     request.sampleRate ?? 22050,
     canonicalChainConfig(request.config ?? {}),
-    request.onProgress
+    request.onProgress,
+    request.cancel ?? (() => false)
   );
 }
 function masteringPresetNames() {
@@ -515,13 +620,15 @@ function masteringPresetNames() {
 function masterAudio(samples, sampleRate = 22050, presetName = "pop", overrides = {}, onProgress) {
   const request = masterAudioRequest(samples, sampleRate, presetName, overrides, onProgress);
   const flat = flattenChainConfig(request.overrides ?? {});
-  if (request.onProgress) {
+  if (request.onProgress || request.cancel) {
     return requireModule3().masterAudioWithProgress(
       request.preset ?? "pop",
       request.samples,
       request.sampleRate ?? 22050,
       flat,
-      request.onProgress
+      request.onProgress ?? (() => {
+      }),
+      request.cancel ?? (() => false)
     );
   }
   return requireModule3().masterAudio(
@@ -544,14 +651,16 @@ function masterAudioStereo(left, right = void 0, sampleRate = 22050, presetName
   if (request.left.length !== request.right.length) {
     throw new Error("Stereo channel lengths must match.");
   }
-  if (request.onProgress) {
+  if (request.onProgress || request.cancel) {
     return requireModule3().masterAudioStereoWithProgress(
       request.preset ?? "pop",
       request.left,
       request.right,
       request.sampleRate ?? 22050,
       flat,
-      request.onProgress
+      request.onProgress ?? (() => {
+      }),
+      request.cancel ?? (() => false)
     );
   }
   return requireModule3().masterAudioStereo(
@@ -572,7 +681,8 @@ function masterAudioWithProgress(samples, sampleRate = 22050, presetName = "pop"
     request.samples,
     request.sampleRate ?? 22050,
     flattenChainConfig(request.overrides ?? {}),
-    request.onProgress
+    request.onProgress,
+    request.cancel ?? (() => false)
   );
 }
 function masterAudioStereoWithProgress(left, right = void 0, sampleRate = 22050, presetName = "pop", overrides = null, onProgress) {
@@ -596,7 +706,8 @@ function masterAudioStereoWithProgress(left, right = void 0, sampleRate = 22050,
     request.right,
     request.sampleRate ?? 22050,
     flattenChainConfig(request.overrides ?? {}),
-    request.onProgress
+    request.onProgress,
+    request.cancel ?? (() => false)
   );
 }
 
@@ -759,7 +870,10 @@ function masteringDynamicsCompressor(samples, sampleRate, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("masteringDynamicsCompressor", request.samples, request.validate !== false);
   const detector = typeof request.detector === "string" ? COMPRESSOR_DETECTOR_MAP[request.detector] : request.detector;
-  const opts = { ...request };
+  const opts = Object.assign(
+    Object.create(Object.getPrototypeOf(request)),
+    request
+  );
   if (detector !== void 0) {
     opts.detector = detector;
   }
@@ -848,6 +962,36 @@ function mixStereo(leftChannels, rightChannels, sampleRate = 48e3, options = {})
 function requireModule8() {
   return getSonareModule();
 }
+function tone(frequency = 440, sampleRate = 22050, duration = 1, phase = 0, amplitude = 1) {
+  const request = typeof frequency === "number" ? { frequency, sampleRate, duration, phase, amplitude } : frequency;
+  return requireModule8().tone(
+    request.frequency ?? 440,
+    request.sampleRate ?? 22050,
+    request.duration ?? 1,
+    request.phase ?? 0,
+    request.amplitude ?? 1
+  );
+}
+function chirp(fmin = 440, fmax = 880, sampleRate = 22050, duration = 1, linear = true) {
+  const request = typeof fmin === "number" ? { fmin, fmax, sampleRate, duration, linear } : fmin;
+  return requireModule8().chirp(
+    request.fmin ?? 440,
+    request.fmax ?? 880,
+    request.sampleRate ?? 22050,
+    request.duration ?? 1,
+    request.linear ?? true
+  );
+}
+function clicks(times, sampleRate = 22050, length = 0, frequency = 1e3, clickDuration = 0.1) {
+  const request = times instanceof Float32Array ? { times, sampleRate, length, frequency, clickDuration } : times;
+  return requireModule8().clicks(
+    request.times,
+    request.sampleRate ?? 22050,
+    request.length ?? 0,
+    request.frequency ?? 1e3,
+    request.clickDuration ?? 0.1
+  );
+}
 function hzToMel(hz) {
   return requireModule8().hzToMel(hz);
 }
@@ -944,6 +1088,12 @@ function fixFrames(frames, xMin = 0, xMax = -1, pad = true) {
   }
   return requireModule8().fixFrames(frames, xMin, xMax, pad);
 }
+function onsetBacktrack(events, energy) {
+  if (!(events instanceof Int32Array)) {
+    return onsetBacktrack(events.events, events.energy);
+  }
+  return requireModule8().onsetBacktrack(events, energy);
+}
 function peakPick(values, preMax, postMax, preAvg, postAvg, delta, wait) {
   if (!(values instanceof Float32Array)) {
     const r = values;
@@ -988,12 +1138,28 @@ function tonnetz(chromagram, nChroma, nFrames) {
   }
   return requireModule8().tonnetz(chromagram, nChroma, nFrames);
 }
-function tempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, mode = "autocorrelation") {
+function tempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, mode = "autocorrelation", center = true, norm = true) {
   if (!(onsetEnvelope2 instanceof Float32Array)) {
     const r = onsetEnvelope2;
-    return tempogram(r.onsetEnvelope, r.sampleRate, r.hopLength, r.winLength, r.mode);
+    return tempogram(
+      r.onsetEnvelope,
+      r.sampleRate,
+      r.hopLength,
+      r.winLength,
+      r.mode,
+      r.center,
+      r.norm
+    );
   }
-  return requireModule8().tempogram(onsetEnvelope2, sampleRate, hopLength, winLength, mode);
+  return requireModule8().tempogram(
+    onsetEnvelope2,
+    sampleRate,
+    hopLength,
+    winLength,
+    mode,
+    center,
+    norm
+  );
 }
 function cyclicTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, bpmMin = 60, nBins = 60) {
   if (!(onsetEnvelope2 instanceof Float32Array)) {
@@ -1054,12 +1220,18 @@ function nnlsChroma(samples, sampleRate = 22050, options = {}) {
     return nnlsChroma(samples.samples, samples.sampleRate, samples);
   }
   validateMusicSamples("nnlsChroma", samples, sampleRate, options);
-  return requireModule9().nnlsChroma(
+  const hopLength = options.hopLength === void 0 ? 512 : options.hopLength;
+  assertPositiveInteger("nnlsChroma", hopLength, "hopLength");
+  if (hopLength > 2 ** 31 - 1) {
+    throw new RangeError("nnlsChroma: hopLength must fit in a signed 32-bit integer");
+  }
+  return requireModule9().nnlsChromaEx(
     samples,
     sampleRate,
     options.enableStftBlend ?? true,
     options.stftBlendWeight ?? 0.55,
-    options.stftBlendNFft ?? 4096
+    options.stftBlendNFft ?? 4096,
+    hopLength
   );
 }
 function cqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
@@ -1327,7 +1499,7 @@ function onsetStrengthMulti(samples, sampleRate = 22050, nFft = 2048, hopLength
   validatePositiveIntegers("onsetStrengthMulti", { nFft, hopLength, nMels, nBands });
   return requireModule9().onsetStrengthMulti(samples, sampleRate, nFft, hopLength, nMels, nBands);
 }
-function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, options = {}) {
+function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, center = true, norm = true, options = {}) {
   if (!(onsetEnvelope2 instanceof Float32Array)) {
     const request = onsetEnvelope2;
     return fourierTempogram(
@@ -1335,13 +1507,22 @@ function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, w
       request.sampleRate,
       request.hopLength,
       request.winLength,
+      request.center,
+      request.norm,
       request
     );
   }
   assertSampleRate("fourierTempogram", sampleRate);
   assertSamples("fourierTempogram", onsetEnvelope2, options.validate !== false, "onsetEnvelope");
   validatePositiveIntegers("fourierTempogram", { hopLength, winLength });
-  return requireModule9().fourierTempogram(onsetEnvelope2, sampleRate, hopLength, winLength);
+  return requireModule9().fourierTempogram(
+    onsetEnvelope2,
+    sampleRate,
+    hopLength,
+    winLength,
+    center,
+    norm
+  );
 }
 function tempogramRatio(tempogramData, winLength = 384, sampleRate = 22050, hopLength = 512, factors, options = {}) {
   if (!(tempogramData instanceof Float32Array)) {
@@ -1392,6 +1573,21 @@ function shortTermLufs(samples, sampleRate = 22050, options = {}) {
 function requireModule10() {
   return getSonareModule();
 }
+function piptrack(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 150, fmax = 4e3, threshold = 0.1) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return piptrack(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.threshold
+    );
+  }
+  return requireModule10().piptrack(samples, sampleRate, nFft, hopLength, fmin, fmax, threshold);
+}
 function pitchYin(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512, fmin = 65, fmax = 2093, threshold = 0.1, fillNa = false) {
   if (!(samples instanceof Float32Array)) {
     const request = samples;
@@ -1442,6 +1638,13 @@ function pitchPyin(samples, sampleRate = 22050, frameLength = 2048, hopLength =
     fillNa
   );
 }
+function noteSegments(request) {
+  return requireModule10().noteSegments(request.f0Hz, request.voicedProb, request.frameRate, {
+    segmentationThresholdCents: request.segmentationThresholdCents,
+    minNoteMs: request.minNoteMs,
+    referenceHz: request.referenceHz
+  });
+}
 
 // src/feature_resample.ts
 function requireModule11() {
@@ -1458,6 +1661,44 @@ function resample(samples, srcSr, targetSr) {
 function requireModule12() {
   return getSonareModule();
 }
+function resolveEffectFftOptions2(fnName, nFft, hopLength) {
+  const resolvedNFft = nFft === void 0 ? 2048 : nFft;
+  const resolvedHopLength = hopLength === void 0 ? 512 : hopLength;
+  if (typeof resolvedNFft !== "number" || !Number.isInteger(resolvedNFft)) {
+    throw new TypeError(`${fnName}: nFft must be an integer`);
+  }
+  if (resolvedNFft < 2 || resolvedNFft > 2 ** 30) {
+    throw new RangeError(`${fnName}: nFft must be an even power of two >= 2`);
+  }
+  if ((resolvedNFft & resolvedNFft - 1) !== 0) {
+    throw new RangeError(`${fnName}: nFft must be an even power of two >= 2`);
+  }
+  if (typeof resolvedHopLength !== "number" || !Number.isInteger(resolvedHopLength)) {
+    throw new TypeError(`${fnName}: hopLength must be an integer`);
+  }
+  if (resolvedHopLength <= 0 || resolvedHopLength > 2 ** 31 - 1) {
+    throw new RangeError(`${fnName}: hopLength must be a positive integer`);
+  }
+  return { nFft: resolvedNFft, hopLength: resolvedHopLength };
+}
+function resolveHardMask2(fnName, value) {
+  if (value === void 0) {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    throw new TypeError(`${fnName}: hardMask must be a boolean`);
+  }
+  return value;
+}
+function validateSegmentMatrix(fnName, data, rows, cols, dataName) {
+  assertPositiveInteger(fnName, rows, "rows");
+  assertPositiveInteger(fnName, cols, "cols");
+  assertSamples(fnName, data, true, dataName);
+  const expected = rows * cols;
+  if (!Number.isSafeInteger(expected) || data.length !== expected) {
+    throw new RangeError(`${fnName}: ${dataName} length must equal rows * cols`);
+  }
+}
 function spectralCentroid(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
   if (!(samples instanceof Float32Array)) {
     return spectralCentroid(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
@@ -1580,12 +1821,30 @@ function phaseVocoder(samples, sampleRate = 22050, rate = 1, nFft = 2048, hopLen
   }
   return requireModule12().phaseVocoder(samples, sampleRate, rate, nFft, hopLength);
 }
-function hpssWithResidual(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31) {
+function hpssWithResidual(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31, nFft, hopLength, hardMask) {
   if (!(samples instanceof Float32Array)) {
     const r = samples;
-    return hpssWithResidual(r.samples, r.sampleRate, r.kernelHarmonic, r.kernelPercussive);
+    return hpssWithResidual(
+      r.samples,
+      r.sampleRate,
+      r.kernelHarmonic,
+      r.kernelPercussive,
+      r.nFft,
+      r.hopLength,
+      r.hardMask
+    );
   }
-  return requireModule12().hpssWithResidual(samples, sampleRate, kernelHarmonic, kernelPercussive);
+  const fftOptions = resolveEffectFftOptions2("hpssWithResidual", nFft, hopLength);
+  const resolvedHardMask = resolveHardMask2("hpssWithResidual", hardMask);
+  return requireModule12().hpssWithResidualEx(
+    samples,
+    sampleRate,
+    kernelHarmonic,
+    kernelPercussive,
+    fftOptions.nFft,
+    fftOptions.hopLength,
+    resolvedHardMask
+  );
 }
 function lufsInterleaved(samples, channels = 0, sampleRate = 22050, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1602,11 +1861,17 @@ function ebur128LoudnessRange(samples, sampleRate = 22050) {
   }
   return requireModule12().ebur128LoudnessRange(samples, sampleRate);
 }
-function spectralBandwidth(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
+function spectralBandwidth(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, p = 2) {
   if (!(samples instanceof Float32Array)) {
-    return spectralBandwidth(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
+    return spectralBandwidth(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.p
+    );
   }
-  return requireModule12().spectralBandwidth(samples, sampleRate, nFft, hopLength);
+  return requireModule12().spectralBandwidth(samples, sampleRate, nFft, hopLength, p);
 }
 function spectralRolloff(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, rollPercent = 0.85) {
   if (!(samples instanceof Float32Array)) {
@@ -1626,6 +1891,18 @@ function spectralFlatness(samples, sampleRate = 22050, nFft = 2048, hopLength =
   }
   return requireModule12().spectralFlatness(samples, sampleRate, nFft, hopLength);
 }
+function spectralFlux(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, lag = 1) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralFlux(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.lag
+    );
+  }
+  return requireModule12().spectralFlux(samples, sampleRate, nFft, hopLength, lag);
+}
 function zeroCrossingRate(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
   if (!(samples instanceof Float32Array)) {
     return zeroCrossingRate(
@@ -1643,6 +1920,107 @@ function rmsEnergy(samples, sampleRate = 22050, frameLength = 2048, hopLength =
   }
   return requireModule12().rmsEnergy(samples, sampleRate, frameLength, hopLength);
 }
+function segmentCrossSimilarity(request) {
+  validateSegmentMatrix("segmentCrossSimilarity", request.x, request.xRows, request.xCols, "x");
+  validateSegmentMatrix("segmentCrossSimilarity", request.y, request.yRows, request.yCols, "y");
+  if (request.xRows !== request.yRows) {
+    throw new RangeError("segmentCrossSimilarity: feature dimensions must match");
+  }
+  assertNonNegativeInteger("segmentCrossSimilarity", request.k ?? 0, "k");
+  return requireModule12().segmentCrossSimilarity(
+    request.x,
+    request.xRows,
+    request.xCols,
+    request.y,
+    request.yRows,
+    request.yCols,
+    request.k ?? 0,
+    request.metric ?? "cosine",
+    request.mode ?? "connectivity"
+  );
+}
+function segmentRecurrenceMatrix(request) {
+  validateSegmentMatrix(
+    "segmentRecurrenceMatrix",
+    request.data,
+    request.rows,
+    request.cols,
+    "data"
+  );
+  assertNonNegativeInteger("segmentRecurrenceMatrix", request.k ?? 0, "k");
+  assertNonNegativeInteger("segmentRecurrenceMatrix", request.width ?? 1, "width");
+  return requireModule12().segmentRecurrenceMatrix(
+    request.data,
+    request.rows,
+    request.cols,
+    request.k ?? 0,
+    request.width ?? 1,
+    request.sym ?? false,
+    request.metric ?? "euclidean",
+    request.mode ?? "connectivity"
+  );
+}
+function segmentRecurrenceToLag(request) {
+  validateSegmentMatrix(
+    "segmentRecurrenceToLag",
+    request.recurrence,
+    request.n,
+    request.n,
+    "recurrence"
+  );
+  return requireModule12().segmentRecurrenceToLag(
+    request.recurrence,
+    request.n,
+    request.pad ?? false
+  );
+}
+function segmentLagToRecurrence(request) {
+  validateSegmentMatrix("segmentLagToRecurrence", request.lag, request.rows, request.lags, "lag");
+  return requireModule12().segmentLagToRecurrence(request.lag, request.rows, request.lags);
+}
+function segmentSubsegment(request) {
+  validateSegmentMatrix("segmentSubsegment", request.data, request.rows, request.cols, "data");
+  assertPositiveInteger("segmentSubsegment", request.nSegments ?? 4, "nSegments");
+  return requireModule12().segmentSubsegment(
+    request.data,
+    request.rows,
+    request.cols,
+    request.boundaries,
+    request.nSegments ?? 4
+  );
+}
+function segmentAgglomerative(request) {
+  validateSegmentMatrix("segmentAgglomerative", request.data, request.rows, request.cols, "data");
+  assertPositiveInteger("segmentAgglomerative", request.k, "k");
+  return requireModule12().segmentAgglomerative(
+    request.data,
+    request.rows,
+    request.cols,
+    request.k,
+    request.linkage ?? "average"
+  );
+}
+function segmentPathEnhance(request) {
+  validateSegmentMatrix(
+    "segmentPathEnhance",
+    request.recurrence,
+    request.n,
+    request.n,
+    "recurrence"
+  );
+  assertPositiveInteger("segmentPathEnhance", request.win, "win");
+  assertPositiveInteger("segmentPathEnhance", request.maxRatio ?? 2, "maxRatio");
+  assertNonNegativeInteger("segmentPathEnhance", request.minRatio ?? 0, "minRatio");
+  assertPositiveInteger("segmentPathEnhance", request.nFilters ?? 7, "nFilters");
+  return requireModule12().segmentPathEnhance(
+    request.recurrence,
+    request.n,
+    request.win,
+    request.maxRatio ?? 2,
+    request.minRatio ?? 0,
+    request.nFilters ?? 7
+  );
+}
 
 // src/feature_spectrogram.ts
 function requireModule13() {
@@ -1679,14 +2057,35 @@ function validateMatrix(fnName, data, rows, frames, dataName, rowName, options =
     throw new RangeError(`${fnName}: ${dataName} length must equal ${rowName} * nFrames`);
   }
 }
-function trim(samples, sampleRate = 22050, thresholdDb = -60, options = {}) {
+function trim(samples, sampleRate = 22050, thresholdDb = -60, frameLengthOrOptions, hopLength, options = {}) {
   if (!(samples instanceof Float32Array)) {
     const r = samples;
-    return trim(r.samples, r.sampleRate, r.thresholdDb, r);
+    return trim(r.samples, r.sampleRate, r.thresholdDb, r.frameLength, r.hopLength, r);
+  }
+  if (frameLengthOrOptions === null) {
+    throw new TypeError("trim: frameLength must be an integer or options object");
+  }
+  if (frameLengthOrOptions !== void 0 && typeof frameLengthOrOptions !== "number" && typeof frameLengthOrOptions !== "object") {
+    throw new TypeError("trim: frameLength must be an integer or options object");
   }
-  validateSpectrogramSamples("trim", samples, sampleRate, options);
+  const positionalOptions = typeof frameLengthOrOptions === "object" && frameLengthOrOptions !== null ? frameLengthOrOptions : options;
+  const positionalFrameLength = typeof frameLengthOrOptions === "number" ? frameLengthOrOptions : void 0;
+  const resolvedFrameLength = positionalFrameLength ?? 2048;
+  const resolvedHopLength = hopLength === void 0 ? 512 : hopLength;
+  validateSpectrogramSamples("trim", samples, sampleRate, positionalOptions);
   assertFiniteScalar("trim", thresholdDb, "thresholdDb");
-  return requireModule13().trim(samples, sampleRate, thresholdDb);
+  assertPositiveInteger("trim", resolvedFrameLength, "frameLength");
+  assertPositiveInteger("trim", resolvedHopLength, "hopLength");
+  if (resolvedFrameLength > 2 ** 31 - 1 || resolvedHopLength > 2 ** 31 - 1) {
+    throw new RangeError("trim: frameLength and hopLength must fit in a signed 32-bit integer");
+  }
+  return requireModule13().trimEx(
+    samples,
+    sampleRate,
+    thresholdDb,
+    resolvedFrameLength,
+    resolvedHopLength
+  );
 }
 function stft(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1821,6 +2220,53 @@ function mfcc(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels =
     lifter
   );
 }
+function melDelta(features, nFeatures, nFrames, width = 9) {
+  const request = features instanceof Float32Array ? { features, nFeatures: nFeatures ?? 0, nFrames: nFrames ?? 0, width } : features;
+  assertPositiveInteger("melDelta", request.nFeatures, "nFeatures");
+  assertPositiveInteger("melDelta", request.nFrames, "nFrames");
+  assertPositiveInteger("melDelta", request.width ?? 9, "width");
+  if ((request.width ?? 9) < 3 || (request.width ?? 9) % 2 === 0) {
+    throw new RangeError("melDelta: width must be an odd integer of at least 3");
+  }
+  if (request.features.length !== request.nFeatures * request.nFrames) {
+    throw new RangeError("melDelta: feature matrix length must equal nFeatures * nFrames");
+  }
+  return requireModule13().melDelta(
+    request.features,
+    request.nFeatures,
+    request.nFrames,
+    request.width ?? 9
+  );
+}
+function reassignedSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, refPower = 1e-6, fillNan = false) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return reassignedSpectrogram(
+      request.samples,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.refPower,
+      request.fillNan
+    );
+  }
+  assertSamples("reassignedSpectrogram", samples, true);
+  assertSampleRate("reassignedSpectrogram", sampleRate);
+  assertPositiveInteger("reassignedSpectrogram", nFft, "nFft");
+  assertPositiveInteger("reassignedSpectrogram", hopLength, "hopLength");
+  assertFiniteScalar("reassignedSpectrogram", refPower, "refPower");
+  if (refPower < 0) {
+    throw new RangeError("reassignedSpectrogram: refPower must be non-negative");
+  }
+  return requireModule13().reassignedSpectrogram(
+    samples,
+    sampleRate,
+    nFft,
+    hopLength,
+    refPower,
+    fillNan
+  );
+}
 function melToStft(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, fmin = 0, fmax = 0, htk = false, options = {}) {
   if (!(melPower instanceof Float32Array)) {
     const request = melPower;
@@ -1876,6 +2322,35 @@ function melToAudio(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft =
     htk
   );
 }
+function griffinLim(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, hopLength = 512, nIter = 32, momentum = 0.99, options = {}) {
+  if (!(magnitude instanceof Float32Array)) {
+    const request = magnitude;
+    return griffinLim(
+      request.magnitude,
+      request.nBins,
+      request.nFrames,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.nIter,
+      request.momentum,
+      request
+    );
+  }
+  assertSampleRate("griffinLim", sampleRate);
+  validateMatrix("griffinLim", magnitude, nBins, nFrames, "magnitude", "nBins", options);
+  validatePositiveIntegers2("griffinLim", { nFft, hopLength, nIter });
+  return requireModule13().griffinLim(
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    nFft,
+    hopLength,
+    nIter,
+    momentum
+  );
+}
 function mfccToMel(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, lifter = 0, options = {}) {
   if (!(mfccCoefficients instanceof Float32Array)) {
     const request = mfccCoefficients;
@@ -1956,6 +2431,88 @@ function chroma(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, optio
   return requireModule13().chroma(samples, sampleRate, nFft, hopLength);
 }
 
+// src/codes.ts
+function resolveOrdinalInRange(value, min, max, enumName) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+    throw new RangeError(`Invalid ${enumName}: ${String(value)}`);
+  }
+  return value;
+}
+function resolveEnumOrdinal(value, values, enumName) {
+  if (typeof value === "number") {
+    const ordinals = Object.values(values);
+    const ordinal = resolveOrdinalInRange(
+      value,
+      Math.min(...ordinals),
+      Math.max(...ordinals),
+      enumName
+    );
+    if (!ordinals.includes(ordinal)) {
+      throw new RangeError(`Invalid ${enumName}: ${String(value)}`);
+    }
+    return ordinal;
+  }
+  if (typeof value === "string") {
+    const ordinal = values[value];
+    if (ordinal !== void 0) {
+      return ordinal;
+    }
+  }
+  throw new RangeError(`Invalid ${enumName}: ${String(value)}`);
+}
+var AUTOMATION_CURVE_VALUES = {
+  linear: 0,
+  exponential: 1,
+  hold: 2,
+  "s-curve": 3
+};
+var PAN_LAW_VALUES = {
+  const3db: 0,
+  "const-3db": 0,
+  "-3db": 0,
+  "const4.5db": 1,
+  "const-4.5db": 1,
+  "-4.5db": 1,
+  const6db: 2,
+  "const-6db": 2,
+  "-6db": 2,
+  linear0db: 3,
+  "linear-0db": 3,
+  linear: 3,
+  "0db": 3
+};
+var PAN_MODE_VALUES = {
+  balance: 0,
+  pan: 1,
+  stereopan: 1,
+  "stereo-pan": 1,
+  dualpan: 2,
+  "dual-pan": 2
+};
+var METER_TAP_VALUES = { preFader: 0, postFader: 1 };
+var SEND_TIMING_VALUES = { postFader: 0, preFader: 1 };
+var TRACK_MONITOR_MODE_VALUES = { off: 0, pfl: 1, afl: 2 };
+function automationCurveCode(curve) {
+  return resolveEnumOrdinal(curve, AUTOMATION_CURVE_VALUES, "automation curve");
+}
+function panLawCode(panLaw) {
+  const normalized = typeof panLaw === "string" ? panLaw.toLowerCase().replace(/_/g, "-") : panLaw;
+  return resolveEnumOrdinal(normalized, PAN_LAW_VALUES, "pan law");
+}
+function panModeCode(panMode) {
+  const normalized = typeof panMode === "string" ? panMode.replace(/_/g, "-").toLowerCase() : panMode;
+  return resolveEnumOrdinal(normalized, PAN_MODE_VALUES, "pan mode");
+}
+function meterTapCode(tap) {
+  return resolveEnumOrdinal(tap, METER_TAP_VALUES, "meter tap");
+}
+function sendTimingCode(timing) {
+  return resolveEnumOrdinal(timing, SEND_TIMING_VALUES, "send timing");
+}
+function trackMonitorModeCode(mode) {
+  return resolveEnumOrdinal(mode, TRACK_MONITOR_MODE_VALUES, "track monitor mode");
+}
+
 // src/public_types_music.ts
 var PitchClass = {
   C: 0,
@@ -2049,6 +2606,30 @@ function convertKeyCandidate(wasm) {
     correlation: wasm.correlation
   };
 }
+var KEY_MODE_VALUES = {
+  major: Mode.Major,
+  minor: Mode.Minor,
+  dorian: Mode.Dorian,
+  phrygian: Mode.Phrygian,
+  lydian: Mode.Lydian,
+  mixolydian: Mode.Mixolydian,
+  locrian: Mode.Locrian
+};
+var KEY_PROFILE_VALUES = {
+  ks: KeyProfile.KrumhanslSchmuckler,
+  krumhansl: KeyProfile.KrumhanslSchmuckler,
+  temperley: KeyProfile.Temperley,
+  shaath: KeyProfile.Shaath,
+  keyfinder: KeyProfile.Shaath,
+  "faraldo-edmt": KeyProfile.FaraldoEDMT,
+  edmt: KeyProfile.FaraldoEDMT,
+  "faraldo-edma": KeyProfile.FaraldoEDMA,
+  edma: KeyProfile.FaraldoEDMA,
+  "faraldo-edmm": KeyProfile.FaraldoEDMM,
+  edmm: KeyProfile.FaraldoEDMM,
+  "bellman-budge": KeyProfile.BellmanBudge,
+  bellman: KeyProfile.BellmanBudge
+};
 function keyModeValues(modes) {
   if (!modes) {
     return [];
@@ -2067,40 +2648,13 @@ function keyModeValues(modes) {
       Mode.Locrian
     ];
   }
-  const names = {
-    major: Mode.Major,
-    minor: Mode.Minor,
-    dorian: Mode.Dorian,
-    phrygian: Mode.Phrygian,
-    lydian: Mode.Lydian,
-    mixolydian: Mode.Mixolydian,
-    locrian: Mode.Locrian
-  };
-  return modes.map((mode) => typeof mode === "number" ? mode : names[mode]);
+  return modes.map((mode) => resolveEnumOrdinal(mode, KEY_MODE_VALUES, "key mode"));
 }
 function keyProfileValue(profile) {
   if (profile === void 0) {
     return -1;
   }
-  if (typeof profile === "number") {
-    return profile;
-  }
-  const names = {
-    ks: KeyProfile.KrumhanslSchmuckler,
-    krumhansl: KeyProfile.KrumhanslSchmuckler,
-    temperley: KeyProfile.Temperley,
-    shaath: KeyProfile.Shaath,
-    keyfinder: KeyProfile.Shaath,
-    "faraldo-edmt": KeyProfile.FaraldoEDMT,
-    edmt: KeyProfile.FaraldoEDMT,
-    "faraldo-edma": KeyProfile.FaraldoEDMA,
-    edma: KeyProfile.FaraldoEDMA,
-    "faraldo-edmm": KeyProfile.FaraldoEDMM,
-    edmm: KeyProfile.FaraldoEDMM,
-    "bellman-budge": KeyProfile.BellmanBudge,
-    bellman: KeyProfile.BellmanBudge
-  };
-  return names[profile];
+  return resolveEnumOrdinal(profile, KEY_PROFILE_VALUES, "key profile");
 }
 function convertChordAnalysisResult(wasm) {
   return {
@@ -2134,6 +2688,11 @@ function convertAnalysisResult(wasm) {
   return {
     bpm: wasm.bpm,
     bpmConfidence: wasm.bpmConfidence,
+    bpmCandidates: wasm.bpmCandidates.map((candidate) => ({
+      value: candidate.value,
+      confidence: candidate.confidence,
+      relation: candidate.relation
+    })),
     key: {
       root: wasm.key.root,
       mode: wasm.key.mode,
@@ -2142,6 +2701,7 @@ function convertAnalysisResult(wasm) {
       shortName: wasm.key.shortName
     },
     timeSignature: wasm.timeSignature,
+    timeSignatureCandidates: wasm.timeSignatureCandidates,
     beatTimes,
     beats: wasm.beats,
     chords: wasm.chords.map((c) => ({
@@ -2232,7 +2792,7 @@ function detectKeyCandidates(samples, sampleRate = 22050, options = {}) {
 function detectOnsets(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectOnsets", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule14().detectOnsets(request.samples, request.sampleRate ?? 22050);
+  return requireModule14().detectOnsets(request.samples, request.sampleRate ?? 22050, request);
 }
 function detectBeats(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
@@ -2300,18 +2860,27 @@ function analyze(samples, sampleRate = 22050, options = {}) {
   const result = requireModule14().analyze(request.samples, request.sampleRate ?? 22050, request);
   return convertAnalysisResult(result);
 }
-function analyzeImpulseResponse(samples, sampleRate = 48e3, nOctaveBands = 6) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, nOctaveBands } : samples;
+function analyzeImpulseResponse(samples, sampleRate = 48e3, nOctaveBands = 6, minDecayDb) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, nOctaveBands, minDecayDb } : samples;
+  if (request.minDecayDb === null) {
+    throw new TypeError("analyzeImpulseResponse: minDecayDb must be a finite number");
+  }
+  const resolvedMinDecayDb = request.minDecayDb === void 0 ? 30 : request.minDecayDb;
+  assertFiniteScalar("analyzeImpulseResponse", resolvedMinDecayDb, "minDecayDb");
+  if (resolvedMinDecayDb <= 0) {
+    throw new RangeError("analyzeImpulseResponse: minDecayDb must be greater than zero");
+  }
   validateAnalysisInput(
     "analyzeImpulseResponse",
     request.samples,
     request.sampleRate ?? 48e3,
     request
   );
-  const result = requireModule14().analyzeImpulseResponse(
+  const result = requireModule14().analyzeImpulseResponseEx(
     request.samples,
     request.sampleRate ?? 48e3,
-    request.nOctaveBands ?? 6
+    request.nOctaveBands ?? 6,
+    resolvedMinDecayDb
   );
   return result;
 }
@@ -2364,7 +2933,9 @@ function analyzeWithProgress(samples, sampleRate = 22050, onProgress) {
   const result = requireModule14().analyzeWithProgress(
     request.samples,
     request.sampleRate ?? 22050,
-    request.onProgress
+    request.onProgress ?? (() => {
+    }),
+    request.cancel ?? (() => false)
   );
   return convertAnalysisResult(result);
 }
@@ -2518,9 +3089,14 @@ var Audio = class _Audio {
       }
     }
   }
-  /** The raw audio samples. */
+  /**
+   * A copy of the raw audio samples. Mirrors Node's `getData()` contract: the
+   * returned array is independent of the Audio's internal buffer, so mutating
+   * it (or transferring it to a Worker) does not affect subsequent facade
+   * calls, which all read the internal snapshot directly.
+   */
   get data() {
-    return this._samples;
+    return this._samples.slice();
   }
   /** Number of samples. */
   get length() {
@@ -2788,7 +3364,12 @@ self.onmessage = async (event) => {
 `;
 function createOpfsClipPageWorker() {
   const blob = new Blob([opfsClipPageWorkerSource], { type: "text/javascript" });
-  return new Worker(URL.createObjectURL(blob));
+  const url = URL.createObjectURL(blob);
+  try {
+    return new Worker(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
 }
 function createOpfsClipPageProvider(engine, options) {
   if (options.numChannels <= 0 || options.numSamples <= 0 || options.pageFrames <= 0) {
@@ -2828,6 +3409,7 @@ function createOpfsClipPageProvider(engine, options) {
     }
     try {
       provider.supply(response.pageIndex, channels);
+      options.onPageSupplied?.(response.pageIndex, channels);
     } catch {
       entry.resolve(false);
       return;
@@ -2875,6 +3457,13 @@ function createOpfsClipPageProvider(engine, options) {
     supplyRequest(request) {
       return supplyPage(Math.floor(request.sample / options.pageFrames));
     },
+    clearPage(pageIndex) {
+      if (closed) {
+        return;
+      }
+      provider.clear(pageIndex);
+      options.onPageCleared?.(pageIndex);
+    },
     close() {
       if (closed) {
         return;
@@ -2886,6 +3475,7 @@ function createOpfsClipPageProvider(engine, options) {
       }
       pending.clear();
       provider.destroy();
+      options.onClose?.();
       if (ownsWorker) {
         worker.terminate();
       }
@@ -2963,7 +3553,10 @@ var ClipPageStreamer = class {
       if (!state) {
         continue;
       }
-      const page = Math.floor(request.sample / state.source.pageFrames);
+      const page = request.pageIndex !== void 0 ? request.pageIndex : Math.floor((request.sample ?? Number.NaN) / state.source.pageFrames);
+      if (!Number.isInteger(page) || page < 0 || page > state.lastPage) {
+        continue;
+      }
       frontiers.set(request.clipId, page);
     }
     const fetches = [];
@@ -2998,7 +3591,7 @@ var ClipPageStreamer = class {
     const high = Math.min(state.lastPage, frontier + this.readAheadPages);
     for (const page of state.resident.keys()) {
       if (page < low || page > high) {
-        state.source.binding.provider.clear(page);
+        this.clearPage(state, page);
         state.resident.delete(page);
       }
     }
@@ -3013,7 +3606,7 @@ var ClipPageStreamer = class {
         state.source.binding.supplyPage(pageIndex).then(
           (ok) => {
             if (state.generation !== generation) {
-              state.source.binding.provider.clear(pageIndex);
+              this.clearPage(state, pageIndex);
             } else if (!ok && state.resident.get(pageIndex) === generation) {
               state.resident.delete(pageIndex);
             }
@@ -3034,12 +3627,28 @@ var ClipPageStreamer = class {
     state.generation += 1;
     state.lastFrontier = null;
     for (const page of state.resident.keys()) {
-      state.source.binding.provider.clear(page);
+      this.clearPage(state, page);
     }
     state.resident.clear();
   }
+  clearPage(state, pageIndex) {
+    if (state.source.binding.clearPage) {
+      state.source.binding.clearPage(pageIndex);
+    } else {
+      state.source.binding.provider.clear(pageIndex);
+    }
+  }
 };
-async function attachOpfsClipStream(streamer, engine, options) {
+async function attachOpfsClipStream(streamerOrEngine, engineOrOptions, maybeOptions) {
+  if (!(streamerOrEngine instanceof ClipPageStreamer)) {
+    return streamerOrEngine.attachOpfsClipStream(engineOrOptions);
+  }
+  const streamer = streamerOrEngine;
+  const engine = engineOrOptions;
+  const options = maybeOptions;
+  if (!options) {
+    throw new Error("attachOpfsClipStream requires options.");
+  }
   const { clipId, primePages = 1, ...providerOptions } = options;
   const binding = createOpfsClipPageProvider(engine, providerOptions);
   const lastPage = Math.ceil(providerOptions.numSamples / providerOptions.pageFrames) - 1;
@@ -3095,7 +3704,11 @@ async function bindMicrophoneInput(context, engine, options = {}) {
 function assertOversampleFactor(fnName, factor) {
   const normalized = factor === 0 ? 4 : factor;
   if (!Number.isInteger(normalized) || normalized < 1 || normalized > 16 || (normalized & normalized - 1) !== 0) {
-    throw new RangeError(`${fnName}: oversampleFactor must be 0 or a power of two from 1 to 16`);
+    throw new SonareError(
+      4 /* InvalidParameter */,
+      "InvalidParameter",
+      `${fnName}: oversampleFactor must be 0 or a power of two from 1 to 16`
+    );
   }
 }
 function requireModule15() {
@@ -3341,44 +3954,61 @@ function assertProjectMidiEvents(fnName, events) {
   });
 }
 function projectTrackKindValue(kind) {
-  if (kind === void 0 || kind === "audio") {
-    return 0;
-  }
-  if (kind === "midi") {
-    return 1;
-  }
-  if (kind === "aux") {
-    return 2;
-  }
-  return kind;
+  return resolveEnumOrdinal(kind ?? "audio", { audio: 0, midi: 1, aux: 2 }, "project track kind");
+}
+function projectAutomationTargetKindValue(kind) {
+  return resolveEnumOrdinal(
+    kind,
+    { opaque: 0, "track-fader-db": 1, "track-pan": 2 },
+    "project automation target kind"
+  );
 }
 function projectWarpModeValue(mode) {
-  if (mode === void 0 || mode === "off") {
-    return 0;
-  }
-  if (mode === "repitch") {
-    return 1;
+  return resolveEnumOrdinal(
+    mode ?? "off",
+    { off: 0, repitch: 1, "tempo-sync": 2 },
+    "project warp mode"
+  );
+}
+function projectLoopModeValue(mode) {
+  return resolveEnumOrdinal(mode ?? "off", { off: 0, loop: 1 }, "project loop mode");
+}
+
+// src/project_class.ts
+function validateAssistSidecarUint32(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+    throw new RangeError(`Project.setAssistSidecar: ${field} must be a uint32`);
   }
-  if (mode === "tempo-sync") {
-    return 2;
+  return value;
+}
+function validateAssistSidecarPpq(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new RangeError(
+      `Project.setAssistSidecar: ${field} must be a finite, non-negative number`
+    );
   }
-  return mode;
+  return value;
 }
-function projectLoopModeValue(mode) {
-  if (mode === void 0 || mode === "off") {
-    return 0;
+function validateAssistSidecarPayload(value) {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError("Project.setAssistSidecar: payload must be a Uint8Array");
   }
-  if (mode === "loop") {
-    return 1;
+  return value;
+}
+function validateAssistSidecarModuleId(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError("Project.setAssistSidecar: moduleId must be a non-empty string");
   }
-  return mode;
+  return value;
 }
-
-// src/project_class.ts
 var Project = class _Project {
   constructor() {
     this.native = new (projectModule()).Project();
   }
+  /** Create a new empty project. */
+  static create() {
+    return new _Project();
+  }
   /** Pack a MIDI 1.0 note-on event accepted by {@link setMidiEvents}. */
   static midiNoteOn(ppq, group, channel, note, velocity) {
     return projectMidi1Event("Project.midiNoteOn", ppq, group, 9, channel, note, velocity);
@@ -3544,6 +4174,16 @@ var Project = class _Project {
   addClip(desc) {
     return this.native.addClip(desc);
   }
+  /** Import host-separated PCM through the normal audio-track/clip path. */
+  importExternalStems(request) {
+    return this.native.importExternalStems({
+      ...request,
+      stems: request.stems.map((stem) => ({
+        ...stem,
+        layout: stem.layout === "mono" ? 1 : stem.layout === "stereo" ? 2 : stem.layout
+      }))
+    });
+  }
   /** Split captured loop-recording audio into takes and add one clip. */
   addLoopRecordingTakes(desc) {
     return this.native.addLoopRecordingTakes(desc);
@@ -3588,7 +4228,11 @@ var Project = class _Project {
    * Route a track's MIDI to host-instrument `destinationId` (0 = default). The
    * compiler stamps every MIDI clip on the track with this id so the engine
    * dispatches its events to the instrument registered for that destination.
-   * Routes through an undoable edit command.
+   * Routes through an undoable edit command. Builtin, NativeSynth, and SF2
+   * instruments retain source-track provenance inside a shared destination
+   * voice pool. With only zero-latency instruments bound, live lanes and
+   * channel-strip bounces remain aligned. Configure one live lane per source
+   * track that needs strip processing.
    */
   setTrackMidiDestination(trackId, destinationId) {
     this.native.setTrackMidiDestination(trackId, destinationId);
@@ -3628,6 +4272,18 @@ var Project = class _Project {
     }
     this.native.setMaxUndoDepth(depth);
   }
+  /** Set the combined undo/redo history byte cap. Zero disables retention. */
+  setMaxHistoryBytes(bytes) {
+    if (typeof bytes !== "number") {
+      throw new TypeError("Project.setMaxHistoryBytes: bytes must be a number");
+    }
+    if (!Number.isFinite(bytes) || !Number.isInteger(bytes) || bytes < 0 || bytes > 4294967295) {
+      throw new RangeError(
+        "Project.setMaxHistoryBytes: bytes must be a finite integer in the uint32 range"
+      );
+    }
+    this.native.setMaxHistoryBytes(bytes);
+  }
   /** Replace a MIDI clip's entire event list. */
   setMidiEvents(clipId, events) {
     assertProjectMidiEvents("Project.setMidiEvents", events);
@@ -3758,8 +4414,11 @@ var Project = class _Project {
    * Karplus-Strong / modal / additive / percussion / extended-waveguide-piano
    * engines plus the realism layer). Pass a {@link SynthPatch}, a preset-name
    * string (`'saw-lead'` / `'va:saw-lead'`; see {@link synthPresetNames}), or
-   * an array of either; each object entry may carry a `destinationId` binding
-   * convenience (default 0), which is not part of the NativeSynth patch itself.
+   * an array of either; each object entry may carry `destinationId` (default
+   * 0) and `useGmPrograms` (default `false`) binding conveniences, neither of
+   * which is part of the NativeSynth patch itself. When enabled, MIDI program
+   * changes select the corresponding General MIDI voice while the patch remains
+   * the fallback.
    * Because the parameter defaults to `{}`, omission and explicit `undefined`
    * both create one default binding. Use an explicitly empty array `[]` (or
    * runtime `null`) for zero bindings. Unknown preset names throw.
@@ -3825,6 +4484,18 @@ var Project = class _Project {
   setClipFade(clipId, fadeIn = {}, fadeOut = {}) {
     this.native.setClipFade(clipId, fadeIn, fadeOut);
   }
+  /** Audio source ids that need decoded PCM after deserialization. */
+  unresolvedAudioSourceIds() {
+    return this.native.unresolvedAudioSourceIds();
+  }
+  /** Register decoded interleaved PCM for an existing audio source (undoable). */
+  setSourceAudio(sourceId, audio, channels, sampleRate) {
+    this.native.setSourceAudio(sourceId, audio, channels, sampleRate);
+  }
+  /** Replace an audio source's metadata strings as one undoable edit. */
+  setAudioSourceMetadata(sourceId, contentHash, externalStemRole) {
+    this.native.setAudioSourceMetadata(sourceId, contentHash, externalStemRole);
+  }
   /** Replace a clip's take list and active take id (undoable). */
   setClipTakes(clipId, takes, activeTakeId = 0) {
     this.native.setClipTakes(clipId, takes, activeTakeId);
@@ -3866,23 +4537,35 @@ var Project = class _Project {
   setTrackRoute(trackId, channelStripRef, outputTarget) {
     this.native.setTrackRoute(trackId, channelStripRef ?? "", outputTarget ?? "");
   }
-  /** Append an automation lane to a track; returns the lane index (undoable). */
+  /** Append an automation lane; returns its stable target parameter id (undoable). */
   addAutomationLane(trackId, desc) {
-    return this.native.addAutomationLane(trackId, {
-      targetParamId: desc.targetParamId,
-      points: desc.points
-    });
+    if (desc.targetParamId === 0) {
+      throw new RangeError("project automation lane targetParamId must be non-zero");
+    }
+    const nativeDesc = { ...desc };
+    if (Object.keys(desc).includes("targetKind")) {
+      nativeDesc.targetKind = projectAutomationTargetKindValue(
+        desc.targetKind
+      );
+    }
+    return this.native.addAutomationLane(trackId, nativeDesc);
   }
-  /** Replace an existing automation lane in place (undoable). */
-  editAutomationLane(trackId, laneIndex, desc) {
-    this.native.editAutomationLane(trackId, laneIndex, {
-      targetParamId: desc.targetParamId,
-      points: desc.points
-    });
+  /** Replace the lane identified by its stable target parameter id (undoable). */
+  editAutomationLane(trackId, targetParamId, desc) {
+    if (desc.targetParamId === 0) {
+      throw new RangeError("project automation lane targetParamId must be non-zero");
+    }
+    const nativeDesc = { ...desc };
+    if (Object.keys(desc).includes("targetKind")) {
+      nativeDesc.targetKind = projectAutomationTargetKindValue(
+        desc.targetKind
+      );
+    }
+    this.native.editAutomationLane(trackId, targetParamId, nativeDesc);
   }
-  /** Remove an automation lane from a track (undoable). */
-  removeAutomationLane(trackId, laneIndex) {
-    this.native.removeAutomationLane(trackId, laneIndex);
+  /** Remove the lane identified by its stable target parameter id (undoable). */
+  removeAutomationLane(trackId, targetParamId) {
+    this.native.removeAutomationLane(trackId, targetParamId);
   }
   /** Replace the project's key annotation stream (undoable). */
   annotateKeys(keys) {
@@ -3892,15 +4575,33 @@ var Project = class _Project {
   annotateChords(chords) {
     this.native.annotateChords(chords);
   }
-  /** Add or update an opaque assist sidecar by module id + target scope (undoable). */
-  setAssistSidecar(moduleId, schemaVersion, targetTrackId, regionStartPpq, regionEndPpq, payload) {
+  setAssistSidecar(sidecarOrModuleId, schemaVersion, targetTrackId, regionStartPpq, regionEndPpq, payload) {
+    if (typeof sidecarOrModuleId === "string") {
+      if (schemaVersion === void 0 || targetTrackId === void 0 || regionStartPpq === void 0 || regionEndPpq === void 0 || payload === void 0) {
+        throw new TypeError("Project.setAssistSidecar: positional form requires six arguments");
+      }
+      this.native.setAssistSidecar(
+        validateAssistSidecarModuleId(sidecarOrModuleId),
+        validateAssistSidecarUint32(schemaVersion, "schemaVersion"),
+        validateAssistSidecarUint32(targetTrackId, "targetTrackId"),
+        validateAssistSidecarPpq(regionStartPpq, "regionStartPpq"),
+        validateAssistSidecarPpq(regionEndPpq, "regionEndPpq"),
+        validateAssistSidecarPayload(payload)
+      );
+      return;
+    }
+    if (sidecarOrModuleId === null || typeof sidecarOrModuleId !== "object" || Array.isArray(sidecarOrModuleId)) {
+      throw new TypeError("Project.setAssistSidecar: expected a sidecar descriptor object");
+    }
+    const sidecar = sidecarOrModuleId;
+    const moduleId = validateAssistSidecarModuleId(sidecar.moduleId);
     this.native.setAssistSidecar(
       moduleId,
-      schemaVersion,
-      targetTrackId,
-      regionStartPpq,
-      regionEndPpq,
-      payload
+      validateAssistSidecarUint32(sidecar.schemaVersion ?? 0, "schemaVersion"),
+      validateAssistSidecarUint32(sidecar.targetTrackId ?? 0, "targetTrackId"),
+      validateAssistSidecarPpq(sidecar.regionStartPpq ?? 0, "regionStartPpq"),
+      validateAssistSidecarPpq(sidecar.regionEndPpq ?? 0, "regionEndPpq"),
+      validateAssistSidecarPayload(sidecar.payload ?? new Uint8Array())
     );
   }
   /** Number of assist sidecars currently stored on the project. */
@@ -3911,6 +4612,11 @@ var Project = class _Project {
   getAssistSidecar(index) {
     return this.native.getAssistSidecar(index);
   }
+  /** Read every stored assist sidecar in the same order as the index getter. */
+  assistSidecars() {
+    const count = this.assistSidecarCount();
+    return Array.from({ length: count }, (_, index) => this.getAssistSidecar(index));
+  }
   /** Set the project's clip-overlap policy (SonareProjectOverlapPolicy ordinal). */
   setOverlapPolicy(policy) {
     this.native.setOverlapPolicy(policy);
@@ -3946,6 +4652,18 @@ var Project = class _Project {
   markerByIndex(index) {
     return this.native.markerByIndex(index);
   }
+  /** Read a stored project track by 0-based index. */
+  trackByIndex(index) {
+    return this.native.trackByIndex(index);
+  }
+  /** Read a stored project clip by 0-based index. */
+  clipByIndex(index) {
+    return this.native.clipByIndex(index);
+  }
+  /** Read a stored project source by 0-based index. */
+  sourceByIndex(index) {
+    return this.native.sourceByIndex(index);
+  }
   /** Number of markers in the project. */
   markerCount() {
     return this.native.markerCount();
@@ -4019,6 +4737,7 @@ var MarkerKind = {
   cuePoint: 3,
   keySignature: 4
 };
+var BUILTIN_SYNTH_WAVEFORMS = ["sine", "saw", "sawtooth", "square", "triangle"];
 var SYNTH_ENGINE_MODES = [
   "default",
   "subtractive",
@@ -4080,82 +4799,14 @@ var SYNTH_MOD_DESTINATIONS = [
   "amp-gain",
   "pan-units"
 ];
-
-// src/codes.ts
-function automationCurveCode(curve) {
-  switch (curve) {
-    case "linear":
-      return 0;
-    case "exponential":
-      return 1;
-    case "hold":
-      return 2;
-    case "s-curve":
-      return 3;
-    default:
-      throw new Error(`Invalid automation curve: ${curve}`);
-  }
-}
-function panLawCode(panLaw) {
-  if (typeof panLaw === "number") {
-    return panLaw;
-  }
-  switch (panLaw) {
-    case "const3dB":
-      return 0;
-    case "const4.5dB":
-      return 1;
-    case "const6dB":
-      return 2;
-    case "linear0dB":
-      return 3;
-    default:
-      throw new Error(`Invalid pan law: ${panLaw}`);
-  }
-}
-function panModeCode(panMode) {
-  if (typeof panMode === "number") {
-    return panMode;
-  }
-  switch (panMode) {
-    case "balance":
-      return 0;
-    case "stereoPan":
-    case "stereo-pan":
-      return 1;
-    case "dualPan":
-    case "dual-pan":
-      return 2;
-    default:
-      throw new Error(`Invalid pan mode: ${panMode}`);
-  }
-}
-function meterTapCode(tap) {
-  if (typeof tap === "number") {
-    return tap;
-  }
-  switch (tap) {
-    case "preFader":
-      return 0;
-    case "postFader":
-      return 1;
-    default:
-      throw new Error(`Invalid meter tap: ${tap}`);
-  }
-}
-function sendTimingCode(timing) {
-  if (typeof timing === "number") {
-    return timing;
-  }
-  switch (timing) {
-    case "postFader":
-      return 0;
-    case "preFader":
-      return 1;
-    default:
-      throw new Error(`Invalid send timing: ${timing}`);
-  }
-}
+var AutomationTargetKind = {
+  opaque: 0,
+  trackFaderDb: 1,
+  trackPan: 2
+};
+var PROJECT_AUTOMATION_TARGET_OPAQUE = AutomationTargetKind.opaque;
+var PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB = AutomationTargetKind.trackFaderDb;
+var PROJECT_AUTOMATION_TARGET_TRACK_PAN = AutomationTargetKind.trackPan;
 
 // src/realtime_engine.ts
 var EXPECTED_ENGINE_ABI_VERSION = 3;
@@ -4175,23 +4826,30 @@ function engineCapabilities() {
   };
 }
 var RealtimeEngine = class {
-  constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024) {
+  constructor(sampleRate = 48e3, maxBlockSize = 128, commandCapacity = 1024, telemetryCapacity = 1024, maxChannels = 64) {
     const module2 = getSonareModule();
-    const capabilities = engineCapabilities();
-    if (!capabilities.abiCompatible) {
+    const capabilities2 = engineCapabilities();
+    if (!capabilities2.abiCompatible) {
       throw new Error(
-        `Engine ABI mismatch: wasm=${capabilities.engineAbiVersion}, expected=${capabilities.expectedEngineAbiVersion}`
+        `Engine ABI mismatch: wasm=${capabilities2.engineAbiVersion}, expected=${capabilities2.expectedEngineAbiVersion}`
       );
     }
     this.native = new module2.RealtimeEngine(
       sampleRate,
       maxBlockSize,
       commandCapacity,
-      telemetryCapacity
+      telemetryCapacity,
+      maxChannels
     );
   }
-  prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024) {
-    this.native.prepare(sampleRate, maxBlockSize, commandCapacity, telemetryCapacity);
+  prepare(sampleRate, maxBlockSize, commandCapacity = 1024, telemetryCapacity = 1024, maxChannels = 64) {
+    this.native.prepareWithChannels(
+      sampleRate,
+      maxBlockSize,
+      commandCapacity,
+      telemetryCapacity,
+      maxChannels
+    );
   }
   /** Queue a sample-accurate parameter change (engine kSetParam). */
   setParameter(paramId, value, renderFrame = -1) {
@@ -4212,6 +4870,10 @@ var RealtimeEngine = class {
   setSoloMute(laneIndex, solo, mute, renderFrame = -1) {
     this.native.setSoloMute(laneIndex, solo, mute, renderFrame);
   }
+  /** Queue a per-track PFL/AFL monitor tap mode change. */
+  setTrackMonitorMode(laneIndex, mode, renderFrame = -1) {
+    this.native.setTrackMonitorMode(laneIndex, trackMonitorModeCode(mode), renderFrame);
+  }
   setMidiClips(clips) {
     this.native.setMidiClips(clips);
   }
@@ -4317,6 +4979,9 @@ var RealtimeEngine = class {
   externalMidiDroppedCount() {
     return this.native.externalMidiDroppedCount();
   }
+  externalMidiPendingCount() {
+    return this.native.externalMidiPendingCount();
+  }
   /**
    * Drain queued external-MIDI events, already lowered to MIDI 1.0 byte
    * messages ready to write to a Web MIDI output port. Call once per audio
@@ -4327,6 +4992,25 @@ var RealtimeEngine = class {
   drainExternalMidi(maxRecords = 1024) {
     return this.native.drainExternalMidi(maxRecords);
   }
+  /** Scalar, allocation-free external-MIDI drain for AudioWorklet SAB output. */
+  popExternalMidiToScratch() {
+    return this.native.popExternalMidiToScratch();
+  }
+  externalMidiScratchDestinationId() {
+    return this.native.externalMidiScratchDestinationId();
+  }
+  externalMidiScratchRenderFrame() {
+    return this.native.externalMidiScratchRenderFrame();
+  }
+  externalMidiScratchByteWord() {
+    return this.native.externalMidiScratchByteWord();
+  }
+  externalMidiScratchByteCount() {
+    return this.native.externalMidiScratchByteCount();
+  }
+  consumeExternalMidiScratch() {
+    this.native.consumeExternalMidiScratch();
+  }
   pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples = 0) {
     this.native.pushMidiInputNoteOn(group, channel, note, velocity, portTimeSamples);
   }
@@ -4351,6 +5035,10 @@ var RealtimeEngine = class {
   pushMidiCc(destinationId, group, channel, controller, value, renderFrame = -1) {
     this.native.pushMidiCc(destinationId, group, channel, controller, value, renderFrame);
   }
+  /** Queue one immediate MIDI 1.0 channel-voice UMP word for a destination. */
+  pushMidiUmp(destinationId, word0, renderFrame = -1) {
+    this.native.pushMidiUmp(destinationId, word0, renderFrame);
+  }
   /**
    * Queue an immediate (live) MIDI SysEx frame to a MIDI destination. `data` is
    * the full message including the leading 0xF0 and trailing 0xF7 (1..512
@@ -4396,6 +5084,10 @@ var RealtimeEngine = class {
   settleParameters() {
     this.native.settleParameters();
   }
+  /** Drains queued commands on an offline/control-only engine immediately. */
+  flushControlCommands() {
+    this.native.flushControlCommands();
+  }
   seekPpq(ppq, renderFrame = -1) {
     this.native.seekPpq(ppq, renderFrame);
   }
@@ -4650,6 +5342,23 @@ var RealtimeEngine = class {
   popClipPageRequest() {
     return this.native.popClipPageRequest();
   }
+  /**
+   * Moves one native request into the binding's persistent scalar scratch.
+   * This avoids creating an embind JS object in AudioWorklet process().
+   */
+  popClipPageRequestToScratch() {
+    return this.native.popClipPageRequestToScratch();
+  }
+  clipPageRequestScratchClipId() {
+    return this.native.clipPageRequestScratchClipId();
+  }
+  clipPageRequestScratchSample() {
+    return this.native.clipPageRequestScratchSample();
+  }
+  /** Cumulative page misses dropped because the native bounded request queue was full. */
+  clipPageRequestOverflowCount() {
+    return this.native.clipPageRequestOverflowCount();
+  }
   setCaptureBuffer(numChannels, capacityFrames) {
     this.native.setCaptureBuffer(numChannels, capacityFrames);
   }
@@ -4678,6 +5387,10 @@ var RealtimeEngine = class {
   capturedAudio() {
     return this.native.capturedAudio();
   }
+  /**
+   * Renders in place, adding engine output to `channels`. Zero each plane first
+   * when it contains no upstream input.
+   */
   process(channels) {
     return this.native.process(channels);
   }
@@ -4700,6 +5413,7 @@ var RealtimeEngine = class {
   }
   /**
    * Runs the engine in place over the prepared per-channel scratch buffers.
+   * Zero each active span first when it contains no upstream input.
    * Allocation-free: safe to call on the AudioWorklet render thread after
    * `prepareChannels`.
    */
@@ -4721,6 +5435,42 @@ var RealtimeEngine = class {
   drainTelemetry(maxRecords = 1024) {
     return this.native.drainTelemetry(maxRecords);
   }
+  popTelemetryToScratch() {
+    return this.native.popTelemetryToScratch();
+  }
+  telemetryScratchType() {
+    return this.native.telemetryScratchType();
+  }
+  telemetryScratchError() {
+    return this.native.telemetryScratchError();
+  }
+  telemetryScratchRenderFrame() {
+    return Number(this.native.telemetryScratchRenderFrame());
+  }
+  telemetryScratchTimelineSample() {
+    return Number(this.native.telemetryScratchTimelineSample());
+  }
+  telemetryScratchAudibleTimelineSample() {
+    return Number(this.native.telemetryScratchAudibleTimelineSample());
+  }
+  telemetryScratchGraphLatencySamplesQ8() {
+    return this.native.telemetryScratchGraphLatencySamplesQ8();
+  }
+  telemetryScratchValue() {
+    return this.native.telemetryScratchValue();
+  }
+  popMeterTelemetryToScratch() {
+    return this.native.popMeterTelemetryToScratch();
+  }
+  meterScratchTargetId() {
+    return this.native.meterScratchTargetId();
+  }
+  meterScratchRenderFrame() {
+    return Number(this.native.meterScratchRenderFrame());
+  }
+  meterScratchValue(field) {
+    return this.native.meterScratchValue(field);
+  }
   drainMeterTelemetry(maxRecords = 1024) {
     return this.native.drainMeterTelemetry(maxRecords);
   }
@@ -4748,6 +5498,30 @@ var RealtimeEngine = class {
   drainScopeTelemetry(maxRecords = 1024) {
     return this.native.drainScopeTelemetry(maxRecords);
   }
+  popScopeTelemetryToScratch() {
+    return this.native.popScopeTelemetryToScratch();
+  }
+  scopeScratchTargetId() {
+    return this.native.scopeScratchTargetId();
+  }
+  scopeScratchRenderFrame() {
+    return Number(this.native.scopeScratchRenderFrame());
+  }
+  scopeScratchBandCount() {
+    return this.native.scopeScratchBandCount();
+  }
+  scopeScratchBand(index) {
+    return this.native.scopeScratchBand(index);
+  }
+  scopeScratchPointCount() {
+    return this.native.scopeScratchPointCount();
+  }
+  scopeScratchPointLeft(index) {
+    return this.native.scopeScratchPointLeft(index);
+  }
+  scopeScratchPointRight(index) {
+    return this.native.scopeScratchPointRight(index);
+  }
   destroy() {
     this.native.delete();
   }
@@ -4813,6 +5587,7 @@ var StreamAnalyzer = class {
     if (config.outputFormat !== void 0 && (typeof config.outputFormat !== "number" || !Number.isFinite(config.outputFormat) || !Number.isInteger(config.outputFormat) || config.outputFormat !== 0)) {
       throw new TypeError("outputFormat must be the integer 0 (Float32)");
     }
+    const window = config.window === void 0 ? void 0 : resolveOrdinalInRange(config.window, 0, 3, "stream analyzer window");
     const module2 = getSonareModule();
     const defaults = streamAnalyzerConfigDefaults();
     this.analyzer = new module2.StreamAnalyzer(
@@ -4834,7 +5609,7 @@ var StreamAnalyzer = class {
       config.maxProgressionEntries ?? defaults.maxProgressionEntries,
       config.keyUpdateIntervalSec ?? defaults.keyUpdateIntervalSec,
       config.bpmUpdateIntervalSec ?? defaults.bpmUpdateIntervalSec,
-      config.window ?? defaults.window,
+      window ?? defaults.window,
       config.outputFormat ?? defaults.outputFormat
     );
   }
@@ -5262,7 +6037,7 @@ var Mixer = class _Mixer {
   setPolarityInvert(stripIndex, invertLeft, invertRight) {
     this.mixer.setPolarityInvert(stripIndex, invertLeft, invertRight);
   }
-  /** Set the strip's pan law. */
+  /** Set the strip's pan law (a {@link PanLawName} alias or raw C ABI ordinal). */
   setPanLaw(stripIndex, panLaw) {
     this.mixer.setPanLaw(stripIndex, panLawCode(panLaw));
   }
@@ -5449,65 +6224,18 @@ var Mixer = class _Mixer {
 };
 
 // src/realtime_voice_changer.ts
-function isFlatVoiceChangerPod(config) {
-  return typeof config === "object" && config !== null && "retuneSemitones" in config;
-}
-function flatVoiceChangerPodToNested(pod) {
-  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
-    }
-  };
-}
 var RealtimeVoiceChanger = class {
-  constructor(config = "neutral-monitor") {
+  /**
+   * Creates a voice changer. Supplying `sampleRate` prepares it immediately,
+   * matching the Node and Python constructors; omitting it preserves the
+   * explicit {@link prepare} lifecycle for callers that configure later.
+   */
+  constructor(config = "neutral-monitor", sampleRate, maxBlockSize = 128, channels = 1) {
     const module2 = getSonareModule();
     this.changer = module2.createRealtimeVoiceChanger(config);
+    if (sampleRate !== void 0) {
+      this.changer.prepare(sampleRate, maxBlockSize, channels);
+    }
   }
   prepare(sampleRate, maxBlockSize = 128, channels = 1) {
     this.changer.prepare(sampleRate, maxBlockSize, channels);
@@ -5516,8 +6244,15 @@ var RealtimeVoiceChanger = class {
     this.changer.reset();
   }
   setConfig(config) {
-    const resolved = isFlatVoiceChangerPod(config) ? flatVoiceChangerPodToNested(config) : config;
-    this.changer.setConfig(resolved);
+    this.changer.setConfig(config);
+  }
+  /**
+   * Apply a flat, pre-normalized config without JSON serialization. Intended
+   * for AudioWorklet control messages whose sender prepared the POD on the
+   * main thread.
+   */
+  setPodConfig(config) {
+    this.changer.setPodConfig(config);
   }
   configJson() {
     return this.changer.configJson();
@@ -5525,6 +6260,13 @@ var RealtimeVoiceChanger = class {
   latencySamples() {
     return this.changer.latencySamples();
   }
+  /**
+   * Monotonically increases whenever {@link prepare} can replace the native
+   * scratch buffers. Cached WASM heap views must be reacquired after it changes.
+   */
+  bufferGeneration() {
+    return this.changer.bufferGeneration();
+  }
   processMono(samples) {
     return this.changer.processMono(samples);
   }
@@ -5601,10 +6343,12 @@ var RealtimeVoiceChanger = class {
   createRealtimeMonoBuffer(numSamples) {
     let input = this.getMonoInputBuffer(numSamples);
     let output = this.getMonoOutputBuffer(numSamples);
+    let generation = this.bufferGeneration();
     const reacquireIfDetached = () => {
-      if (input.byteLength === 0 || output.byteLength === 0) {
+      if (generation !== this.bufferGeneration() || input.byteLength === 0 || output.byteLength === 0) {
         input = this.getMonoInputBuffer(numSamples);
         output = this.getMonoOutputBuffer(numSamples);
+        generation = this.bufferGeneration();
       }
     };
     return {
@@ -5626,10 +6370,12 @@ var RealtimeVoiceChanger = class {
   createRealtimeInterleavedBuffer(numFrames, numChannels) {
     let input = this.getInterleavedInputBuffer(numFrames, numChannels);
     let output = this.getInterleavedOutputBuffer(numFrames, numChannels);
+    let generation = this.bufferGeneration();
     const reacquireIfDetached = () => {
-      if (input.byteLength === 0 || output.byteLength === 0) {
+      if (generation !== this.bufferGeneration() || input.byteLength === 0 || output.byteLength === 0) {
         input = this.getInterleavedInputBuffer(numFrames, numChannels);
         output = this.getInterleavedOutputBuffer(numFrames, numChannels);
+        generation = this.bufferGeneration();
       }
     };
     return {
@@ -5656,15 +6402,17 @@ var RealtimeVoiceChanger = class {
    */
   createRealtimePlanarBuffer(numFrames, numChannels) {
     let channels = [];
+    let generation = this.bufferGeneration();
     const acquire = () => {
       channels = [];
       for (let ch = 0; ch < numChannels; ch++) {
         channels.push(this.getPlanarChannelBuffer(ch, numFrames));
       }
+      generation = this.bufferGeneration();
     };
     acquire();
     const reacquireIfDetached = () => {
-      if ((channels[0]?.byteLength ?? 0) === 0) {
+      if (generation !== this.bufferGeneration() || (channels[0]?.byteLength ?? 0) === 0) {
         acquire();
       }
     };
@@ -5740,6 +6488,19 @@ var StreamingMasteringChain = class {
     }
     return this.chain.processStereo(left, right);
   }
+  /**
+   * Emit delayed audio and finite processor tails after the final mono block.
+   * Call until this returns an empty array. The initial `latencySamples()`
+   * samples of the concatenated stream are delayed and should be discarded for
+   * time-aligned output.
+   */
+  flushMono() {
+    return this.chain.flushMono();
+  }
+  /** Stereo counterpart of {@link flushMono}. */
+  flushStereo() {
+    return this.chain.flushStereo();
+  }
   /** Reset all processor state without rebuilding. */
   reset() {
     this.chain.reset();
@@ -5981,7 +6742,6 @@ async function bindWebMidi(engine, options = {}) {
     for (const [, input] of iterInputs(access)) {
       bindInput(input);
     }
-    notify();
   };
   const stateListener = (event) => {
     if (closed) {
@@ -6000,6 +6760,7 @@ async function bindWebMidi(engine, options = {}) {
     notify();
   };
   refreshInputs();
+  notify();
   if (access.addEventListener) {
     access.addEventListener("statechange", stateListener);
   } else {
@@ -6101,12 +6862,8 @@ function dispatchUmpMessage(engine, words, portTimeSamples) {
     if (status === 8) {
       engine.pushMidiInputNoteOff(group, channel, data1, word1 >>> 25 & 127, portTimeSamples);
     } else if (status === 9) {
-      const velocity = word1 >>> 25 & 127;
-      if (velocity === 0) {
-        engine.pushMidiInputNoteOff(group, channel, data1, 0, portTimeSamples);
-      } else {
-        engine.pushMidiInputNoteOn(group, channel, data1, velocity, portTimeSamples);
-      }
+      const velocity = Math.max(1, word1 >>> 25 & 127);
+      engine.pushMidiInputNoteOn(group, channel, data1, velocity, portTimeSamples);
     } else if (status === 11) {
       engine.pushMidiInputCc(group, channel, data1, word1 >>> 25 & 127, portTimeSamples);
     }
@@ -6131,6 +6888,214 @@ function iterInputs(access) {
   return access.inputs instanceof Map ? access.inputs.entries() : access.inputs;
 }
 
+// src/worker_client.ts
+var OfflineWorkerTask = class {
+  constructor(result, cancelRequest) {
+    this.result = result;
+    this.cancelRequest = cancelRequest;
+  }
+  cancel() {
+    this.cancelRequest();
+  }
+  // biome-ignore lint/suspicious/noThenProperty: this intentionally implements PromiseLike so callers can await a task and cancel it.
+  then(onfulfilled, onrejected) {
+    return this.result.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.result.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.result.finally(onfinally);
+  }
+};
+function cloneForWorker(value, copy, transfers, transferred = /* @__PURE__ */ new Set()) {
+  if (value instanceof Float32Array) {
+    const samples = copy ? value.slice() : value;
+    const buffer = samples.buffer;
+    if (!(buffer instanceof ArrayBuffer)) {
+      throw new TypeError(
+        "OfflineWorkerClient only transfers Float32Array values backed by ArrayBuffer"
+      );
+    }
+    if (!transferred.has(buffer)) {
+      transferred.add(buffer);
+      transfers.push(buffer);
+    }
+    return samples;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneForWorker(item, copy, transfers, transferred));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        cloneForWorker(item, copy, transfers, transferred)
+      ])
+    );
+  }
+  return value;
+}
+function cancellationFlag() {
+  if (typeof SharedArrayBuffer === "undefined") {
+    return void 0;
+  }
+  return new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+}
+function workerError(message) {
+  if (message.error.code !== void 0) {
+    return new SonareError(
+      message.error.code,
+      message.error.codeName ?? "Unknown",
+      message.error.message
+    );
+  }
+  const error = new Error(message.error.message);
+  error.name = message.error.name;
+  return error;
+}
+var OfflineWorkerClient = class {
+  constructor(options = {}) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.closed = false;
+    this.usesEventTarget = false;
+    this.onMessage = (event) => {
+      const message = event.data;
+      const pending = this.pending.get(message.id);
+      if (!pending) {
+        return;
+      }
+      if (message.type === "sonare:offline-progress") {
+        pending.onProgress?.({ progress: message.progress, stage: message.stage });
+        return;
+      }
+      this.pending.delete(message.id);
+      if (message.type === "sonare:offline-result") {
+        pending.resolve(message.result);
+        return;
+      }
+      pending.reject(workerError(message));
+    };
+    this.onError = (event) => {
+      const error = new Error(event.message || "Offline Worker failed");
+      for (const { reject } of this.pending.values()) {
+        reject(error);
+      }
+      this.pending.clear();
+    };
+    this.onNodeMessage = (data) => {
+      this.onMessage({ data });
+    };
+    this.onNodeError = (error) => {
+      this.onError(
+        error instanceof Error ? { message: error.message } : { message: String(error) }
+      );
+    };
+    this.ownsWorker = options.worker === void 0 || options.terminateWorkerOnDispose === true;
+    if (options.worker) {
+      this.worker = options.worker;
+    } else {
+      if (!options.workerFactory && typeof Worker === "undefined") {
+        throw new Error("OfflineWorkerClient requires a browser Worker implementation");
+      }
+      const url = options.workerUrl === void 0 ? new URL("./worker.js", import.meta.url) : new URL(options.workerUrl, import.meta.url);
+      this.worker = options.workerFactory?.(url) ?? new Worker(url, { type: "module", name: "sonare-offline" });
+    }
+    if (this.worker.addEventListener) {
+      this.usesEventTarget = true;
+      this.worker.addEventListener("message", this.onMessage);
+      this.worker.addEventListener("error", this.onError);
+    } else if (this.worker.on) {
+      this.worker.on("message", this.onNodeMessage);
+      this.worker.on("error", this.onNodeError);
+    } else {
+      throw new TypeError("OfflineWorkerClient requires Worker event listeners");
+    }
+  }
+  /** Dispatch full music analysis to the Worker. */
+  analyze(request, options) {
+    return this.call("analyze", request, options);
+  }
+  /** Dispatch BPM detection to the Worker. */
+  detectBpm(request, options) {
+    return this.call("detectBpm", request, options);
+  }
+  /** Dispatch key detection to the Worker. */
+  detectKey(request, options) {
+    return this.call("detectKey", request, options);
+  }
+  /** Dispatch chord detection to the Worker. */
+  detectChords(request, options) {
+    return this.call("detectChords", request, options);
+  }
+  /** Dispatch mono preset mastering to the Worker. */
+  masterAudio(request, options) {
+    return this.call("masterAudio", request, options);
+  }
+  /** Dispatch stereo preset mastering to the Worker. */
+  masterAudioStereo(request, options) {
+    return this.call("masterAudioStereo", request, options);
+  }
+  /** Stop accepting calls, reject outstanding work, and release the Worker if owned. */
+  dispose() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (this.usesEventTarget) {
+      this.worker.removeEventListener?.("message", this.onMessage);
+      this.worker.removeEventListener?.("error", this.onError);
+    } else {
+      this.worker.off?.("message", this.onNodeMessage);
+      this.worker.off?.("error", this.onNodeError);
+    }
+    for (const { reject } of this.pending.values()) {
+      reject(new Error("OfflineWorkerClient was disposed"));
+    }
+    this.pending.clear();
+    if (this.ownsWorker) {
+      this.worker.terminate();
+    }
+  }
+  call(operation, request, options = {}) {
+    if (this.closed) {
+      throw new Error("OfflineWorkerClient was disposed");
+    }
+    const id = this.nextId++;
+    const transfers = [];
+    const preparedRequest = cloneForWorker(request, options.copy === true, transfers);
+    const cancelFlag = cancellationFlag();
+    const result = new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: (value) => resolve(value),
+        reject,
+        onProgress: options.onProgress,
+        cancelFlag
+      });
+    });
+    this.worker.postMessage(
+      {
+        type: "sonare:offline-run",
+        id,
+        operation,
+        request: preparedRequest,
+        ...cancelFlag ? { cancelBuffer: cancelFlag.buffer } : {}
+      },
+      transfers
+    );
+    return new OfflineWorkerTask(result, () => {
+      if (!this.pending.has(id)) {
+        return;
+      }
+      if (cancelFlag) {
+        Atomics.store(cancelFlag, 0, 1);
+      }
+      this.worker.postMessage({ type: "sonare:offline-cancel", id });
+    });
+  }
+};
+
 // src/index.ts
 var module = null;
 var initPromise = null;
@@ -6162,6 +7127,18 @@ function version() {
   }
   return module.version();
 }
+function capabilities() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return module.capabilities();
+}
+function capabilityCatalog() {
+  if (!module) {
+    throw new Error("Module not initialized. Call init() first.");
+  }
+  return JSON.parse(module.capabilityCatalog());
+}
 function abiVersion() {
   if (!module) {
     throw new Error("Module not initialized. Call init() first.");
@@ -6190,6 +7167,9 @@ var VOICE_PRESET_ORDINALS = [
 ];
 function resolveVoicePresetOrdinal(preset) {
   if (typeof preset === "number") {
+    if (!Number.isSafeInteger(preset) || preset < 0 || preset >= VOICE_PRESET_ORDINALS.length) {
+      throw new RangeError(`Unknown voice-character preset ordinal: ${String(preset)}`);
+    }
     return preset;
   }
   const ordinal = VOICE_PRESET_ORDINALS.indexOf(preset);
@@ -6202,6 +7182,9 @@ function voiceCharacterPresetId(preset) {
   if (!module) {
     throw new Error("Module not initialized. Call init() first.");
   }
+  if (typeof preset === "number" && (!Number.isSafeInteger(preset) || preset < 0 || preset >= VOICE_PRESET_ORDINALS.length)) {
+    return null;
+  }
   return module.voiceCharacterPresetId(resolveVoicePresetOrdinal(preset));
 }
 function realtimeVoiceChangerPresetConfig(preset) {
@@ -6212,7 +7195,10 @@ function realtimeVoiceChangerPresetConfig(preset) {
 }
 export {
   Audio,
+  AutomationTargetKind,
+  BUILTIN_SYNTH_WAVEFORMS,
   ChordQuality,
+  ClipPageProvider,
   ClipPageStreamer,
   EXPECTED_ENGINE_ABI_VERSION,
   EXPECTED_PROJECT_ABI_VERSION,
@@ -6221,6 +7207,11 @@ export {
   MarkerKind,
   Mixer,
   Mode,
+  OfflineWorkerClient,
+  OfflineWorkerTask,
+  PROJECT_AUTOMATION_TARGET_OPAQUE,
+  PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB,
+  PROJECT_AUTOMATION_TARGET_TRACK_PAN,
   PitchClass as Pitch,
   PitchClass,
   Project,
@@ -6254,10 +7245,14 @@ export {
   bassChroma,
   bindMicrophoneInput,
   bindWebMidi,
+  capabilities,
+  capabilityCatalog,
+  chirp,
   chordFunctionalAnalysis,
   chroma,
   chromaCens,
   chromaCqt,
+  clicks,
   cqt,
   cqtToAudio,
   createOpfsClipPageProvider,
@@ -6287,6 +7282,7 @@ export {
   frameSignal,
   framesToSamples,
   framesToTime,
+  griffinLim,
   harmonic,
   hasFfmpegSupport,
   hpss,
@@ -6337,6 +7333,7 @@ export {
   masteringStereoAnalysisNames,
   masteringStereoAnalyze,
   masteringStreamingPreview,
+  melDelta,
   melSpectrogram,
   melToAudio,
   melToHz,
@@ -6369,8 +7366,10 @@ export {
   nnlsChroma,
   normalize,
   noteMove,
+  noteSegments,
   noteStretch,
   noteToHz,
+  onsetBacktrack,
   onsetEnvelope,
   onsetStrengthMulti,
   opfsClipPageWorkerSource,
@@ -6379,6 +7378,7 @@ export {
   peakPick,
   percussive,
   phaseVocoder,
+  piptrack,
   pitchCorrectTimevarying,
   pitchCorrectToMidi,
   pitchCorrectToMidiTimevarying,
@@ -6395,6 +7395,7 @@ export {
   realtimeVoiceChangerPresetConfig,
   realtimeVoiceChangerPresetJson,
   realtimeVoiceChangerPresetNames,
+  reassignedSpectrogram,
   remix,
   resample,
   rmsEnergy,
@@ -6403,12 +7404,20 @@ export {
   scaleCorrectionSemitones,
   scalePitchClassEnabled,
   scaleQuantizeMidi,
+  segmentAgglomerative,
+  segmentCrossSimilarity,
+  segmentLagToRecurrence,
+  segmentPathEnhance,
+  segmentRecurrenceMatrix,
+  segmentRecurrenceToLag,
+  segmentSubsegment,
   shortTermLufs,
   spectralBandwidth,
   spectralCentroid,
   spectralContrast,
   spectralEdit,
   spectralFlatness,
+  spectralFlux,
   spectralRolloff,
   splitSilence,
   stft,
@@ -6422,6 +7431,7 @@ export {
   tempogramRatio,
   timeStretch,
   timeToFrames,
+  tone,
   tonnetz,
   trim,
   trimSilence,