@libraz/libsonare 1.7.2 → 1.8.1

package/dist/analysis.js

@@ -9,6 +9,7 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2[ErrorCode2["NotSupported"] = 6] = "NotSupported";
   ErrorCode2[ErrorCode2["InvalidState"] = 7] = "InvalidState";
   ErrorCode2[ErrorCode2["Cancelled"] = 8] = "Cancelled";
+  ErrorCode2[ErrorCode2["EncodeFailed"] = 9] = "EncodeFailed";
   ErrorCode2[ErrorCode2["Unknown"] = 99] = "Unknown";
   return ErrorCode2;
 })(ErrorCode || {});
@@ -19,6 +20,17 @@ var SonareError = class extends Error {
     this.code = code;
     this.codeName = codeName;
   }
+  /**
+   * Brand-based `instanceof`: an error that carries the shape narrows here even
+   * when it is not literally an instance of this class. That is not a
+   * hypothetical — an error posted from the analysis worker arrives as a
+   * structured clone with its prototype gone, which a prototype-based
+   * `instanceof` would silently miss. Delegates to {@link isSonareError} so the
+   * two never disagree.
+   */
+  static [Symbol.hasInstance](value) {
+    return isSonareError(value);
+  }
 };
 function isSonareError(value) {
   return value instanceof Error && value.name === "SonareError" && typeof value.code === "number";
@@ -50,6 +62,11 @@ function makeSonareError(raw, thrown) {
       message = info.message || message;
     }
   } catch {
+  } finally {
+    try {
+      raw.sonareReleaseException(thrown);
+    } catch {
+    }
   }
   return new SonareError(code, codeName, message);
 }
@@ -70,6 +87,10 @@ function wrapModuleErrors(raw) {
     if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
       return value;
     }
+    const proto = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || proto === Object.prototype || proto === null) {
+      return value;
+    }
     const objectValue = value;
     const cached = objectCache.get(objectValue);
     if (cached) {
@@ -272,6 +293,22 @@ function splitSilence(samples, topDb = 60, frameLength = 2048, hopLength = 512)
   }
   return requireModule().splitSilence(samples, topDb, frameLength, hopLength);
 }
+function splitSilenceCommon(request) {
+  return requireModule().splitSilenceCommon(
+    request.signals,
+    request.topDb ?? 60,
+    request.frameLength ?? 2048,
+    request.hopLength ?? 512
+  );
+}
+function splitSilenceCommonWithReport(request) {
+  return requireModule().splitSilenceCommonWithReport(
+    request.signals,
+    request.topDb ?? 60,
+    request.frameLength ?? 2048,
+    request.hopLength ?? 512
+  );
+}
 function frameSignal(samples, frameLength, hopLength) {
   if (!(samples instanceof Float32Array)) {
     return frameSignal(samples.samples, samples.frameLength, samples.hopLength);
@@ -421,28 +458,70 @@ function assertSamples(fnName, samples, validate, argName = "samples") {
   assertNonEmptySamples(fnName, samples, argName);
   assertFiniteSamples(fnName, samples, validate, argName);
 }
+function assertSamplesInWindow(fnName, samples, validate, windowStart, windowLength, argName = "samples") {
+  assertNonEmptySamples(fnName, samples, argName);
+  if (!validate) {
+    return;
+  }
+  const start = Math.min(Math.max(Math.floor(windowStart), 0), samples.length);
+  const stop = Math.min(start + Math.max(Math.ceil(windowLength), 0), samples.length);
+  for (let i = start; i < stop; i++) {
+    const v = samples[i];
+    if (!Number.isFinite(v)) {
+      throw new RangeError(`${fnName}: ${argName} contains NaN or Inf at index ${i}`);
+    }
+  }
+}
 function assertFiniteScalar(fnName, value, argName) {
   if (!Number.isFinite(value)) {
     throw new RangeError(`${fnName}: ${argName} must be a finite number`);
   }
 }
-function assertSampleRate(fnName, sampleRate) {
-  if (!Number.isInteger(sampleRate) || sampleRate < MIN_AUDIO_SAMPLE_RATE || sampleRate > MAX_AUDIO_SAMPLE_RATE) {
+function assertVqtGamma(fnName, gamma) {
+  if (gamma === Number.POSITIVE_INFINITY || gamma === Number.NEGATIVE_INFINITY) {
+    throw new RangeError(`${fnName}: gamma must not be infinite`);
+  }
+}
+function assertSampleRate(fnName, sampleRate, argName = "sampleRate") {
+  if (!Number.isInteger(sampleRate)) {
+    throw new RangeError(`${fnName}: ${argName} must be an integer`);
+  }
+  if (sampleRate < MIN_AUDIO_SAMPLE_RATE || sampleRate > MAX_AUDIO_SAMPLE_RATE) {
     throw new RangeError(
-      `${fnName}: sampleRate out of supported range [${MIN_AUDIO_SAMPLE_RATE}, ${MAX_AUDIO_SAMPLE_RATE}]`
+      `${fnName}: ${argName} out of supported range [${MIN_AUDIO_SAMPLE_RATE}, ${MAX_AUDIO_SAMPLE_RATE}]`
     );
   }
 }
+var C_INT_MAX = 2147483647;
 function assertNonNegativeInteger(fnName, value, argName) {
   if (!Number.isInteger(value) || value < 0) {
     throw new RangeError(`${fnName}: ${argName} must be a non-negative integer`);
   }
 }
 function assertPositiveInteger(fnName, value, argName) {
-  if (!Number.isInteger(value) || value <= 0) {
+  if (!Number.isInteger(value)) {
+    throw new RangeError(`${fnName}: ${argName} must be an integer`);
+  }
+  if (value <= 0 || value > C_INT_MAX) {
     throw new RangeError(`${fnName}: ${argName} must be a positive integer`);
   }
 }
+function assertIntegerValue(fnName, value, argName) {
+  if (typeof value !== "number") {
+    throw new TypeError(`${fnName}: ${argName} must be an integer`);
+  }
+  if (!Number.isInteger(value)) {
+    throw new RangeError(`${fnName}: ${argName} must be an integer`);
+  }
+}
+function assertEvenIntegerAtLeast(fnName, value, argName, min, max) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new RangeError(`${fnName}: ${argName} must be an integer in [${min}, ${max}]`);
+  }
+  if (value % 2 !== 0) {
+    throw new RangeError(`${fnName}: ${argName} must be an even integer`);
+  }
+}
 function assertInterleavedSamples(fnName, samples, channels, validate) {
   assertSamples(fnName, samples, validate);
   assertPositiveInteger(fnName, channels, "channels");
@@ -451,103 +530,444 @@ function assertInterleavedSamples(fnName, samples, channels, validate) {
   }
 }
 
-// src/feature_music.ts
+// src/_fft_options.ts
+function resolveFftOptions(fnName, nFft, hopLength) {
+  const resolvedNFft = nFft === void 0 ? 2048 : nFft;
+  const resolvedHopLength = hopLength === void 0 ? 512 : hopLength;
+  assertIntegerValue(fnName, resolvedNFft, "nFft");
+  assertEvenIntegerAtLeast(fnName, resolvedNFft, "nFft", 2, 2 ** 30);
+  assertIntegerValue(fnName, resolvedHopLength, "hopLength");
+  assertPositiveInteger(fnName, resolvedHopLength, "hopLength");
+  return { nFft: resolvedNFft, hopLength: resolvedHopLength };
+}
+
+// src/feature_decompose.ts
 function requireModule2() {
   return getSonareModule();
 }
-function validateMusicSamples(fnName, samples, sampleRate, options = {}) {
-  assertSampleRate(fnName, sampleRate);
-  assertSamples(fnName, samples, options.validate !== false);
+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 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 requireModule2().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 requireModule2().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 requireModule2().segmentRecurrenceToLag(
+    request.recurrence,
+    request.n,
+    request.pad ?? false
+  );
+}
+function segmentLagToRecurrence(request) {
+  validateSegmentMatrix("segmentLagToRecurrence", request.lag, request.rows, request.lags, "lag");
+  return requireModule2().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 requireModule2().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 requireModule2().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 requireModule2().segmentPathEnhance(
+    request.recurrence,
+    request.n,
+    request.win,
+    request.maxRatio ?? 2,
+    request.minRatio ?? 0,
+    request.nFilters ?? 7
+  );
 }
+
+// src/_feature_validation.ts
 function validatePositiveIntegers(fnName, values) {
   for (const [name, value] of Object.entries(values)) {
     assertPositiveInteger(fnName, value, name);
   }
 }
-function validateFrequencyBounds(fnName, fmin, fmax) {
+function validateMelFrequencyRange(fnName, fmin, fmax, sampleRate) {
   assertFiniteScalar(fnName, fmin, "fmin");
+  assertFiniteScalar(fnName, fmax, "fmax");
   if (fmin < 0) {
     throw new RangeError(`${fnName}: fmin must be non-negative`);
   }
-  if (fmax !== void 0) {
-    assertFiniteScalar(fnName, fmax, "fmax");
-    if (fmax <= fmin) {
-      throw new RangeError(`${fnName}: fmax must be greater than fmin`);
-    }
+  if (fmax < 0) {
+    throw new RangeError(`${fnName}: fmax must be non-negative`);
   }
-}
-function nnlsChroma(samples, sampleRate = 22050, options = {}) {
-  if (!(samples instanceof Float32Array)) {
-    return nnlsChroma(samples.samples, samples.sampleRate, samples);
+  const effectiveFmax = fmax === 0 ? sampleRate / 2 : fmax;
+  if (effectiveFmax <= fmin) {
+    throw new RangeError(`${fnName}: fmax must be greater than fmin`);
   }
-  validateMusicSamples("nnlsChroma", samples, sampleRate, options);
-  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");
+}
+
+// src/feature_inverse.ts
+function requireModule3() {
+  return getSonareModule();
+}
+function validateMatrix(fnName, data, rows, frames, dataName, rowName, options = {}) {
+  validatePositiveIntegers(fnName, { [rowName]: rows, nFrames: frames });
+  assertSamples(fnName, data, options.validate !== false, dataName);
+  const expectedLength = rows * frames;
+  if (!Number.isSafeInteger(expectedLength) || data.length !== expectedLength) {
+    throw new RangeError(`${fnName}: ${dataName} length must equal ${rowName} * nFrames`);
   }
-  return requireModule2().nnlsChromaEx(
-    samples,
-    sampleRate,
-    options.enableStftBlend ?? true,
-    options.stftBlendWeight ?? 0.55,
-    options.stftBlendNFft ?? 4096,
-    hopLength
-  );
 }
-function cqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
-  if (!(samples instanceof Float32Array)) {
-    const request = samples;
-    return cqt(
-      request.samples,
+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;
+    return melToStft(
+      request.melPower,
+      request.nMels,
+      request.nFrames,
       request.sampleRate,
-      request.hopLength,
+      request.nFft,
       request.fmin,
-      request.nBins,
-      request.binsPerOctave,
+      request.fmax,
+      request.htk,
       request
     );
   }
-  validateMusicSamples("cqt", samples, sampleRate, options);
-  validatePositiveIntegers("cqt", { hopLength, nBins, binsPerOctave });
-  validateFrequencyBounds("cqt", fmin);
-  return requireModule2().cqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+  assertSampleRate("melToStft", sampleRate);
+  validateMatrix("melToStft", melPower, nMels, nFrames, "melPower", "nMels", options);
+  validatePositiveIntegers("melToStft", { nFft });
+  validateMelFrequencyRange("melToStft", fmin, fmax, sampleRate);
+  return requireModule3().melToStft(melPower, nMels, nFrames, sampleRate, nFft, fmin, fmax, htk);
 }
-function pseudoCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
-  if (!(samples instanceof Float32Array)) {
-    const request = samples;
-    return pseudoCqt(
-      request.samples,
+function melToAudio(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, options = {}) {
+  if (!(melPower instanceof Float32Array)) {
+    const request = melPower;
+    return melToAudio(
+      request.melPower,
+      request.nMels,
+      request.nFrames,
       request.sampleRate,
+      request.nFft,
       request.hopLength,
       request.fmin,
-      request.nBins,
-      request.binsPerOctave,
+      request.fmax,
+      request.nIter,
+      request.htk,
       request
     );
   }
-  validateMusicSamples("pseudoCqt", samples, sampleRate, options);
-  validatePositiveIntegers("pseudoCqt", { hopLength, nBins, binsPerOctave });
-  validateFrequencyBounds("pseudoCqt", fmin);
-  return requireModule2().pseudoCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+  assertSampleRate("melToAudio", sampleRate);
+  validateMatrix("melToAudio", melPower, nMels, nFrames, "melPower", "nMels", options);
+  const fft = resolveFftOptions("melToAudio", nFft, hopLength);
+  validatePositiveIntegers("melToAudio", { nIter });
+  validateMelFrequencyRange("melToAudio", fmin, fmax, sampleRate);
+  return requireModule3().melToAudio(
+    melPower,
+    nMels,
+    nFrames,
+    sampleRate,
+    fft.nFft,
+    fft.hopLength,
+    fmin,
+    fmax,
+    nIter,
+    htk
+  );
 }
-function hybridCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
-  if (!(samples instanceof Float32Array)) {
-    const request = samples;
-    return hybridCqt(
-      request.samples,
+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.fmin,
-      request.nBins,
-      request.binsPerOctave,
-      request
+      request.nIter,
+      request.momentum,
+      request
+    );
+  }
+  assertSampleRate("griffinLim", sampleRate);
+  validateMatrix("griffinLim", magnitude, nBins, nFrames, "magnitude", "nBins", options);
+  const fft = resolveFftOptions("griffinLim", nFft, hopLength);
+  validatePositiveIntegers("griffinLim", { nIter });
+  return requireModule3().griffinLim(
+    magnitude,
+    nBins,
+    nFrames,
+    sampleRate,
+    fft.nFft,
+    fft.hopLength,
+    nIter,
+    momentum
+  );
+}
+function mfccToMel(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, lifter = 0, options = {}) {
+  if (!(mfccCoefficients instanceof Float32Array)) {
+    const request = mfccCoefficients;
+    return mfccToMel(
+      request.mfccCoefficients,
+      request.nMfcc,
+      request.nFrames,
+      request.nMels,
+      request.lifter,
+      request
+    );
+  }
+  validateMatrix(
+    "mfccToMel",
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    "mfccCoefficients",
+    "nMfcc",
+    options
+  );
+  validatePositiveIntegers("mfccToMel", { nMels });
+  return requireModule3().mfccToMel(mfccCoefficients, nMfcc, nFrames, nMels, lifter);
+}
+function mfccToAudio(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, lifter = 0, options = {}) {
+  if (!(mfccCoefficients instanceof Float32Array)) {
+    const request = mfccCoefficients;
+    return mfccToAudio(
+      request.mfccCoefficients,
+      request.nMfcc,
+      request.nFrames,
+      request.nMels,
+      request.sampleRate,
+      request.nFft,
+      request.hopLength,
+      request.fmin,
+      request.fmax,
+      request.nIter,
+      request.htk,
+      request.lifter,
+      request
+    );
+  }
+  assertSampleRate("mfccToAudio", sampleRate);
+  validateMatrix(
+    "mfccToAudio",
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    "mfccCoefficients",
+    "nMfcc",
+    options
+  );
+  const fft = resolveFftOptions("mfccToAudio", nFft, hopLength);
+  validatePositiveIntegers("mfccToAudio", { nMels, nIter });
+  validateMelFrequencyRange("mfccToAudio", fmin, fmax, sampleRate);
+  return requireModule3().mfccToAudio(
+    mfccCoefficients,
+    nMfcc,
+    nFrames,
+    nMels,
+    sampleRate,
+    fft.nFft,
+    fft.hopLength,
+    fmin,
+    fmax,
+    nIter,
+    htk,
+    lifter
+  );
+}
+
+// src/feature_loudness.ts
+function requireModule4() {
+  return getSonareModule();
+}
+function lufsInterleaved(samples, channels = 0, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return lufsInterleaved(r.samples, r.channels, r.sampleRate, r);
+  }
+  assertSampleRate("lufsInterleaved", sampleRate);
+  assertInterleavedSamples("lufsInterleaved", samples, channels, options.validate !== false);
+  return requireModule4().lufsInterleaved(samples, channels, sampleRate);
+}
+function lufsSeriesInterleaved(samples, channels = 0, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return lufsSeriesInterleaved(r.samples, r.channels, r.sampleRate, r);
+  }
+  assertSampleRate("lufsSeriesInterleaved", sampleRate);
+  assertInterleavedSamples("lufsSeriesInterleaved", samples, channels, options.validate !== false);
+  return requireModule4().lufsSeriesInterleaved(samples, channels, sampleRate);
+}
+function ebur128LoudnessRange(samples, sampleRate = 22050) {
+  if (!(samples instanceof Float32Array)) {
+    return ebur128LoudnessRange(samples.samples, samples.sampleRate);
+  }
+  return requireModule4().ebur128LoudnessRange(samples, sampleRate);
+}
+
+// src/feature_music.ts
+function requireModule5() {
+  return getSonareModule();
+}
+function validateMusicSamples(fnName, samples, sampleRate, options = {}) {
+  assertSampleRate(fnName, sampleRate);
+  assertSamples(fnName, samples, options.validate !== false);
+}
+function validateFrequencyBounds(fnName, fmin, fmax) {
+  assertFiniteScalar(fnName, fmin, "fmin");
+  if (fmin < 0) {
+    throw new RangeError(`${fnName}: fmin must be non-negative`);
+  }
+  if (fmax !== void 0) {
+    assertFiniteScalar(fnName, fmax, "fmax");
+    if (fmax <= fmin) {
+      throw new RangeError(`${fnName}: fmax must be greater than fmin`);
+    }
+  }
+}
+function nnlsChroma(samples, sampleRate = 22050, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    return nnlsChroma(samples.samples, samples.sampleRate, samples);
+  }
+  validateMusicSamples("nnlsChroma", samples, sampleRate, options);
+  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 requireModule5().nnlsChromaEx(
+    samples,
+    sampleRate,
+    options.enableStftBlend ?? true,
+    options.stftBlendWeight ?? 0.55,
+    options.stftBlendNFft ?? 4096,
+    hopLength
+  );
+}
+function cqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return cqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateMusicSamples("cqt", samples, sampleRate, options);
+  validatePositiveIntegers("cqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("cqt", fmin);
+  return requireModule5().cqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+}
+function pseudoCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return pseudoCqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
+    );
+  }
+  validateMusicSamples("pseudoCqt", samples, sampleRate, options);
+  validatePositiveIntegers("pseudoCqt", { hopLength, nBins, binsPerOctave });
+  validateFrequencyBounds("pseudoCqt", fmin);
+  return requireModule5().pseudoCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+}
+function hybridCqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, options = {}) {
+  if (!(samples instanceof Float32Array)) {
+    const request = samples;
+    return hybridCqt(
+      request.samples,
+      request.sampleRate,
+      request.hopLength,
+      request.fmin,
+      request.nBins,
+      request.binsPerOctave,
+      request
     );
   }
   validateMusicSamples("hybridCqt", samples, sampleRate, options);
   validatePositiveIntegers("hybridCqt", { hopLength, nBins, binsPerOctave });
   validateFrequencyBounds("hybridCqt", fmin);
-  return requireModule2().hybridCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
+  return requireModule5().hybridCqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave);
 }
 function vqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257483, nBins = 84, binsPerOctave = 12, gamma = -1, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -566,8 +986,8 @@ function vqt(samples, sampleRate = 22050, hopLength = 512, fmin = 32.70319566257
   validateMusicSamples("vqt", samples, sampleRate, options);
   validatePositiveIntegers("vqt", { hopLength, nBins, binsPerOctave });
   validateFrequencyBounds("vqt", fmin);
-  assertFiniteScalar("vqt", gamma, "gamma");
-  return requireModule2().vqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave, gamma);
+  assertVqtGamma("vqt", gamma);
+  return requireModule5().vqt(samples, sampleRate, hopLength, fmin, nBins, binsPerOctave, gamma);
 }
 function validateCqtInverse(fnName, magnitude, nBins, nFrames, sampleRate, hopLength, fmin, binsPerOctave, nIter, options) {
   assertSampleRate(fnName, sampleRate);
@@ -611,7 +1031,7 @@ function cqtToAudio(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, hopLe
     nIter,
     options
   );
-  return requireModule2().cqtToAudio(
+  return requireModule5().cqtToAudio(
     magnitude,
     nBins,
     nFrames,
@@ -650,8 +1070,8 @@ function vqtToAudio(magnitude, nBins = 0, nFrames = 0, sampleRate = 22050, hopLe
     nIter,
     options
   );
-  assertFiniteScalar("vqtToAudio", gamma, "gamma");
-  return requireModule2().vqtToAudio(
+  assertVqtGamma("vqtToAudio", gamma);
+  return requireModule5().vqtToAudio(
     magnitude,
     nBins,
     nFrames,
@@ -677,7 +1097,7 @@ function analyzeSections(samples, sampleRate = 22050, options = {}) {
   if ((options.minSectionSec ?? 4) < 0) {
     throw new RangeError("analyzeSections: minSectionSec must be non-negative");
   }
-  const sections = requireModule2().analyzeSections(
+  const sections = requireModule5().analyzeSections(
     samples,
     sampleRate,
     options.nFft ?? 2048,
@@ -686,6 +1106,49 @@ function analyzeSections(samples, sampleRate = 22050, options = {}) {
   );
   return Array.from(sections, (s) => ({ ...s, type: s.type }));
 }
+function detectBoundaries(request) {
+  const { samples, sampleRate = 22050 } = request;
+  validateMusicSamples("detectBoundaries", samples, sampleRate, request);
+  const sizes = {};
+  for (const name of ["nFft", "hopLength", "kernelSize", "nMfcc", "nChroma"]) {
+    const value = request[name];
+    if (value != null) {
+      sizes[name] = value;
+    }
+  }
+  validatePositiveIntegers("detectBoundaries", sizes);
+  for (const name of ["threshold", "absoluteThreshold", "peakDistance"]) {
+    const value = request[name];
+    if (value == null) {
+      continue;
+    }
+    assertFiniteScalar("detectBoundaries", value, name);
+    if (value < 0) {
+      throw new RangeError(`detectBoundaries: ${name} must be non-negative`);
+    }
+  }
+  if (request.useMfcc === false && request.useChroma === false) {
+    throw new SonareError(
+      4 /* InvalidParameter */,
+      "InvalidParameter",
+      "detectBoundaries: require useMfcc or useChroma"
+    );
+  }
+  const result = requireModule5().detectBoundaries(samples, sampleRate, request);
+  return {
+    boundaries: Array.from(result.boundaries, (b) => ({
+      time: b.time,
+      frame: b.frame,
+      strength: b.strength
+    })),
+    noveltyCurve: result.noveltyCurve,
+    noveltyPeak: result.noveltyPeak,
+    sampleRate: result.sampleRate,
+    hopLength: result.hopLength,
+    nFrames: result.nFrames,
+    frameStride: result.frameStride
+  };
+}
 function analyzeMelody(samples, sampleRate = 22050, options = {}) {
   if (!(samples instanceof Float32Array)) {
     const r = samples;
@@ -715,7 +1178,7 @@ function analyzeMelody(samples, sampleRate = 22050, options = {}) {
       "analyzeMelody: threshold must be positive"
     );
   }
-  return requireModule2().analyzeMelody(
+  return requireModule5().analyzeMelody(
     samples,
     sampleRate,
     options.fmin ?? 65,
@@ -740,8 +1203,9 @@ function onsetEnvelope(samples, sampleRate = 22050, nFft = 2048, hopLength = 512
     );
   }
   validateMusicSamples("onsetEnvelope", samples, sampleRate, options);
-  validatePositiveIntegers("onsetEnvelope", { nFft, hopLength, nMels });
-  return requireModule2().onsetEnvelope(samples, sampleRate, nFft, hopLength, nMels);
+  const fft = resolveFftOptions("onsetEnvelope", nFft, hopLength);
+  validatePositiveIntegers("onsetEnvelope", { nMels });
+  return requireModule5().onsetEnvelope(samples, sampleRate, fft.nFft, fft.hopLength, nMels);
 }
 function onsetStrengthMulti(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, nBands = 3, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -757,8 +1221,16 @@ function onsetStrengthMulti(samples, sampleRate = 22050, nFft = 2048, hopLength
     );
   }
   validateMusicSamples("onsetStrengthMulti", samples, sampleRate, options);
-  validatePositiveIntegers("onsetStrengthMulti", { nFft, hopLength, nMels, nBands });
-  return requireModule2().onsetStrengthMulti(samples, sampleRate, nFft, hopLength, nMels, nBands);
+  const fft = resolveFftOptions("onsetStrengthMulti", nFft, hopLength);
+  validatePositiveIntegers("onsetStrengthMulti", { nMels, nBands });
+  return requireModule5().onsetStrengthMulti(
+    samples,
+    sampleRate,
+    fft.nFft,
+    fft.hopLength,
+    nMels,
+    nBands
+  );
 }
 function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, winLength = 384, center = true, norm = true, options = {}) {
   if (!(onsetEnvelope2 instanceof Float32Array)) {
@@ -776,7 +1248,7 @@ function fourierTempogram(onsetEnvelope2, sampleRate = 22050, hopLength = 512, w
   assertSampleRate("fourierTempogram", sampleRate);
   assertSamples("fourierTempogram", onsetEnvelope2, options.validate !== false, "onsetEnvelope");
   validatePositiveIntegers("fourierTempogram", { hopLength, winLength });
-  return requireModule2().fourierTempogram(
+  return requireModule5().fourierTempogram(
     onsetEnvelope2,
     sampleRate,
     hopLength,
@@ -800,7 +1272,7 @@ function tempogramRatio(tempogramData, winLength = 384, sampleRate = 22050, hopL
   assertSampleRate("tempogramRatio", sampleRate);
   assertSamples("tempogramRatio", tempogramData, options.validate !== false, "tempogramData");
   validatePositiveIntegers("tempogramRatio", { winLength, hopLength });
-  return requireModule2().tempogramRatio(tempogramData, winLength, sampleRate, hopLength, factors);
+  return requireModule5().tempogramRatio(tempogramData, winLength, sampleRate, hopLength, factors);
 }
 function lufs(samples, sampleRate = 22050, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -809,7 +1281,7 @@ function lufs(samples, sampleRate = 22050, options = {}) {
   }
   assertSampleRate("lufs", sampleRate);
   assertSamples("lufs", samples, options.validate !== false);
-  return requireModule2().lufs(samples, sampleRate);
+  return requireModule5().lufs(samples, sampleRate);
 }
 function momentaryLufs(samples, sampleRate = 22050, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -818,7 +1290,7 @@ function momentaryLufs(samples, sampleRate = 22050, options = {}) {
   }
   assertSampleRate("momentaryLufs", sampleRate);
   assertSamples("momentaryLufs", samples, options.validate !== false);
-  return requireModule2().momentaryLufs(samples, sampleRate);
+  return requireModule5().momentaryLufs(samples, sampleRate);
 }
 function shortTermLufs(samples, sampleRate = 22050, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -827,11 +1299,11 @@ function shortTermLufs(samples, sampleRate = 22050, options = {}) {
   }
   assertSampleRate("shortTermLufs", sampleRate);
   assertSamples("shortTermLufs", samples, options.validate !== false);
-  return requireModule2().shortTermLufs(samples, sampleRate);
+  return requireModule5().shortTermLufs(samples, sampleRate);
 }
 
 // src/feature_pitch.ts
-function requireModule3() {
+function requireModule6() {
   return getSonareModule();
 }
 function piptrack(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 150, fmax = 4e3, threshold = 0.1) {
@@ -847,7 +1319,7 @@ function piptrack(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, fmi
       request.threshold
     );
   }
-  return requireModule3().piptrack(samples, sampleRate, nFft, hopLength, fmin, fmax, threshold);
+  return requireModule6().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)) {
@@ -863,7 +1335,7 @@ function pitchYin(samples, sampleRate = 22050, frameLength = 2048, hopLength = 5
       request.fillNa
     );
   }
-  return requireModule3().pitchYin(
+  return requireModule6().pitchYin(
     samples,
     sampleRate,
     frameLength,
@@ -888,7 +1360,7 @@ function pitchPyin(samples, sampleRate = 22050, frameLength = 2048, hopLength =
       request.fillNa
     );
   }
-  return requireModule3().pitchPyin(
+  return requireModule6().pitchPyin(
     samples,
     sampleRate,
     frameLength,
@@ -900,115 +1372,19 @@ function pitchPyin(samples, sampleRate = 22050, frameLength = 2048, hopLength =
   );
 }
 function noteSegments(request) {
-  return requireModule3().noteSegments(request.f0Hz, request.voicedProb, request.frameRate, {
+  return requireModule6().noteSegments(request.f0Hz, request.voicedProb, request.frameRate, {
     segmentationThresholdCents: request.segmentationThresholdCents,
     minNoteMs: request.minNoteMs,
-    referenceHz: request.referenceHz
+    referenceHz: request.referenceHz,
+    voicedThreshold: request.voicedThreshold
   });
 }
-
-// src/feature_resample.ts
-function requireModule4() {
-  return getSonareModule();
-}
-function resample(samples, srcSr, targetSr) {
-  if (!(samples instanceof Float32Array)) {
-    return resample(samples.samples, samples.srcSr, samples.targetSr);
-  }
-  return requireModule4().resample(samples, srcSr, targetSr);
-}
-
-// src/feature_spectral.ts
-function requireModule5() {
-  return getSonareModule();
-}
-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 resolveHardMask(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);
-  }
-  return requireModule5().spectralCentroid(samples, sampleRate, nFft, hopLength);
-}
-function spectralContrast(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nBands = 6, fmin = 200, quantile = 0.02) {
-  if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return spectralContrast(
-      r.samples,
-      r.sampleRate,
-      r.nFft,
-      r.hopLength,
-      r.nBands,
-      r.fmin,
-      r.quantile
-    );
-  }
-  return requireModule5().spectralContrast(
-    samples,
-    sampleRate,
-    nFft,
-    hopLength,
-    nBands,
-    fmin,
-    quantile
-  );
-}
-function polyFeatures(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, order = 1) {
-  if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return polyFeatures(r.samples, r.sampleRate, r.nFft, r.hopLength, r.order);
-  }
-  return requireModule5().polyFeatures(samples, sampleRate, nFft, hopLength, order);
-}
-function zeroCrossings(samples, threshold = 1e-10, refMagnitude = false, pad = true, zeroPos = true) {
-  if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return zeroCrossings(r.samples, r.threshold, r.refMagnitude, r.pad, r.zeroPos);
-  }
-  return requireModule5().zeroCrossings(samples, threshold, refMagnitude, pad, zeroPos);
-}
 function pitchTuning(frequencies, resolution = 0.01, binsPerOctave = 12) {
   if (!(frequencies instanceof Float32Array)) {
     const r = frequencies;
     return pitchTuning(r.frequencies, r.resolution, r.binsPerOctave);
   }
-  return requireModule5().pitchTuning(frequencies, resolution, binsPerOctave);
+  return requireModule6().pitchTuning(frequencies, resolution, binsPerOctave);
 }
 function estimateTuning(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, resolution = 0.01, binsPerOctave = 12) {
   if (!(samples instanceof Float32Array)) {
@@ -1022,7 +1398,7 @@ function estimateTuning(samples, sampleRate = 22050, nFft = 2048, hopLength = 51
       r.binsPerOctave
     );
   }
-  return requireModule5().estimateTuning(
+  return requireModule6().estimateTuning(
     samples,
     sampleRate,
     nFft,
@@ -1031,322 +1407,121 @@ function estimateTuning(samples, sampleRate = 22050, nFft = 2048, hopLength = 51
     binsPerOctave
   );
 }
-function decompose(s, nFeatures = 0, nFrames = 0, nComponents = 0, nIter = 50, beta = 2) {
-  if (!(s instanceof Float32Array)) {
-    const request = s;
-    return decompose(
-      request.s,
-      request.nFeatures,
-      request.nFrames,
-      request.nComponents,
-      request.nIter,
-      request.beta
-    );
-  }
-  return requireModule5().decompose(s, nFeatures, nFrames, nComponents, nIter, beta);
-}
-function decomposeWithInit(s, nFeatures = 0, nFrames = 0, nComponents = 0, nIter = 50, beta = 2, init2 = "random") {
-  if (!(s instanceof Float32Array)) {
-    const request = s;
-    return decomposeWithInit(
-      request.s,
-      request.nFeatures,
-      request.nFrames,
-      request.nComponents,
-      request.nIter,
-      request.beta,
-      request.init
-    );
-  }
-  return requireModule5().decomposeWithInit(s, nFeatures, nFrames, nComponents, nIter, beta, init2);
-}
-function nnFilter(s, nFeatures = 0, nFrames = 0, aggregate = "mean", k = 7, width = 1) {
-  if (!(s instanceof Float32Array)) {
-    const r = s;
-    return nnFilter(r.s, r.nFeatures, r.nFrames, r.aggregate, r.k, r.width);
-  }
-  return requireModule5().nnFilter(s, nFeatures, nFrames, aggregate, k, width);
-}
-function remix(samples, intervals, sampleRate = 22050, alignZeros = false) {
-  if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return remix(r.samples, r.intervals, r.sampleRate, r.alignZeros);
-  }
-  const intervalsI32 = intervals instanceof Int32Array ? intervals : Int32Array.from(intervals, (v) => Math.trunc(v));
-  return requireModule5().remix(samples, intervalsI32, sampleRate, alignZeros);
+
+// src/feature_spectral.ts
+function requireModule7() {
+  return getSonareModule();
 }
-function phaseVocoder(samples, sampleRate = 22050, rate = 1, nFft = 2048, hopLength = 512) {
+function spectralCentroid(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
   if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return phaseVocoder(r.samples, r.sampleRate ?? 22050, r.rate, r.nFft, r.hopLength);
+    return spectralCentroid(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
   }
-  return requireModule5().phaseVocoder(samples, sampleRate, rate, nFft, hopLength);
+  return requireModule7().spectralCentroid(samples, sampleRate, nFft, hopLength);
 }
-function hpssWithResidual(samples, sampleRate = 22050, kernelHarmonic = 31, kernelPercussive = 31, nFft, hopLength, hardMask) {
+function spectralContrast(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nBands = 6, fmin = 200, quantile = 0.02) {
   if (!(samples instanceof Float32Array)) {
     const r = samples;
-    return hpssWithResidual(
+    return spectralContrast(
       r.samples,
       r.sampleRate,
-      r.kernelHarmonic,
-      r.kernelPercussive,
       r.nFft,
       r.hopLength,
-      r.hardMask
+      r.nBands,
+      r.fmin,
+      r.quantile
     );
   }
-  const fftOptions = resolveEffectFftOptions("hpssWithResidual", nFft, hopLength);
-  const resolvedHardMask = resolveHardMask("hpssWithResidual", hardMask);
-  return requireModule5().hpssWithResidualEx(
+  return requireModule7().spectralContrast(
     samples,
     sampleRate,
-    kernelHarmonic,
-    kernelPercussive,
-    fftOptions.nFft,
-    fftOptions.hopLength,
-    resolvedHardMask
-  );
-}
-function lufsInterleaved(samples, channels = 0, sampleRate = 22050, options = {}) {
-  if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return lufsInterleaved(r.samples, r.channels, r.sampleRate, r);
-  }
-  assertSampleRate("lufsInterleaved", sampleRate);
-  assertInterleavedSamples("lufsInterleaved", samples, channels, options.validate !== false);
-  return requireModule5().lufsInterleaved(samples, channels, sampleRate);
-}
-function ebur128LoudnessRange(samples, sampleRate = 22050) {
-  if (!(samples instanceof Float32Array)) {
-    return ebur128LoudnessRange(samples.samples, samples.sampleRate);
-  }
-  return requireModule5().ebur128LoudnessRange(samples, sampleRate);
-}
-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,
-      samples.p
-    );
-  }
-  return requireModule5().spectralBandwidth(samples, sampleRate, nFft, hopLength, p);
-}
-function spectralRolloff(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, rollPercent = 0.85) {
-  if (!(samples instanceof Float32Array)) {
-    return spectralRolloff(
-      samples.samples,
-      samples.sampleRate,
-      samples.nFft,
-      samples.hopLength,
-      samples.rollPercent
-    );
-  }
-  return requireModule5().spectralRolloff(samples, sampleRate, nFft, hopLength, rollPercent);
-}
-function spectralFlatness(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
-  if (!(samples instanceof Float32Array)) {
-    return spectralFlatness(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
-  }
-  return requireModule5().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 requireModule5().spectralFlux(samples, sampleRate, nFft, hopLength, lag);
-}
-function zeroCrossingRate(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
-  if (!(samples instanceof Float32Array)) {
-    return zeroCrossingRate(
-      samples.samples,
-      samples.sampleRate,
-      samples.frameLength,
-      samples.hopLength
-    );
-  }
-  return requireModule5().zeroCrossingRate(samples, sampleRate, frameLength, hopLength);
-}
-function rmsEnergy(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
-  if (!(samples instanceof Float32Array)) {
-    return rmsEnergy(samples.samples, samples.sampleRate, samples.frameLength, samples.hopLength);
-  }
-  return requireModule5().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 requireModule5().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 requireModule5().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 requireModule5().segmentRecurrenceToLag(
-    request.recurrence,
-    request.n,
-    request.pad ?? false
-  );
-}
-function segmentLagToRecurrence(request) {
-  validateSegmentMatrix("segmentLagToRecurrence", request.lag, request.rows, request.lags, "lag");
-  return requireModule5().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 requireModule5().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 requireModule5().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 requireModule5().segmentPathEnhance(
-    request.recurrence,
-    request.n,
-    request.win,
-    request.maxRatio ?? 2,
-    request.minRatio ?? 0,
-    request.nFilters ?? 7
-  );
-}
-
-// src/feature_spectrogram.ts
-function requireModule6() {
-  return getSonareModule();
-}
-function validateSpectrogramSamples(fnName, samples, sampleRate, options = {}) {
-  assertSampleRate(fnName, sampleRate);
-  assertSamples(fnName, samples, options.validate !== false);
+    nFft,
+    hopLength,
+    nBands,
+    fmin,
+    quantile
+  );
 }
-function validatePositiveIntegers2(fnName, values) {
-  for (const [name, value] of Object.entries(values)) {
-    assertPositiveInteger(fnName, value, name);
+function polyFeatures(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, order = 1) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return polyFeatures(r.samples, r.sampleRate, r.nFft, r.hopLength, r.order);
   }
+  return requireModule7().polyFeatures(samples, sampleRate, nFft, hopLength, order);
 }
-function validateMelFrequencyRange(fnName, fmin, fmax, sampleRate) {
-  assertFiniteScalar(fnName, fmin, "fmin");
-  assertFiniteScalar(fnName, fmax, "fmax");
-  if (fmin < 0) {
-    throw new RangeError(`${fnName}: fmin must be non-negative`);
+function zeroCrossings(samples, threshold = 1e-10, refMagnitude = false, pad = true, zeroPos = true) {
+  if (!(samples instanceof Float32Array)) {
+    const r = samples;
+    return zeroCrossings(r.samples, r.threshold, r.refMagnitude, r.pad, r.zeroPos);
   }
-  if (fmax < 0) {
-    throw new RangeError(`${fnName}: fmax must be non-negative`);
+  return requireModule7().zeroCrossings(samples, threshold, refMagnitude, pad, zeroPos);
+}
+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,
+      samples.p
+    );
   }
-  const effectiveFmax = fmax === 0 ? sampleRate / 2 : fmax;
-  if (effectiveFmax <= fmin) {
-    throw new RangeError(`${fnName}: fmax must be greater than fmin`);
+  return requireModule7().spectralBandwidth(samples, sampleRate, nFft, hopLength, p);
+}
+function spectralRolloff(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, rollPercent = 0.85) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralRolloff(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.rollPercent
+    );
   }
+  return requireModule7().spectralRolloff(samples, sampleRate, nFft, hopLength, rollPercent);
 }
-function validateMatrix(fnName, data, rows, frames, dataName, rowName, options = {}) {
-  validatePositiveIntegers2(fnName, { [rowName]: rows, nFrames: frames });
-  assertSamples(fnName, data, options.validate !== false, dataName);
-  const expectedLength = rows * frames;
-  if (!Number.isSafeInteger(expectedLength) || data.length !== expectedLength) {
-    throw new RangeError(`${fnName}: ${dataName} length must equal ${rowName} * nFrames`);
+function spectralFlatness(samples, sampleRate = 22050, nFft = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return spectralFlatness(samples.samples, samples.sampleRate, samples.nFft, samples.hopLength);
   }
+  return requireModule7().spectralFlatness(samples, sampleRate, nFft, hopLength);
 }
-function trim(samples, sampleRate = 22050, thresholdDb = -60, frameLengthOrOptions, hopLength, options = {}) {
+function spectralFlux(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, lag = 1) {
   if (!(samples instanceof Float32Array)) {
-    const r = samples;
-    return trim(r.samples, r.sampleRate, r.thresholdDb, r.frameLength, r.hopLength, r);
+    return spectralFlux(
+      samples.samples,
+      samples.sampleRate,
+      samples.nFft,
+      samples.hopLength,
+      samples.lag
+    );
   }
-  if (frameLengthOrOptions === null) {
-    throw new TypeError("trim: frameLength must be an integer or options object");
+  return requireModule7().spectralFlux(samples, sampleRate, nFft, hopLength, lag);
+}
+function zeroCrossingRate(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return zeroCrossingRate(
+      samples.samples,
+      samples.sampleRate,
+      samples.frameLength,
+      samples.hopLength
+    );
   }
-  if (frameLengthOrOptions !== void 0 && typeof frameLengthOrOptions !== "number" && typeof frameLengthOrOptions !== "object") {
-    throw new TypeError("trim: frameLength must be an integer or options object");
+  return requireModule7().zeroCrossingRate(samples, sampleRate, frameLength, hopLength);
+}
+function rmsEnergy(samples, sampleRate = 22050, frameLength = 2048, hopLength = 512) {
+  if (!(samples instanceof Float32Array)) {
+    return rmsEnergy(samples.samples, samples.sampleRate, samples.frameLength, samples.hopLength);
   }
-  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");
-  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 requireModule6().trimEx(
-    samples,
-    sampleRate,
-    thresholdDb,
-    resolvedFrameLength,
-    resolvedHopLength
-  );
+  return requireModule7().rmsEnergy(samples, sampleRate, frameLength, hopLength);
+}
+
+// src/feature_spectrogram.ts
+function requireModule8() {
+  return getSonareModule();
+}
+function validateSpectrogramSamples(fnName, samples, sampleRate, options = {}) {
+  assertSampleRate(fnName, sampleRate);
+  assertSamples(fnName, samples, options.validate !== false);
 }
 function stft(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1354,8 +1529,8 @@ function stft(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options
     return stft(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
   }
   validateSpectrogramSamples("stft", samples, sampleRate, options);
-  validatePositiveIntegers2("stft", { nFft, hopLength });
-  return requireModule6().stft(samples, sampleRate, nFft, hopLength);
+  const fft = resolveFftOptions("stft", nFft, hopLength);
+  return requireModule8().stft(samples, sampleRate, fft.nFft, fft.hopLength);
 }
 function stftDb(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1363,8 +1538,8 @@ function stftDb(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, optio
     return stftDb(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
   }
   validateSpectrogramSamples("stftDb", samples, sampleRate, options);
-  validatePositiveIntegers2("stftDb", { nFft, hopLength });
-  return requireModule6().stftDb(samples, sampleRate, nFft, hopLength);
+  const fft = resolveFftOptions("stftDb", nFft, hopLength);
+  return requireModule8().stftDb(samples, sampleRate, fft.nFft, fft.hopLength);
 }
 function chromaCens(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, binsPerOctave = 36, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1379,11 +1554,11 @@ function chromaCens(samples, sampleRate = 22050, hopLength = 512, nChroma = 12,
     );
   }
   validateSpectrogramSamples("chromaCens", samples, sampleRate, options);
-  validatePositiveIntegers2("chromaCens", { hopLength, nChroma, binsPerOctave });
+  validatePositiveIntegers("chromaCens", { hopLength, nChroma, binsPerOctave });
   if (binsPerOctave % nChroma !== 0) {
     throw new RangeError("chromaCens: binsPerOctave must be a multiple of nChroma");
   }
-  return requireModule6().chromaCens(samples, sampleRate, hopLength, nChroma, binsPerOctave);
+  return requireModule8().chromaCens(samples, sampleRate, hopLength, nChroma, binsPerOctave);
 }
 function chromaCqt(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, binsPerOctave = 36, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1398,11 +1573,11 @@ function chromaCqt(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, b
     );
   }
   validateSpectrogramSamples("chromaCqt", samples, sampleRate, options);
-  validatePositiveIntegers2("chromaCqt", { hopLength, nChroma, binsPerOctave });
+  validatePositiveIntegers("chromaCqt", { hopLength, nChroma, binsPerOctave });
   if (binsPerOctave % nChroma !== 0) {
     throw new RangeError("chromaCqt: binsPerOctave must be a multiple of nChroma");
   }
-  return requireModule6().chromaCqt(samples, sampleRate, hopLength, nChroma, binsPerOctave);
+  return requireModule8().chromaCqt(samples, sampleRate, hopLength, nChroma, binsPerOctave);
 }
 function bassChroma(samples, sampleRate = 22050, hopLength = 512, nChroma = 12, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1416,8 +1591,8 @@ function bassChroma(samples, sampleRate = 22050, hopLength = 512, nChroma = 12,
     );
   }
   validateSpectrogramSamples("bassChroma", samples, sampleRate, options);
-  validatePositiveIntegers2("bassChroma", { hopLength, nChroma });
-  return requireModule6().bassChroma(samples, sampleRate, hopLength, nChroma);
+  validatePositiveIntegers("bassChroma", { hopLength, nChroma });
+  return requireModule8().bassChroma(samples, sampleRate, hopLength, nChroma);
 }
 function melSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels = 128, fmin = 0, fmax = 0, htk = false, options = {}) {
   if (!(samples instanceof Float32Array)) {
@@ -1435,13 +1610,14 @@ function melSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLength = 51
     );
   }
   validateSpectrogramSamples("melSpectrogram", samples, sampleRate, options);
-  validatePositiveIntegers2("melSpectrogram", { nFft, hopLength, nMels });
+  const fft = resolveFftOptions("melSpectrogram", nFft, hopLength);
+  validatePositiveIntegers("melSpectrogram", { nMels });
   validateMelFrequencyRange("melSpectrogram", fmin, fmax, sampleRate);
-  return requireModule6().melSpectrogram(
+  return requireModule8().melSpectrogram(
     samples,
     sampleRate,
-    nFft,
-    hopLength,
+    fft.nFft,
+    fft.hopLength,
     nMels,
     fmin,
     fmax,
@@ -1466,13 +1642,14 @@ function mfcc(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, nMels =
     );
   }
   validateSpectrogramSamples("mfcc", samples, sampleRate, options);
-  validatePositiveIntegers2("mfcc", { nFft, hopLength, nMels, nMfcc });
+  const fft = resolveFftOptions("mfcc", nFft, hopLength);
+  validatePositiveIntegers("mfcc", { nMels, nMfcc });
   validateMelFrequencyRange("mfcc", fmin, fmax, sampleRate);
-  return requireModule6().mfcc(
+  return requireModule8().mfcc(
     samples,
     sampleRate,
-    nFft,
-    hopLength,
+    fft.nFft,
+    fft.hopLength,
     nMels,
     nMfcc,
     fmin,
@@ -1492,7 +1669,7 @@ function melDelta(features, nFeatures, nFrames, width = 9) {
   if (request.features.length !== request.nFeatures * request.nFrames) {
     throw new RangeError("melDelta: feature matrix length must equal nFeatures * nFrames");
   }
-  return requireModule6().melDelta(
+  return requireModule8().melDelta(
     request.features,
     request.nFeatures,
     request.nFrames,
@@ -1519,7 +1696,7 @@ function reassignedSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLeng
   if (refPower < 0) {
     throw new RangeError("reassignedSpectrogram: refPower must be non-negative");
   }
-  return requireModule6().reassignedSpectrogram(
+  return requireModule8().reassignedSpectrogram(
     samples,
     sampleRate,
     nFft,
@@ -1528,171 +1705,18 @@ function reassignedSpectrogram(samples, sampleRate = 22050, nFft = 2048, hopLeng
     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;
-    return melToStft(
-      request.melPower,
-      request.nMels,
-      request.nFrames,
-      request.sampleRate,
-      request.nFft,
-      request.fmin,
-      request.fmax,
-      request.htk,
-      request
-    );
-  }
-  assertSampleRate("melToStft", sampleRate);
-  validateMatrix("melToStft", melPower, nMels, nFrames, "melPower", "nMels", options);
-  validatePositiveIntegers2("melToStft", { nFft });
-  validateMelFrequencyRange("melToStft", fmin, fmax, sampleRate);
-  return requireModule6().melToStft(melPower, nMels, nFrames, sampleRate, nFft, fmin, fmax, htk);
-}
-function melToAudio(melPower, nMels = 0, nFrames = 0, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, options = {}) {
-  if (!(melPower instanceof Float32Array)) {
-    const request = melPower;
-    return melToAudio(
-      request.melPower,
-      request.nMels,
-      request.nFrames,
-      request.sampleRate,
-      request.nFft,
-      request.hopLength,
-      request.fmin,
-      request.fmax,
-      request.nIter,
-      request.htk,
-      request
-    );
-  }
-  assertSampleRate("melToAudio", sampleRate);
-  validateMatrix("melToAudio", melPower, nMels, nFrames, "melPower", "nMels", options);
-  validatePositiveIntegers2("melToAudio", { nFft, hopLength, nIter });
-  validateMelFrequencyRange("melToAudio", fmin, fmax, sampleRate);
-  return requireModule6().melToAudio(
-    melPower,
-    nMels,
-    nFrames,
-    sampleRate,
-    nFft,
-    hopLength,
-    fmin,
-    fmax,
-    nIter,
-    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 requireModule6().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;
-    return mfccToMel(
-      request.mfccCoefficients,
-      request.nMfcc,
-      request.nFrames,
-      request.nMels,
-      request.lifter,
-      request
-    );
-  }
-  validateMatrix(
-    "mfccToMel",
-    mfccCoefficients,
-    nMfcc,
-    nFrames,
-    "mfccCoefficients",
-    "nMfcc",
-    options
-  );
-  validatePositiveIntegers2("mfccToMel", { nMels });
-  return requireModule6().mfccToMel(mfccCoefficients, nMfcc, nFrames, nMels, lifter);
-}
-function mfccToAudio(mfccCoefficients, nMfcc = 0, nFrames = 0, nMels = 128, sampleRate = 22050, nFft = 2048, hopLength = 512, fmin = 0, fmax = 0, nIter = 32, htk = false, lifter = 0, options = {}) {
-  if (!(mfccCoefficients instanceof Float32Array)) {
-    const request = mfccCoefficients;
-    return mfccToAudio(
-      request.mfccCoefficients,
-      request.nMfcc,
-      request.nFrames,
-      request.nMels,
-      request.sampleRate,
-      request.nFft,
-      request.hopLength,
-      request.fmin,
-      request.fmax,
-      request.nIter,
-      request.htk,
-      request.lifter,
-      request
-    );
-  }
-  assertSampleRate("mfccToAudio", sampleRate);
-  validateMatrix(
-    "mfccToAudio",
-    mfccCoefficients,
-    nMfcc,
-    nFrames,
-    "mfccCoefficients",
-    "nMfcc",
-    options
-  );
-  validatePositiveIntegers2("mfccToAudio", { nMels, nFft, hopLength, nIter });
-  validateMelFrequencyRange("mfccToAudio", fmin, fmax, sampleRate);
-  return requireModule6().mfccToAudio(
-    mfccCoefficients,
-    nMfcc,
-    nFrames,
-    nMels,
-    sampleRate,
-    nFft,
-    hopLength,
-    fmin,
-    fmax,
-    nIter,
-    htk,
-    lifter
-  );
-}
 function chroma(samples, sampleRate = 22050, nFft = 2048, hopLength = 512, options = {}) {
   if (!(samples instanceof Float32Array)) {
     const request = samples;
     return chroma(request.samples, request.sampleRate, request.nFft, request.hopLength, request);
   }
   validateSpectrogramSamples("chroma", samples, sampleRate, options);
-  validatePositiveIntegers2("chroma", { nFft, hopLength });
-  return requireModule6().chroma(samples, sampleRate, nFft, hopLength);
+  const fft = resolveFftOptions("chroma", nFft, hopLength);
+  return requireModule8().chroma(samples, sampleRate, fft.nFft, fft.hopLength);
 }
 
 // src/metering.ts
+var DEFAULT_SPECTRUM_N_FFT = 2048;
 function assertOversampleFactor(fnName, factor) {
   const normalized = factor === 0 ? 4 : factor;
   if (!Number.isInteger(normalized) || normalized < 1 || normalized > 16 || (normalized & normalized - 1) !== 0) {
@@ -1703,23 +1727,23 @@ function assertOversampleFactor(fnName, factor) {
     );
   }
 }
-function requireModule7() {
+function requireModule9() {
   return getSonareModule();
 }
 function meteringPeakDb(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringPeakDb", request.samples, request.validate !== false);
-  return requireModule7().meteringPeakDb(request.samples, request.sampleRate ?? 22050);
+  return requireModule9().meteringPeakDb(request.samples, request.sampleRate ?? 22050);
 }
 function meteringRmsDb(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringRmsDb", request.samples, request.validate !== false);
-  return requireModule7().meteringRmsDb(request.samples, request.sampleRate ?? 22050);
+  return requireModule9().meteringRmsDb(request.samples, request.sampleRate ?? 22050);
 }
 function meteringSilenceRatio(samples, sampleRate = 22050, thresholdDb = -45, frameLength = 1024, hopLength = 256, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, thresholdDb, frameLength, hopLength, ...options } : samples;
   assertSamples("meteringSilenceRatio", request.samples, request.validate !== false);
-  return requireModule7().meteringSilenceRatio(
+  return requireModule9().meteringSilenceRatio(
     request.samples,
     request.sampleRate ?? 22050,
     request.thresholdDb ?? -45,
@@ -1730,12 +1754,12 @@ function meteringSilenceRatio(samples, sampleRate = 22050, thresholdDb = -45, fr
 function meteringCrestFactorDb(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringCrestFactorDb", request.samples, request.validate !== false);
-  return requireModule7().meteringCrestFactorDb(request.samples, request.sampleRate ?? 22050);
+  return requireModule9().meteringCrestFactorDb(request.samples, request.sampleRate ?? 22050);
 }
 function meteringCrestFactorDbStereo(request) {
   assertSamples("meteringCrestFactorDbStereo", request.left, request.validate !== false);
   assertSamples("meteringCrestFactorDbStereo", request.right, request.validate !== false);
-  return requireModule7().meteringCrestFactorDbStereo(
+  return requireModule9().meteringCrestFactorDbStereo(
     request.left,
     request.right,
     request.sampleRate ?? 22050
@@ -1744,23 +1768,21 @@ function meteringCrestFactorDbStereo(request) {
 function meteringDcOffset(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringDcOffset", request.samples, request.validate !== false);
-  return requireModule7().meteringDcOffset(request.samples, request.sampleRate ?? 22050);
+  return requireModule9().meteringDcOffset(request.samples, request.sampleRate ?? 22050);
 }
 function meteringTruePeakDb(samples, sampleRate = 22050, oversampleFactor = 4, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, oversampleFactor, ...options } : samples;
   assertSamples("meteringTruePeakDb", request.samples, request.validate !== false);
   const factor = request.oversampleFactor ?? 4;
   assertOversampleFactor("meteringTruePeakDb", factor);
-  return requireModule7().meteringTruePeakDb(request.samples, request.sampleRate ?? 22050, factor);
+  return requireModule9().meteringTruePeakDb(request.samples, request.sampleRate ?? 22050, factor);
 }
 function meteringDetectClipping(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringDetectClipping", request.samples, request.validate !== false);
   const minRegionSamples = request.minRegionSamples ?? 1;
-  if (!Number.isInteger(minRegionSamples) || minRegionSamples < 0) {
-    throw new RangeError("meteringDetectClipping: minRegionSamples must be a non-negative integer");
-  }
-  return requireModule7().meteringDetectClipping(
+  assertNonNegativeInteger("meteringDetectClipping", minRegionSamples, "minRegionSamples");
+  return requireModule9().meteringDetectClipping(
     request.samples,
     request.sampleRate ?? 22050,
     request.threshold ?? 0.999,
@@ -1770,7 +1792,7 @@ function meteringDetectClipping(samples, sampleRate = 22050, options = {}) {
 function meteringDynamicRange(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringDynamicRange", request.samples, request.validate !== false);
-  return requireModule7().meteringDynamicRange(
+  return requireModule9().meteringDynamicRange(
     request.samples,
     request.sampleRate ?? 22050,
     request.windowSec ?? 0,
@@ -1784,7 +1806,7 @@ function meteringStereoCorrelation(left, right, sampleRate = 22050, options = {}
   const validate = request.validate !== false;
   assertSamples("meteringStereoCorrelation", request.left, validate, "left");
   assertSamples("meteringStereoCorrelation", request.right, validate, "right");
-  return requireModule7().meteringStereoCorrelation(
+  return requireModule9().meteringStereoCorrelation(
     request.left,
     request.right,
     request.sampleRate ?? 22050
@@ -1795,7 +1817,7 @@ function meteringStereoWidth(left, right, sampleRate = 22050, options = {}) {
   const validate = request.validate !== false;
   assertSamples("meteringStereoWidth", request.left, validate, "left");
   assertSamples("meteringStereoWidth", request.right, validate, "right");
-  return requireModule7().meteringStereoWidth(
+  return requireModule9().meteringStereoWidth(
     request.left,
     request.right,
     request.sampleRate ?? 22050
@@ -1806,7 +1828,7 @@ function meteringVectorscope(left, right, sampleRate = 22050, options = {}) {
   const validate = request.validate !== false;
   assertSamples("meteringVectorscope", request.left, validate, "left");
   assertSamples("meteringVectorscope", request.right, validate, "right");
-  return requireModule7().meteringVectorscopeDecimated(
+  return requireModule9().meteringVectorscopeDecimated(
     request.left,
     request.right,
     request.sampleRate ?? 22050,
@@ -1818,7 +1840,7 @@ function meteringVectorscopeDecimated(left, right, sampleRate = 22050, maxPoints
   const validate = request.validate !== false;
   assertSamples("meteringVectorscopeDecimated", request.left, validate, "left");
   assertSamples("meteringVectorscopeDecimated", request.right, validate, "right");
-  return requireModule7().meteringVectorscopeDecimated(
+  return requireModule9().meteringVectorscopeDecimated(
     request.left,
     request.right,
     request.sampleRate ?? 22050,
@@ -1830,7 +1852,7 @@ function meteringPhaseScope(left, right, sampleRate = 22050, options = {}) {
   const validate = request.validate !== false;
   assertSamples("meteringPhaseScope", request.left, validate, "left");
   assertSamples("meteringPhaseScope", request.right, validate, "right");
-  return requireModule7().meteringPhaseScopeDecimated(
+  return requireModule9().meteringPhaseScopeDecimated(
     request.left,
     request.right,
     request.sampleRate ?? 22050,
@@ -1842,7 +1864,7 @@ function meteringPhaseScopeDecimated(left, right, sampleRate = 22050, maxPoints
   const validate = request.validate !== false;
   assertSamples("meteringPhaseScopeDecimated", request.left, validate, "left");
   assertSamples("meteringPhaseScopeDecimated", request.right, validate, "right");
-  return requireModule7().meteringPhaseScopeDecimated(
+  return requireModule9().meteringPhaseScopeDecimated(
     request.left,
     request.right,
     request.sampleRate ?? 22050,
@@ -1852,12 +1874,19 @@ function meteringPhaseScopeDecimated(left, right, sampleRate = 22050, maxPoints
 function meteringSpectrum(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   assertSamples("meteringSpectrum", request.samples, request.validate !== false);
-  return requireModule7().meteringSpectrum(request.samples, request.sampleRate ?? 22050, request);
+  return requireModule9().meteringSpectrum(request.samples, request.sampleRate ?? 22050, request);
 }
 function meteringSpectrumFrame(samples, sampleRate = 22050, frameOffset = 0, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, frameOffset, ...options } : samples;
-  assertSamples("meteringSpectrumFrame", request.samples, request.validate !== false);
-  return requireModule7().meteringSpectrumFrame(
+  const nFft = request.nFft ?? 0;
+  assertSamplesInWindow(
+    "meteringSpectrumFrame",
+    request.samples,
+    request.validate !== false,
+    request.frameOffset ?? 0,
+    nFft > 0 ? nFft : DEFAULT_SPECTRUM_N_FFT
+  );
+  return requireModule9().meteringSpectrumFrame(
     request.samples,
     request.sampleRate ?? 22050,
     request.frameOffset ?? 0,
@@ -1866,29 +1895,126 @@ function meteringSpectrumFrame(samples, sampleRate = 22050, frameOffset = 0, opt
 }
 function waveformPeaks(samples, channels, options = {}) {
   const request = samples instanceof Float32Array ? { samples, channels, ...options } : samples;
-  assertSamples("waveformPeaks", request.samples, request.validate !== false);
-  if (request.channels <= 0 || request.samples.length % request.channels !== 0) {
-    throw new RangeError("waveformPeaks: samples length must be a multiple of channels");
-  }
+  assertInterleavedSamples(
+    "waveformPeaks",
+    request.samples,
+    request.channels,
+    request.validate !== false
+  );
   const samplesPerBucket = request.samplesPerBucket ?? 512;
-  if (samplesPerBucket <= 0) {
-    throw new RangeError("waveformPeaks: samplesPerBucket must be > 0");
-  }
-  return requireModule7().waveformPeaks(request.samples, request.channels, samplesPerBucket);
+  assertPositiveInteger("waveformPeaks", samplesPerBucket, "samplesPerBucket");
+  return requireModule9().waveformPeaks(request.samples, request.channels, samplesPerBucket);
 }
 function waveformPeakPyramid(samples, channels, options = {}) {
   const request = samples instanceof Float32Array ? { samples, channels, ...options } : samples;
-  assertSamples("waveformPeakPyramid", request.samples, request.validate !== false);
-  if (request.channels <= 0 || request.samples.length % request.channels !== 0) {
-    throw new RangeError("waveformPeakPyramid: samples length must be a multiple of channels");
-  }
+  assertInterleavedSamples(
+    "waveformPeakPyramid",
+    request.samples,
+    request.channels,
+    request.validate !== false
+  );
   const levels = request.samplesPerBucketLevels ?? [512, 1024, 2048, 4096];
-  if (levels.length === 0 || levels.some((level) => level <= 0)) {
-    throw new RangeError("waveformPeakPyramid: samplesPerBucketLevels must be non-empty and > 0");
+  if (levels.length === 0) {
+    throw new RangeError("waveformPeakPyramid: samplesPerBucketLevels must not be empty");
   }
-  return requireModule7().waveformPeakPyramid(request.samples, request.channels, levels);
+  levels.forEach((level, index) => {
+    assertPositiveInteger("waveformPeakPyramid", level, `samplesPerBucketLevels[${index}]`);
+  });
+  return requireModule9().waveformPeakPyramid(request.samples, request.channels, levels);
 }
 
+// src/public_types_mastering.ts
+var SOLO_PROCESSORS = [
+  "dynamics.brickwallLimiter",
+  "dynamics.compressor",
+  "dynamics.deesser",
+  "dynamics.duckingProcessor",
+  "dynamics.expander",
+  "dynamics.gate",
+  "dynamics.limiter",
+  "dynamics.parallelComp",
+  "dynamics.sidechainRouter",
+  "dynamics.transientShaper",
+  "dynamics.upwardCompressor",
+  "dynamics.upwardExpander",
+  "dynamics.vocalRider",
+  "effects.acoustic.roomMorph",
+  "effects.delay.stereo",
+  "effects.filter.vowel",
+  "effects.gsEfx",
+  "effects.modulation.autoWah",
+  "effects.modulation.chorus",
+  "effects.modulation.ensemble",
+  "effects.modulation.flanger",
+  "effects.modulation.phaser",
+  "effects.modulation.pitchShifter",
+  "effects.modulation.ringModulator",
+  "effects.modulation.rotary",
+  "effects.modulation.wah",
+  "effects.reverb.convolution",
+  "effects.reverb.dattorro",
+  "effects.reverb.fdn",
+  "effects.reverb.plate",
+  "effects.reverb.room",
+  "effects.reverb.velvet",
+  "eq.apiStyle",
+  "eq.bandPass",
+  "eq.cutFilter",
+  "eq.dynamic",
+  "eq.equalizer",
+  "eq.graphic",
+  "eq.linearPhase",
+  "eq.midSide",
+  "eq.minimumPhase",
+  "eq.parametric",
+  "eq.pultec",
+  "eq.shelving",
+  "eq.tilt",
+  "final.bitDepth",
+  "final.dither",
+  "final.outputChain",
+  "maximizer.adaptiveRelease",
+  "maximizer.loudnessOptimize",
+  "maximizer.maximizer",
+  "maximizer.softKneeMax",
+  "maximizer.truePeakLimiter",
+  "multiband.compressor",
+  "multiband.dynamicEq",
+  "multiband.expander",
+  "multiband.imager",
+  "multiband.limiter",
+  "multiband.saturation",
+  "repair.declick",
+  "repair.declip",
+  "repair.decrackle",
+  "repair.dehum",
+  "repair.denoiseClassical",
+  "repair.dereverbClassical",
+  "repair.trimSilence",
+  "saturation.ampSim",
+  "saturation.bitcrusher",
+  "saturation.exciter",
+  "saturation.hardClipper",
+  "saturation.multibandExciter",
+  "saturation.softClipper",
+  "saturation.tape",
+  "saturation.transformer",
+  "saturation.tube",
+  "saturation.waveshaper",
+  "spectral.airBand",
+  "spectral.lowEndFocus",
+  "spectral.presenceEnhancer",
+  "spectral.spectralShaper",
+  "stereo.autoPan",
+  "stereo.binaural",
+  "stereo.haasEnhancer",
+  "stereo.imager",
+  "stereo.monoMaker",
+  "stereo.phaseAlign",
+  "stereo.stereoBalance",
+  "utility.gain"
+];
+
 // src/public_types_music.ts
 var PitchClass = {
   C: 0,
@@ -1939,7 +2065,15 @@ var ChordQuality = {
   HalfDim7: 13,
   Major9: 14,
   Dominant9: 15,
-  Sus2Add4: 16
+  Sus2Add4: 16,
+  Major6: 17,
+  Minor6: 18,
+  MinorMajor7: 19,
+  Dominant7Sus4: 20,
+  Dominant11: 21,
+  Dominant13: 22,
+  Dominant7Flat9: 23,
+  Dominant7Sharp9: 24
 };
 var SectionType = {
   Intro: 0,
@@ -1981,6 +2115,16 @@ function resolveEnumOrdinal(value, values, enumName) {
   }
   throw new RangeError(`Invalid ${enumName}: ${String(value)}`);
 }
+var AUTOMATION_CURVE_VALUES = {
+  linear: 0,
+  exponential: 1,
+  hold: 2,
+  "s-curve": 3
+};
+var PROJECT_AUTOMATION_CURVE_VALUES = {
+  ...AUTOMATION_CURVE_VALUES,
+  scurve: 3
+};
 
 // src/analysis_helpers.ts
 var PITCH_CLASS_NAMES = [
@@ -2072,6 +2216,7 @@ function convertChordAnalysisResult(wasm) {
       quality: c.quality,
       start: c.start,
       end: c.end,
+      duration: c.end - c.start,
       confidence: c.confidence,
       name: c.name
     }))
@@ -2110,6 +2255,10 @@ function convertAnalysisResult(wasm) {
     timeSignatureCandidates: wasm.timeSignatureCandidates,
     beatTimes,
     beats: wasm.beats,
+    downbeatIndices: wasm.downbeatIndices,
+    downbeatPhase: wasm.downbeatPhase,
+    beatObservations: wasm.beatObservations,
+    beatLocalBpm: wasm.beatLocalBpm,
     chords: wasm.chords.map((c) => ({
       root: c.root,
       bass: c.bass,
@@ -2118,8 +2267,10 @@ function convertAnalysisResult(wasm) {
       quality: c.quality,
       start: c.start,
       end: c.end,
+      duration: c.end - c.start,
       confidence: c.confidence,
-      name: c.name
+      name: c.name,
+      romanNumeral: c.romanNumeral
     })),
     sections: wasm.sections.map((s) => ({
       type: s.type,
@@ -2138,7 +2289,7 @@ function convertAnalysisResult(wasm) {
 }
 
 // src/quick_analysis.ts
-function requireModule8() {
+function requireModule10() {
   return getSonareModule();
 }
 function validateAnalysisInput(fnName, samples, sampleRate, options = {}) {
@@ -2148,12 +2299,12 @@ function validateAnalysisInput(fnName, samples, sampleRate, options = {}) {
 function detectBpm(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectBpm", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().detectBpm(request.samples, request.sampleRate ?? 22050);
+  return requireModule10().detectBpm(request.samples, request.sampleRate ?? 22050);
 }
 function detectKey(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectKey", request.samples, request.sampleRate ?? 22050, request);
-  const result = requireModule8()._detectKeyWithOptions(
+  const result = requireModule10()._detectKeyWithOptions(
     request.samples,
     request.sampleRate ?? 22050,
     request.nFft ?? 4096,
@@ -2181,7 +2332,7 @@ function detectKeyCandidates(samples, sampleRate = 22050, options = {}) {
     request.sampleRate ?? 22050,
     request
   );
-  const candidates = requireModule8()._detectKeyCandidates(
+  const candidates = requireModule10()._detectKeyCandidates(
     request.samples,
     request.sampleRate ?? 22050,
     request.nFft ?? 4096,
@@ -2198,22 +2349,22 @@ 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 requireModule8().detectOnsets(request.samples, request.sampleRate ?? 22050, request);
+  return requireModule10().detectOnsets(request.samples, request.sampleRate ?? 22050, request);
 }
 function detectBeats(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectBeats", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().detectBeats(request.samples, request.sampleRate ?? 22050);
+  return requireModule10().detectBeats(request.samples, request.sampleRate ?? 22050);
 }
 function detectDownbeats(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectDownbeats", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().detectDownbeats(request.samples, request.sampleRate ?? 22050);
+  return requireModule10().detectDownbeats(request.samples, request.sampleRate ?? 22050);
 }
 function detectChords(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectChords", request.samples, request.sampleRate ?? 22050, request);
-  const result = requireModule8().detectChords(
+  const result = requireModule10().detectChords(
     request.samples,
     request.sampleRate ?? 22050,
     request.minDuration ?? 0.3,
@@ -2229,7 +2380,8 @@ function detectChords(samples, sampleRate = 22050, options = {}) {
     request.keyRoot ?? PitchClass.C,
     request.keyMode ?? Mode.Major,
     request.detectInversions ?? false,
-    chordChromaMethodValue(request.chromaMethod ?? "stft")
+    chordChromaMethodValue(request.chromaMethod ?? "stft"),
+    request.tuning ?? 0
   );
   return convertChordAnalysisResult(result);
 }
@@ -2241,7 +2393,7 @@ function chordFunctionalAnalysis(samples, keyRoot, keyMode, sampleRate = 22050,
     request.sampleRate ?? 22050,
     request
   );
-  return requireModule8().chordFunctionalAnalysis(
+  return requireModule10().chordFunctionalAnalysis(
     request.samples,
     request.keyRoot,
     request.keyMode ?? Mode.Major,
@@ -2257,20 +2409,21 @@ function chordFunctionalAnalysis(samples, keyRoot, keyMode, sampleRate = 22050,
     request.hmmBeamWidth ?? 24,
     request.useKeyContext ?? false,
     request.detectInversions ?? false,
-    chordChromaMethodValue(request.chromaMethod ?? "stft")
+    chordChromaMethodValue(request.chromaMethod ?? "stft"),
+    request.tuning ?? 0
   );
 }
 function analyze(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("analyze", request.samples, request.sampleRate ?? 22050, request);
-  const result = requireModule8().analyze(request.samples, request.sampleRate ?? 22050, request);
+  const result = requireModule10().analyze(request.samples, request.sampleRate ?? 22050, request);
   return convertAnalysisResult(result);
 }
+function estimateMeter(request) {
+  return requireModule10().estimateMeter(request.beatTimes, request.beatStrengths, request);
+}
 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) {
@@ -2282,7 +2435,7 @@ function analyzeImpulseResponse(samples, sampleRate = 48e3, nOctaveBands = 6, mi
     request.sampleRate ?? 48e3,
     request
   );
-  const result = requireModule8().analyzeImpulseResponseEx(
+  const result = requireModule10().analyzeImpulseResponseEx(
     request.samples,
     request.sampleRate ?? 48e3,
     request.nOctaveBands ?? 6,
@@ -2293,7 +2446,7 @@ function analyzeImpulseResponse(samples, sampleRate = 48e3, nOctaveBands = 6, mi
 function detectAcoustic(samples, sampleRate = 48e3, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("detectAcoustic", request.samples, request.sampleRate ?? 48e3, request);
-  const result = requireModule8().detectAcoustic(
+  const result = requireModule10().detectAcoustic(
     request.samples,
     request.sampleRate ?? 48e3,
     request.nOctaveBands ?? 6,
@@ -2303,17 +2456,18 @@ function detectAcoustic(samples, sampleRate = 48e3, options = {}) {
   );
   return result;
 }
-function analyzeWithProgress(samples, sampleRate = 22050, onProgress) {
-  const request = samples instanceof Float32Array ? { samples, sampleRate, onProgress } : samples;
+function analyzeWithProgress(samples, sampleRate = 22050, onProgress, options) {
+  const request = samples instanceof Float32Array ? { samples, sampleRate, onProgress, options } : samples;
   validateAnalysisInput(
     "analyzeWithProgress",
     request.samples,
     request.sampleRate ?? 22050,
     request
   );
-  const result = requireModule8().analyzeWithProgress(
+  const result = requireModule10().analyzeWithProgress(
     request.samples,
     request.sampleRate ?? 22050,
+    request.options ?? {},
     request.onProgress ?? (() => {
     }),
     request.cancel ?? (() => false)
@@ -2324,7 +2478,7 @@ function analyzeBpm(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("analyzeBpm", request.samples, request.sampleRate ?? 22050, request);
   assertNonNegativeInteger("analyzeBpm", request.maxCandidates ?? 5, "maxCandidates");
-  return requireModule8().analyzeBpm(
+  return requireModule10().analyzeBpm(
     request.samples,
     request.sampleRate ?? 22050,
     request.bpmMin ?? 30,
@@ -2338,7 +2492,7 @@ function analyzeBpm(samples, sampleRate = 22050, options = {}) {
 function analyzeRhythm(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("analyzeRhythm", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().analyzeRhythm(
+  return requireModule10().analyzeRhythm(
     request.samples,
     request.sampleRate ?? 22050,
     request.bpmMin ?? 60,
@@ -2351,7 +2505,7 @@ function analyzeRhythm(samples, sampleRate = 22050, options = {}) {
 function analyzeDynamics(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("analyzeDynamics", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().analyzeDynamics(
+  return requireModule10().analyzeDynamics(
     request.samples,
     request.sampleRate ?? 22050,
     request.windowSec ?? 0.4,
@@ -2362,7 +2516,7 @@ function analyzeDynamics(samples, sampleRate = 22050, options = {}) {
 function analyzeTimbre(samples, sampleRate = 22050, options = {}) {
   const request = samples instanceof Float32Array ? { samples, sampleRate, ...options } : samples;
   validateAnalysisInput("analyzeTimbre", request.samples, request.sampleRate ?? 22050, request);
-  return requireModule8().analyzeTimbre(
+  return requireModule10().analyzeTimbre(
     request.samples,
     request.sampleRate ?? 22050,
     request.nFft ?? 2048,
@@ -2373,7 +2527,7 @@ function analyzeTimbre(samples, sampleRate = 22050, options = {}) {
   );
 }
 function hasFfmpegSupport() {
-  return requireModule8().hasFfmpegSupport();
+  return requireModule10().hasFfmpegSupport();
 }
 
 // src/analysis.ts
@@ -2437,6 +2591,7 @@ export {
   KeyProfile,
   Mode,
   PitchClass,
+  SOLO_PROCESSORS,
   SectionType,
   SonareError,
   abiVersion,
@@ -2463,11 +2618,10 @@ export {
   cyclicTempogram,
   dbToAmplitude,
   dbToPower,
-  decompose,
-  decomposeWithInit,
   deemphasis,
   detectAcoustic,
   detectBeats,
+  detectBoundaries,
   detectBpm,
   detectChords,
   detectDownbeats,
@@ -2476,6 +2630,7 @@ export {
   detectOnsets,
   ebur128LoudnessRange,
   engineAbiVersion,
+  estimateMeter,
   estimateTuning,
   fixFrames,
   fixLength,
@@ -2485,7 +2640,6 @@ export {
   framesToTime,
   griffinLim,
   hasFfmpegSupport,
-  hpssWithResidual,
   hybridCqt,
   hzToMel,
   hzToMidi,
@@ -2495,6 +2649,7 @@ export {
   isSonareError,
   lufs,
   lufsInterleaved,
+  lufsSeriesInterleaved,
   melDelta,
   melSpectrogram,
   melToAudio,
@@ -2522,7 +2677,6 @@ export {
   mfccToMel,
   midiToHz,
   momentaryLufs,
-  nnFilter,
   nnlsChroma,
   noteSegments,
   noteToHz,
@@ -2532,7 +2686,6 @@ export {
   padCenter,
   pcen,
   peakPick,
-  phaseVocoder,
   piptrack,
   pitchPyin,
   pitchTuning,
@@ -2543,8 +2696,6 @@ export {
   preemphasis,
   pseudoCqt,
   reassignedSpectrogram,
-  remix,
-  resample,
   rmsEnergy,
   samplesToFrames,
   segmentAgglomerative,
@@ -2562,6 +2713,8 @@ export {
   spectralFlux,
   spectralRolloff,
   splitSilence,
+  splitSilenceCommon,
+  splitSilenceCommonWithReport,
   stft,
   stftDb,
   tempogram,
@@ -2569,7 +2722,6 @@ export {
   timeToFrames,
   tone,
   tonnetz,
-  trim,
   trimSilence,
   vectorNormalize,
   version,