@octoseq/mir 0.1.0-main.4baa7cd → 0.1.0-main.4d96254

package/dist/{chunk-KIGWMJLC.js → chunk-5WZ7TTDW.js}

@@ -158,6 +158,212 @@ async function gpuOnsetEnvelopeFromMelFlat(gpu, input) {
   };
 }
 
+// src/dsp/silenceGating.ts
+var DEFAULT_SILENCE_GATE_CONFIG = {
+  enabled: false,
+  // Disabled by default to avoid breaking existing behavior
+  energyPercentile: 10,
+  enterMargin: 6,
+  exitMargin: 3,
+  hangoverMs: 50,
+  minActiveMs: 0,
+  postSilenceSuppressMs: 50
+};
+var DEFAULT_BIN_GATE_CONFIG = {
+  enabled: true,
+  binFloorRel: 0.05
+};
+function withSilenceGateDefaults(config) {
+  return {
+    enabled: config?.enabled ?? DEFAULT_SILENCE_GATE_CONFIG.enabled,
+    energyPercentile: config?.energyPercentile ?? DEFAULT_SILENCE_GATE_CONFIG.energyPercentile,
+    enterMargin: config?.enterMargin ?? DEFAULT_SILENCE_GATE_CONFIG.enterMargin,
+    exitMargin: config?.exitMargin ?? DEFAULT_SILENCE_GATE_CONFIG.exitMargin,
+    hangoverMs: config?.hangoverMs ?? DEFAULT_SILENCE_GATE_CONFIG.hangoverMs,
+    minActiveMs: config?.minActiveMs ?? DEFAULT_SILENCE_GATE_CONFIG.minActiveMs,
+    postSilenceSuppressMs: config?.postSilenceSuppressMs ?? DEFAULT_SILENCE_GATE_CONFIG.postSilenceSuppressMs
+  };
+}
+function withBinGateDefaults(config) {
+  return {
+    enabled: config?.enabled ?? DEFAULT_BIN_GATE_CONFIG.enabled,
+    binFloorRel: config?.binFloorRel ?? DEFAULT_BIN_GATE_CONFIG.binFloorRel
+  };
+}
+function computeFrameEnergyFromMel(melBands) {
+  const nFrames = melBands.length;
+  const energy = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const bands = melBands[t];
+    if (!bands || bands.length === 0) {
+      energy[t] = -100;
+      continue;
+    }
+    let sum = 0;
+    for (let m = 0; m < bands.length; m++) {
+      sum += bands[m] ?? -100;
+    }
+    energy[t] = sum / bands.length;
+  }
+  return energy;
+}
+function computeFrameEnergyFromSpectrogram(magnitudes, usePower = false) {
+  const nFrames = magnitudes.length;
+  const energy = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const mags = magnitudes[t];
+    if (!mags || mags.length === 0) {
+      energy[t] = 0;
+      continue;
+    }
+    let sum = 0;
+    for (let k = 0; k < mags.length; k++) {
+      const m = mags[k] ?? 0;
+      sum += usePower ? m * m : m;
+    }
+    energy[t] = sum / mags.length;
+  }
+  return energy;
+}
+function computePercentile(values, percentile) {
+  if (values.length === 0) return 0;
+  const sorted = Float32Array.from(values).sort((a, b) => a - b);
+  const p = Math.max(0, Math.min(100, percentile));
+  const idx = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) {
+    return sorted[lower] ?? 0;
+  }
+  const frac = idx - lower;
+  const lowVal = sorted[lower] ?? 0;
+  const highVal = sorted[upper] ?? 0;
+  return lowVal + frac * (highVal - lowVal);
+}
+function estimateNoiseFloor(frameEnergy, percentile) {
+  return computePercentile(frameEnergy, percentile);
+}
+function buildActivityMask(frameEnergy, enterThreshold, exitThreshold, hangoverFrames) {
+  const nFrames = frameEnergy.length;
+  const mask = new Uint8Array(nFrames);
+  let isActive = false;
+  let hangoverRemaining = 0;
+  for (let t = 0; t < nFrames; t++) {
+    const e = frameEnergy[t] ?? 0;
+    if (!isActive) {
+      if (e >= enterThreshold) {
+        isActive = true;
+        hangoverRemaining = hangoverFrames;
+        mask[t] = 1;
+      } else {
+        mask[t] = 0;
+      }
+    } else {
+      if (e >= exitThreshold) {
+        hangoverRemaining = hangoverFrames;
+        mask[t] = 1;
+      } else if (hangoverRemaining > 0) {
+        hangoverRemaining--;
+        mask[t] = 1;
+      } else {
+        isActive = false;
+        mask[t] = 0;
+      }
+    }
+  }
+  return mask;
+}
+function buildSuppressionMask(activityMask, suppressFrames) {
+  const nFrames = activityMask.length;
+  const suppress = new Uint8Array(nFrames);
+  let suppressRemaining = 0;
+  let wasActive = false;
+  for (let t = 0; t < nFrames; t++) {
+    const isActive = (activityMask[t] ?? 0) === 1;
+    if (isActive && !wasActive) {
+      suppressRemaining = suppressFrames;
+    }
+    if (isActive && suppressRemaining > 0) {
+      suppress[t] = 1;
+      suppressRemaining--;
+    } else {
+      suppress[t] = 0;
+    }
+    wasActive = isActive;
+  }
+  return suppress;
+}
+function applyMinActiveDuration(activityMask, minActiveFrames) {
+  if (minActiveFrames <= 1) return;
+  const nFrames = activityMask.length;
+  const regions = [];
+  let regionStart = -1;
+  for (let t = 0; t <= nFrames; t++) {
+    const isActive = t < nFrames && (activityMask[t] ?? 0) === 1;
+    if (isActive && regionStart < 0) {
+      regionStart = t;
+    } else if (!isActive && regionStart >= 0) {
+      regions.push({ start: regionStart, end: t });
+      regionStart = -1;
+    }
+  }
+  for (const region of regions) {
+    const length = region.end - region.start;
+    if (length < minActiveFrames) {
+      for (let t = region.start; t < region.end; t++) {
+        activityMask[t] = 0;
+      }
+    }
+  }
+}
+function computeSilenceGating(frameEnergy, frameDurationSec, config) {
+  const cfg = withSilenceGateDefaults(config);
+  const nFrames = frameEnergy.length;
+  if (!cfg.enabled) {
+    return {
+      frameEnergy,
+      noiseFloor: -Infinity,
+      enterThreshold: -Infinity,
+      exitThreshold: -Infinity,
+      activityMask: new Uint8Array(nFrames).fill(1),
+      suppressionMask: new Uint8Array(nFrames)
+      // All zeros = no suppression
+    };
+  }
+  const noiseFloor = estimateNoiseFloor(frameEnergy, cfg.energyPercentile);
+  const enterThreshold = noiseFloor + cfg.enterMargin;
+  const exitThreshold = noiseFloor + cfg.exitMargin;
+  const hangoverFrames = Math.max(0, Math.round(cfg.hangoverMs / 1e3 / frameDurationSec));
+  const suppressFrames = Math.max(0, Math.round(cfg.postSilenceSuppressMs / 1e3 / frameDurationSec));
+  const minActiveFrames = Math.max(0, Math.round(cfg.minActiveMs / 1e3 / frameDurationSec));
+  const activityMask = buildActivityMask(frameEnergy, enterThreshold, exitThreshold, hangoverFrames);
+  if (minActiveFrames > 1) {
+    applyMinActiveDuration(activityMask, minActiveFrames);
+  }
+  const suppressionMask = buildSuppressionMask(activityMask, suppressFrames);
+  return {
+    frameEnergy,
+    noiseFloor,
+    enterThreshold,
+    exitThreshold,
+    activityMask,
+    suppressionMask
+  };
+}
+function applySilenceGating(novelty, activityMask, suppressionMask) {
+  const nFrames = novelty.length;
+  for (let t = 0; t < nFrames; t++) {
+    const isActive = (activityMask[t] ?? 0) === 1;
+    const isSuppressed = (suppressionMask[t] ?? 0) === 1;
+    if (!isActive || isSuppressed) {
+      novelty[t] = 0;
+    }
+  }
+}
+function computeBinFloor(frameEnergy, binFloorRel) {
+  return frameEnergy * binFloorRel;
+}
+
 // src/dsp/onset.ts
 function movingAverage(values, windowFrames) {
   if (windowFrames <= 1) return values;
@@ -178,22 +384,26 @@ function movingAverage(values, windowFrames) {
   }
   return out;
 }
-function defaultOptions(opts) {
+function resolveOptions(opts) {
   return {
     useLog: opts?.useLog ?? false,
     smoothMs: opts?.smoothMs ?? 30,
-    diffMethod: opts?.diffMethod ?? "rectified"
+    diffMethod: opts?.diffMethod ?? "rectified",
+    silenceGate: withSilenceGateDefaults(opts?.silenceGate),
+    binGate: withBinGateDefaults(opts?.binGate),
+    returnDiagnostics: opts?.returnDiagnostics ?? false
   };
 }
 function logCompress(x) {
   return Math.log1p(Math.max(0, x));
 }
 function onsetEnvelopeFromSpectrogram(spec, options) {
-  const opts = defaultOptions(options);
+  const opts = resolveOptions(options);
   const nFrames = spec.times.length;
-  const out = new Float32Array(nFrames);
   const nBins = (spec.fftSize >>> 1) + 1;
+  const out = new Float32Array(nFrames);
   out[0] = 0;
+  const frameEnergies = opts.binGate.enabled ? computeFrameEnergyFromSpectrogram(spec.magnitudes, false) : null;
   for (let t = 1; t < nFrames; t++) {
     const cur = spec.magnitudes[t];
     const prev = spec.magnitudes[t - 1];
@@ -201,35 +411,65 @@ function onsetEnvelopeFromSpectrogram(spec, options) {
       out[t] = 0;
       continue;
     }
+    const binFloor = frameEnergies && opts.binGate.enabled ? computeBinFloor(frameEnergies[t] ?? 0, opts.binGate.binFloorRel) : 0;
     let sum = 0;
+    let validBins = 0;
     for (let k = 0; k < nBins; k++) {
       let a = cur[k] ?? 0;
       let b = prev[k] ?? 0;
+      if (opts.binGate.enabled && a < binFloor && b < binFloor) {
+        continue;
+      }
       if (opts.useLog) {
         a = logCompress(a);
         b = logCompress(b);
       }
       const d = a - b;
       sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+      validBins++;
     }
-    out[t] = nBins > 0 ? sum / nBins : 0;
+    out[t] = validBins > 0 ? sum / validBins : 0;
+  }
+  const linearEnergy = computeFrameEnergyFromSpectrogram(spec.magnitudes, false);
+  const frameEnergy = new Float32Array(nFrames);
+  const eps = 1e-12;
+  for (let t = 0; t < nFrames; t++) {
+    frameEnergy[t] = Math.log10(eps + (linearEnergy[t] ?? 0));
+  }
+  const frameDurationSec = nFrames >= 2 ? (spec.times[1] ?? 0) - (spec.times[0] ?? 0) : 0.01;
+  const gating = computeSilenceGating(frameEnergy, frameDurationSec, opts.silenceGate);
+  const rawNovelty = opts.returnDiagnostics ? Float32Array.from(out) : void 0;
+  if (opts.silenceGate.enabled) {
+    applySilenceGating(out, gating.activityMask, gating.suppressionMask);
   }
+  let values = out;
   const smoothMs = opts.smoothMs;
   if (smoothMs > 0 && nFrames >= 2) {
-    const dt = (spec.times[1] ?? 0) - (spec.times[0] ?? 0);
+    const dt = frameDurationSec;
     const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
-    return {
-      times: spec.times,
-      values: movingAverage(out, windowFrames | 1)
+    const smoothed = movingAverage(out, windowFrames | 1);
+    values = new Float32Array(smoothed);
+  }
+  const result = { times: spec.times, values };
+  if (opts.returnDiagnostics && rawNovelty) {
+    result.diagnostics = {
+      frameEnergy,
+      noiseFloor: gating.noiseFloor,
+      enterThreshold: gating.enterThreshold,
+      exitThreshold: gating.exitThreshold,
+      activityMask: gating.activityMask,
+      suppressionMask: gating.suppressionMask,
+      rawNovelty
     };
   }
-  return { times: spec.times, values: out };
+  return result;
 }
 function onsetEnvelopeFromMel(mel, options) {
-  const opts = defaultOptions(options);
+  const opts = resolveOptions(options);
   const nFrames = mel.times.length;
   const out = new Float32Array(nFrames);
   out[0] = 0;
+  const melFrameEnergies = opts.binGate.enabled ? computeFrameEnergyFromMel(mel.melBands) : null;
   for (let t = 1; t < nFrames; t++) {
     const cur = mel.melBands[t];
     const prev = mel.melBands[t - 1];
@@ -238,29 +478,58 @@ function onsetEnvelopeFromMel(mel, options) {
       continue;
     }
     const nBands = cur.length;
+    const frameEnergyLinear = melFrameEnergies ? Math.pow(10, melFrameEnergies[t] ?? -100) : 0;
+    const binFloorLinear = opts.binGate.enabled ? computeBinFloor(frameEnergyLinear, opts.binGate.binFloorRel) : 0;
     let sum = 0;
+    let validBands = 0;
     for (let m = 0; m < nBands; m++) {
       let a = cur[m] ?? 0;
       let b = prev[m] ?? 0;
+      if (opts.binGate.enabled) {
+        const aLinear = Math.pow(10, a);
+        const bLinear = Math.pow(10, b);
+        if (aLinear < binFloorLinear && bLinear < binFloorLinear) {
+          continue;
+        }
+      }
       if (opts.useLog) {
         a = logCompress(a);
         b = logCompress(b);
       }
       const d = a - b;
       sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+      validBands++;
     }
-    out[t] = nBands > 0 ? sum / nBands : 0;
+    out[t] = validBands > 0 ? sum / validBands : 0;
+  }
+  const frameEnergy = computeFrameEnergyFromMel(mel.melBands);
+  const frameDurationSec = nFrames >= 2 ? (mel.times[1] ?? 0) - (mel.times[0] ?? 0) : 0.01;
+  const gating = computeSilenceGating(frameEnergy, frameDurationSec, opts.silenceGate);
+  const rawNovelty = opts.returnDiagnostics ? Float32Array.from(out) : void 0;
+  if (opts.silenceGate.enabled) {
+    applySilenceGating(out, gating.activityMask, gating.suppressionMask);
   }
+  let values = out;
   const smoothMs = opts.smoothMs;
   if (smoothMs > 0 && nFrames >= 2) {
-    const dt = (mel.times[1] ?? 0) - (mel.times[0] ?? 0);
+    const dt = frameDurationSec;
     const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
-    return {
-      times: mel.times,
-      values: movingAverage(out, windowFrames | 1)
+    const smoothed = movingAverage(out, windowFrames | 1);
+    values = new Float32Array(smoothed);
+  }
+  const result = { times: mel.times, values };
+  if (opts.returnDiagnostics && rawNovelty) {
+    result.diagnostics = {
+      frameEnergy,
+      noiseFloor: gating.noiseFloor,
+      enterThreshold: gating.enterThreshold,
+      exitThreshold: gating.exitThreshold,
+      activityMask: gating.activityMask,
+      suppressionMask: gating.suppressionMask,
+      rawNovelty
     };
   }
-  return { times: mel.times, values: out };
+  return result;
 }
 async function onsetEnvelopeFromMelGpu(mel, gpu, options) {
   const nFrames = mel.times.length;
@@ -272,29 +541,87 @@ async function onsetEnvelopeFromMelGpu(mel, gpu, options) {
     melFlat.set(row, t * nMels);
   }
   const diffMethod = options?.diffMethod ?? "rectified";
+  const silenceGateConfig = withSilenceGateDefaults(options?.silenceGate);
+  const returnDiagnostics = options?.returnDiagnostics ?? false;
+  const smoothMs = options?.smoothMs ?? 30;
   const { value, timing } = await gpuOnsetEnvelopeFromMelFlat(gpu, {
     nFrames,
     nMels,
     melFlat,
     diffMethod
   });
-  return {
+  const out = Float32Array.from(value.out);
+  const rawNovelty = returnDiagnostics ? Float32Array.from(out) : void 0;
+  const frameEnergy = computeFrameEnergyFromMel(mel.melBands);
+  const frameDurationSec = nFrames >= 2 ? (mel.times[1] ?? 0) - (mel.times[0] ?? 0) : 0.01;
+  const gating = computeSilenceGating(frameEnergy, frameDurationSec, silenceGateConfig);
+  if (silenceGateConfig.enabled) {
+    applySilenceGating(out, gating.activityMask, gating.suppressionMask);
+  }
+  let values = out;
+  if (smoothMs > 0 && nFrames >= 2) {
+    const dt = frameDurationSec;
+    const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
+    const smoothed = movingAverage(out, windowFrames | 1);
+    values = new Float32Array(smoothed);
+  }
+  const result = {
     times: mel.times,
-    values: value.out,
+    values,
     gpuTimings: { gpuSubmitToReadbackMs: timing.gpuSubmitToReadbackMs }
   };
+  if (returnDiagnostics && rawNovelty) {
+    result.diagnostics = {
+      frameEnergy,
+      noiseFloor: gating.noiseFloor,
+      enterThreshold: gating.enterThreshold,
+      exitThreshold: gating.exitThreshold,
+      activityMask: gating.activityMask,
+      suppressionMask: gating.suppressionMask,
+      rawNovelty
+    };
+  }
+  return result;
 }
 
 // src/dsp/spectral.ts
-function spectralCentroid(spec) {
+function amplitudeEnvelope(samples, sampleRate, config) {
+  const hopSize = config?.hopSize ?? 512;
+  const windowSize = config?.windowSize ?? hopSize;
+  const nFrames = Math.floor((samples.length - windowSize) / hopSize) + 1;
+  const times = new Float32Array(nFrames);
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const start = t * hopSize;
+    const end = Math.min(start + windowSize, samples.length);
+    let sumSq = 0;
+    for (let i = start; i < end; i++) {
+      const s = samples[i] ?? 0;
+      sumSq += s * s;
+    }
+    const rms = Math.sqrt(sumSq / (end - start));
+    times[t] = (start + windowSize / 2) / sampleRate;
+    values[t] = rms;
+  }
+  return { times, values };
+}
+function spectralCentroid(spec, options) {
   const nFrames = spec.times.length;
   const out = new Float32Array(nFrames);
   const nBins = (spec.fftSize >>> 1) + 1;
   const binHz = spec.sampleRate / spec.fftSize;
+  const activity = options?.activity;
+  const holdBehavior = options?.inactiveBehavior === "hold";
+  let lastActiveValue = 0;
   for (let t = 0; t < nFrames; t++) {
+    const isActive = activity ? (activity.isActive[t] ?? 0) === 1 : true;
+    if (!isActive) {
+      out[t] = holdBehavior ? lastActiveValue : 0;
+      continue;
+    }
     const mags = spec.magnitudes[t];
     if (!mags) {
-      out[t] = 0;
+      out[t] = holdBehavior ? lastActiveValue : 0;
       continue;
     }
     let num = 0;
@@ -305,16 +632,26 @@ function spectralCentroid(spec) {
       num += f * m;
       den += m;
     }
-    out[t] = den > 0 ? num / den : 0;
+    const centroid = den > 0 ? num / den : 0;
+    out[t] = centroid;
+    lastActiveValue = centroid;
   }
   return out;
 }
-function spectralFlux(spec) {
+function spectralFlux(spec, options) {
   const nFrames = spec.times.length;
   const out = new Float32Array(nFrames);
   const nBins = (spec.fftSize >>> 1) + 1;
+  const activity = options?.activity;
   let prev = null;
   for (let t = 0; t < nFrames; t++) {
+    const isActive = activity ? (activity.isActive[t] ?? 0) === 1 : true;
+    const isSuppressed = activity ? (activity.suppressMask[t] ?? 0) === 1 : false;
+    if (!isActive || isSuppressed) {
+      out[t] = 0;
+      prev = null;
+      continue;
+    }
     const mags = spec.magnitudes[t];
     if (!mags) {
       out[t] = 0;
@@ -802,6 +1139,20 @@ function hzToMel(hz) {
 function melToHz(mel) {
   return 700 * (Math.pow(10, mel / 2595) - 1);
 }
+function hzToFeatureIndex(hz, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const melHz = hzToMel(hz);
+  const normalized = (melHz - melMin) / (melMax - melMin);
+  return normalized * (config.nMels - 1);
+}
+function featureIndexToHz(index, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const normalized = index / (config.nMels - 1);
+  const mel = melMin + normalized * (melMax - melMin);
+  return melToHz(mel);
+}
 function buildMelFilterBank(sampleRate, fftSize, nMels, fMin, fMax) {
   const nBins = (fftSize >>> 1) + 1;
   const nyquist = sampleRate / 2;
@@ -1553,6 +1904,841 @@ async function spectrogram(audio, config, gpu, options = {}) {
   };
 }
 
+// src/dsp/cqt.ts
+var CQT_DEFAULTS = {
+  /** Quarter-tone resolution (24 bins per octave) */
+  binsPerOctave: 24,
+  /** C1 (lowest note on a standard piano) */
+  fMin: 32.7,
+  /** C9 (well above audible range for most content) */
+  fMax: 8372
+};
+function cqtBinToHz(bin, config) {
+  return config.fMin * Math.pow(2, bin / config.binsPerOctave);
+}
+function hzToCqtBin(hz, config) {
+  if (hz <= 0) return -Infinity;
+  return config.binsPerOctave * Math.log2(hz / config.fMin);
+}
+function getNumOctaves(config) {
+  return Math.log2(config.fMax / config.fMin);
+}
+function getNumBins(config) {
+  const nOctaves = getNumOctaves(config);
+  return Math.ceil(nOctaves * config.binsPerOctave);
+}
+function getCqtBinFrequencies(config) {
+  const nBins = getNumBins(config);
+  const freqs = new Float32Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    freqs[k] = cqtBinToHz(k, config);
+  }
+  return freqs;
+}
+var kernelBankCache = /* @__PURE__ */ new Map();
+function kernelCacheKey(config, fftSize, sampleRate) {
+  return `${config.binsPerOctave}:${config.fMin}:${config.fMax}:${fftSize}:${sampleRate}`;
+}
+function createCqtKernel(binIndex, config, fftSize, sampleRate) {
+  const centerFreq = cqtBinToHz(binIndex, config);
+  const freqResolution = sampleRate / fftSize;
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const bandwidth = centerFreq / Q;
+  const fLow = centerFreq - bandwidth / 2;
+  const fHigh = centerFreq + bandwidth / 2;
+  const startBin = Math.max(0, Math.floor(fLow / freqResolution));
+  const endBin = Math.min(
+    Math.floor(fftSize / 2) + 1,
+    Math.ceil(fHigh / freqResolution) + 1
+  );
+  const numBins = Math.max(1, endBin - startBin);
+  const weights = new Float32Array(numBins);
+  for (let i = 0; i < numBins; i++) {
+    const binFreq = (startBin + i) * freqResolution;
+    if (binFreq <= centerFreq) {
+      if (centerFreq > fLow) {
+        weights[i] = (binFreq - fLow) / (centerFreq - fLow);
+      } else {
+        weights[i] = 1;
+      }
+    } else {
+      if (fHigh > centerFreq) {
+        weights[i] = (fHigh - binFreq) / (fHigh - centerFreq);
+      } else {
+        weights[i] = 1;
+      }
+    }
+    weights[i] = Math.max(0, Math.min(1, weights[i] ?? 0));
+  }
+  let sum = 0;
+  for (let i = 0; i < numBins; i++) {
+    sum += weights[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < numBins; i++) {
+      weights[i] = (weights[i] ?? 0) / sum;
+    }
+  }
+  return {
+    centerFreq,
+    startBin,
+    endBin,
+    weights
+  };
+}
+function getCqtKernelBank(config, fftSize, sampleRate) {
+  const key = kernelCacheKey(config, fftSize, sampleRate);
+  const cached = kernelBankCache.get(key);
+  if (cached) return cached;
+  const nBins = getNumBins(config);
+  const kernels = new Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    kernels[k] = createCqtKernel(k, config, fftSize, sampleRate);
+  }
+  const bank = {
+    config,
+    fftSize,
+    sampleRate,
+    kernels
+  };
+  kernelBankCache.set(key, bank);
+  return bank;
+}
+function applyCqtKernels(stftMagnitudes, kernelBank) {
+  const nCqtBins = kernelBank.kernels.length;
+  const cqtMagnitudes = new Float32Array(nCqtBins);
+  for (let k = 0; k < nCqtBins; k++) {
+    const kernel = kernelBank.kernels[k];
+    if (!kernel) continue;
+    let sum = 0;
+    for (let i = 0; i < kernel.weights.length; i++) {
+      const stftBin = kernel.startBin + i;
+      const stftMag = stftMagnitudes[stftBin] ?? 0;
+      const weight = kernel.weights[i] ?? 0;
+      sum += stftMag * weight;
+    }
+    cqtMagnitudes[k] = sum;
+  }
+  return cqtMagnitudes;
+}
+function withCqtDefaults(partial) {
+  return {
+    binsPerOctave: partial?.binsPerOctave ?? CQT_DEFAULTS.binsPerOctave,
+    fMin: partial?.fMin ?? CQT_DEFAULTS.fMin,
+    fMax: partial?.fMax ?? CQT_DEFAULTS.fMax,
+    hopSize: partial?.hopSize
+  };
+}
+async function cqtSpectrogram(audio, config, options = {}) {
+  const sampleRate = audio.sampleRate;
+  if (config.fMin <= 0) {
+    throw new Error("@octoseq/mir: CQT fMin must be positive");
+  }
+  if (config.fMax <= config.fMin) {
+    throw new Error("@octoseq/mir: CQT fMax must be greater than fMin");
+  }
+  if (config.binsPerOctave <= 0) {
+    throw new Error("@octoseq/mir: CQT binsPerOctave must be positive");
+  }
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const minFreqResolution = config.fMin / Q / 2;
+  const minFftSize = Math.ceil(sampleRate / minFreqResolution);
+  let fftSize = 1;
+  while (fftSize < minFftSize) {
+    fftSize *= 2;
+  }
+  fftSize = Math.min(fftSize, 16384);
+  const hopSize = config.hopSize ?? Math.floor(fftSize / 4);
+  const stft = await spectrogram(
+    audio,
+    { fftSize, hopSize, window: "hann" },
+    void 0,
+    { isCancelled: options.isCancelled }
+  );
+  const kernelBank = getCqtKernelBank(config, fftSize, sampleRate);
+  const nFrames = stft.magnitudes.length;
+  const cqtMagnitudes = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const stftFrame = stft.magnitudes[frame];
+    if (!stftFrame) continue;
+    cqtMagnitudes[frame] = applyCqtKernels(stftFrame, kernelBank);
+  }
+  const nOctaves = getNumOctaves(config);
+  getNumBins(config);
+  return {
+    sampleRate,
+    config,
+    times: stft.times,
+    magnitudes: cqtMagnitudes,
+    nOctaves,
+    binsPerOctave: config.binsPerOctave,
+    binFrequencies: getCqtBinFrequencies(config)
+  };
+}
+async function computeCqt(audio, config, options = {}) {
+  const startTime = performance.now();
+  const fullConfig = withCqtDefaults(config);
+  const cqt = await cqtSpectrogram(audio, fullConfig, options);
+  const endTime = performance.now();
+  return {
+    cqt,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+
+// src/dsp/cqtSignals.ts
+var BASS_MIN_HZ = 20;
+var BASS_MAX_HZ = 300;
+var TONAL_STABILITY_WINDOW_FRAMES = 20;
+var CHROMA_BINS = 12;
+function normalizeMinMax(values) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min;
+  const result = new Float32Array(values.length);
+  if (range > 0) {
+    for (let i = 0; i < values.length; i++) {
+      result[i] = ((values[i] ?? 0) - min) / range;
+    }
+  } else {
+    result.fill(0.5);
+  }
+  return result;
+}
+function weightedCentroid(values, startIndex = 0) {
+  let sumWeighted = 0;
+  let sumWeights = 0;
+  for (let i = 0; i < values.length; i++) {
+    const weight = values[i] ?? 0;
+    sumWeighted += (startIndex + i) * weight;
+    sumWeights += weight;
+  }
+  return sumWeights > 0 ? sumWeighted / sumWeights : startIndex + values.length / 2;
+}
+function computeHarmonicEnergyFrame(frame, cqt) {
+  if (frame.length === 0) return 0;
+  let totalEnergy = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    totalEnergy += mag * mag;
+  }
+  if (totalEnergy === 0) return 0;
+  let maxMag = 0;
+  let fundamentalBin = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    if (mag > maxMag) {
+      maxMag = mag;
+      fundamentalBin = i;
+    }
+  }
+  const fundamentalFreq = cqtBinToHz(fundamentalBin, cqt.config);
+  let harmonicEnergy2 = 0;
+  const numHarmonics = 6;
+  for (let h = 1; h <= numHarmonics; h++) {
+    const harmonicFreq = fundamentalFreq * h;
+    const harmonicBin = Math.round(hzToCqtBin(harmonicFreq, cqt.config));
+    if (harmonicBin >= 0 && harmonicBin < frame.length) {
+      const mag = frame[harmonicBin] ?? 0;
+      const weight = 1 / h;
+      harmonicEnergy2 += mag * mag * weight;
+    }
+  }
+  let weightSum = 0;
+  for (let h = 1; h <= numHarmonics; h++) {
+    weightSum += 1 / h;
+  }
+  harmonicEnergy2 /= weightSum;
+  return Math.min(1, harmonicEnergy2 / totalEnergy);
+}
+function harmonicEnergy(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const values = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      values[frame] = computeHarmonicEnergyFrame(cqtFrame, cqt);
+    }
+  }
+  const normalized = normalizeMinMax(values);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "harmonicEnergy",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function bassPitchMotion(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const bassStartBin = Math.max(0, Math.floor(hzToCqtBin(BASS_MIN_HZ, cqt.config)));
+  const bassEndBin = Math.min(
+    cqt.magnitudes[0]?.length ?? 0,
+    Math.ceil(hzToCqtBin(BASS_MAX_HZ, cqt.config))
+  );
+  const bassNumBins = bassEndBin - bassStartBin;
+  if (bassNumBins <= 0) {
+    return {
+      kind: "cqt1d",
+      signalId: "bassPitchMotion",
+      times: cqt.times,
+      values: new Float32Array(nFrames),
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: { totalMs: 0, cpuMs: 0 }
+      }
+    };
+  }
+  const centroids = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (!cqtFrame) continue;
+    const bassBins = new Float32Array(bassNumBins);
+    for (let i = 0; i < bassNumBins; i++) {
+      bassBins[i] = cqtFrame[bassStartBin + i] ?? 0;
+    }
+    centroids[frame] = weightedCentroid(bassBins, bassStartBin);
+  }
+  const motion = new Float32Array(nFrames);
+  for (let frame = 1; frame < nFrames; frame++) {
+    motion[frame] = Math.abs((centroids[frame] ?? 0) - (centroids[frame - 1] ?? 0));
+  }
+  motion[0] = motion[1] ?? 0;
+  const normalized = normalizeMinMax(motion);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "bassPitchMotion",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeChroma(frame, binsPerOctave) {
+  const chroma = new Float32Array(CHROMA_BINS);
+  const binsPerSemitone = binsPerOctave / CHROMA_BINS;
+  for (let i = 0; i < frame.length; i++) {
+    const chromaBin = Math.floor(i % binsPerOctave / binsPerSemitone) % CHROMA_BINS;
+    const mag = frame[i] ?? 0;
+    chroma[chromaBin] = (chroma[chromaBin] ?? 0) + mag * mag;
+  }
+  let sum = 0;
+  for (let i = 0; i < CHROMA_BINS; i++) {
+    sum += chroma[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < CHROMA_BINS; i++) {
+      chroma[i] = (chroma[i] ?? 0) / sum;
+    }
+  }
+  return chroma;
+}
+function tonalStability(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const chromas = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      chromas[frame] = computeChroma(cqtFrame, cqt.binsPerOctave);
+    } else {
+      chromas[frame] = new Float32Array(CHROMA_BINS);
+    }
+  }
+  const halfWindow = Math.floor(TONAL_STABILITY_WINDOW_FRAMES / 2);
+  const instability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const windowStart = Math.max(0, frame - halfWindow);
+    const windowEnd = Math.min(nFrames, frame + halfWindow + 1);
+    const windowSize = windowEnd - windowStart;
+    const avgChroma = new Float32Array(CHROMA_BINS);
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          avgChroma[c] = (avgChroma[c] ?? 0) + (chroma[c] ?? 0);
+        }
+      }
+    }
+    for (let c = 0; c < CHROMA_BINS; c++) {
+      avgChroma[c] = (avgChroma[c] ?? 0) / windowSize;
+    }
+    let totalVariance = 0;
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          const diff = (chroma[c] ?? 0) - (avgChroma[c] ?? 0);
+          totalVariance += diff * diff;
+        }
+      }
+    }
+    totalVariance /= windowSize * CHROMA_BINS;
+    instability[frame] = totalVariance;
+  }
+  const normalizedInstability = normalizeMinMax(instability);
+  const stability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    stability[frame] = 1 - (normalizedInstability[frame] ?? 0);
+  }
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "tonalStability",
+    times: cqt.times,
+    values: stability,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeCqtSignal(cqt, signalId) {
+  switch (signalId) {
+    case "harmonicEnergy":
+      return harmonicEnergy(cqt);
+    case "bassPitchMotion":
+      return bassPitchMotion(cqt);
+    case "tonalStability":
+      return tonalStability(cqt);
+    default:
+      throw new Error(`@octoseq/mir: unknown CQT signal ID: ${signalId}`);
+  }
+}
+function computeAllCqtSignals(cqt) {
+  const results = /* @__PURE__ */ new Map();
+  results.set("harmonicEnergy", harmonicEnergy(cqt));
+  results.set("bassPitchMotion", bassPitchMotion(cqt));
+  results.set("tonalStability", tonalStability(cqt));
+  return results;
+}
+
+// src/dsp/activity.ts
+var DEFAULT_ACTIVITY_CONFIG = {
+  energyPercentile: 10,
+  enterMargin: 6,
+  exitMargin: 3,
+  hangoverMs: 50,
+  minActiveMs: 30,
+  smoothMs: 20
+};
+function withActivityDefaults(config) {
+  return {
+    energyPercentile: config?.energyPercentile ?? DEFAULT_ACTIVITY_CONFIG.energyPercentile,
+    enterMargin: config?.enterMargin ?? DEFAULT_ACTIVITY_CONFIG.enterMargin,
+    exitMargin: config?.exitMargin ?? DEFAULT_ACTIVITY_CONFIG.exitMargin,
+    hangoverMs: config?.hangoverMs ?? DEFAULT_ACTIVITY_CONFIG.hangoverMs,
+    minActiveMs: config?.minActiveMs ?? DEFAULT_ACTIVITY_CONFIG.minActiveMs,
+    smoothMs: config?.smoothMs ?? DEFAULT_ACTIVITY_CONFIG.smoothMs
+  };
+}
+function smoothSignal(values, windowFrames) {
+  if (windowFrames <= 1) return values;
+  const n = values.length;
+  const out = new Float32Array(n);
+  const half = Math.floor(windowFrames / 2);
+  const prefix = new Float64Array(n + 1);
+  prefix[0] = 0;
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = (prefix[i] ?? 0) + (values[i] ?? 0);
+  }
+  for (let i = 0; i < n; i++) {
+    const start = Math.max(0, i - half);
+    const end = Math.min(n, i + half + 1);
+    const sum = (prefix[end] ?? 0) - (prefix[start] ?? 0);
+    const count = Math.max(1, end - start);
+    out[i] = sum / count;
+  }
+  return out;
+}
+function maskToActivityLevel(mask, smoothFrames) {
+  const n = mask.length;
+  const level = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    level[i] = mask[i] ?? 0;
+  }
+  if (smoothFrames > 1) {
+    return smoothSignal(level, smoothFrames);
+  }
+  return level;
+}
+function computeActivityFromMel(mel, config) {
+  const cfg = withActivityDefaults(config);
+  const nFrames = mel.times.length;
+  const frameEnergy = computeFrameEnergyFromMel(mel.melBands);
+  const noiseFloor = estimateNoiseFloor(frameEnergy, cfg.energyPercentile);
+  const enterThreshold = noiseFloor + cfg.enterMargin;
+  const exitThreshold = noiseFloor + cfg.exitMargin;
+  const frameDurationSec = nFrames >= 2 ? (mel.times[1] ?? 0) - (mel.times[0] ?? 0) : 0.01;
+  const hangoverFrames = Math.max(0, Math.round(cfg.hangoverMs / 1e3 / frameDurationSec));
+  const minActiveFrames = Math.max(0, Math.round(cfg.minActiveMs / 1e3 / frameDurationSec));
+  const smoothFrames = Math.max(1, Math.round(cfg.smoothMs / 1e3 / frameDurationSec)) | 1;
+  const isActive = buildActivityMask(frameEnergy, enterThreshold, exitThreshold, hangoverFrames);
+  if (minActiveFrames > 1) {
+    applyMinActiveDuration(isActive, minActiveFrames);
+  }
+  const suppressFrames = Math.max(0, Math.round(50 / 1e3 / frameDurationSec));
+  const suppressMask = buildSuppressionMask(isActive, suppressFrames);
+  const activityLevel = maskToActivityLevel(isActive, smoothFrames);
+  return {
+    times: mel.times,
+    activityLevel,
+    isActive,
+    suppressMask,
+    diagnostics: {
+      frameEnergy,
+      noiseFloor,
+      enterThreshold,
+      exitThreshold
+    }
+  };
+}
+function computeActivityFromSpectrogram(spec, config) {
+  const cfg = withActivityDefaults(config);
+  const nFrames = spec.times.length;
+  const linearEnergy = computeFrameEnergyFromSpectrogram(spec.magnitudes, false);
+  const frameEnergy = new Float32Array(nFrames);
+  const eps = 1e-12;
+  for (let t = 0; t < nFrames; t++) {
+    frameEnergy[t] = Math.log10(eps + (linearEnergy[t] ?? 0));
+  }
+  const noiseFloor = estimateNoiseFloor(frameEnergy, cfg.energyPercentile);
+  const enterThreshold = noiseFloor + cfg.enterMargin;
+  const exitThreshold = noiseFloor + cfg.exitMargin;
+  const frameDurationSec = nFrames >= 2 ? (spec.times[1] ?? 0) - (spec.times[0] ?? 0) : 0.01;
+  const hangoverFrames = Math.max(0, Math.round(cfg.hangoverMs / 1e3 / frameDurationSec));
+  const minActiveFrames = Math.max(0, Math.round(cfg.minActiveMs / 1e3 / frameDurationSec));
+  const smoothFrames = Math.max(1, Math.round(cfg.smoothMs / 1e3 / frameDurationSec)) | 1;
+  const isActive = buildActivityMask(frameEnergy, enterThreshold, exitThreshold, hangoverFrames);
+  if (minActiveFrames > 1) {
+    applyMinActiveDuration(isActive, minActiveFrames);
+  }
+  const suppressFrames = Math.max(0, Math.round(50 / 1e3 / frameDurationSec));
+  const suppressMask = buildSuppressionMask(isActive, suppressFrames);
+  const activityLevel = maskToActivityLevel(isActive, smoothFrames);
+  return {
+    times: spec.times,
+    activityLevel,
+    isActive,
+    suppressMask,
+    diagnostics: {
+      frameEnergy,
+      noiseFloor,
+      enterThreshold,
+      exitThreshold
+    }
+  };
+}
+function computeActivityFromAudio(samples, sampleRate, hopSize, windowSize, config) {
+  const cfg = withActivityDefaults(config);
+  const nFrames = Math.max(0, Math.floor((samples.length - windowSize) / hopSize) + 1);
+  const times = new Float32Array(nFrames);
+  const frameEnergy = new Float32Array(nFrames);
+  const eps = 1e-12;
+  for (let frame = 0; frame < nFrames; frame++) {
+    const start = frame * hopSize;
+    const end = Math.min(start + windowSize, samples.length);
+    let sumSq = 0;
+    for (let i = start; i < end; i++) {
+      const s = samples[i] ?? 0;
+      sumSq += s * s;
+    }
+    const rms = Math.sqrt(sumSq / (end - start));
+    times[frame] = (start + windowSize / 2) / sampleRate;
+    frameEnergy[frame] = Math.log10(eps + rms);
+  }
+  const noiseFloor = estimateNoiseFloor(frameEnergy, cfg.energyPercentile);
+  const enterThreshold = noiseFloor + cfg.enterMargin;
+  const exitThreshold = noiseFloor + cfg.exitMargin;
+  const frameDurationSec = hopSize / sampleRate;
+  const hangoverFrames = Math.max(0, Math.round(cfg.hangoverMs / 1e3 / frameDurationSec));
+  const minActiveFrames = Math.max(0, Math.round(cfg.minActiveMs / 1e3 / frameDurationSec));
+  const smoothFrames = Math.max(1, Math.round(cfg.smoothMs / 1e3 / frameDurationSec)) | 1;
+  const isActive = buildActivityMask(frameEnergy, enterThreshold, exitThreshold, hangoverFrames);
+  if (minActiveFrames > 1) {
+    applyMinActiveDuration(isActive, minActiveFrames);
+  }
+  const suppressFrames = Math.max(0, Math.round(50 / 1e3 / frameDurationSec));
+  const suppressMask = buildSuppressionMask(isActive, suppressFrames);
+  const activityLevel = maskToActivityLevel(isActive, smoothFrames);
+  return {
+    times,
+    activityLevel,
+    isActive,
+    suppressMask,
+    diagnostics: {
+      frameEnergy,
+      noiseFloor,
+      enterThreshold,
+      exitThreshold
+    }
+  };
+}
+function applyActivityGating(values, activity, options) {
+  const useBinary = options?.useBinaryMask ?? true;
+  const suppressPostSilence = options?.suppressPostSilence ?? true;
+  const levelThreshold = options?.levelThreshold ?? 0.5;
+  const n = Math.min(values.length, activity.activityLevel.length);
+  for (let i = 0; i < n; i++) {
+    let shouldGate = false;
+    if (useBinary) {
+      shouldGate = (activity.isActive[i] ?? 0) === 0;
+    } else {
+      shouldGate = (activity.activityLevel[i] ?? 0) < levelThreshold;
+    }
+    if (suppressPostSilence && (activity.suppressMask[i] ?? 0) === 1) {
+      shouldGate = true;
+    }
+    if (shouldGate) {
+      values[i] = 0;
+    }
+  }
+}
+function interpolateActivity(activity, targetTimes) {
+  const n = targetTimes.length;
+  const activityLevel = new Float32Array(n);
+  const isActive = new Uint8Array(n);
+  const suppressMask = new Uint8Array(n);
+  const frameEnergy = new Float32Array(n);
+  const srcTimes = activity.times;
+  const srcN = srcTimes.length;
+  if (srcN === 0) {
+    return {
+      times: targetTimes,
+      activityLevel,
+      isActive,
+      suppressMask,
+      diagnostics: {
+        frameEnergy,
+        noiseFloor: activity.diagnostics.noiseFloor,
+        enterThreshold: activity.diagnostics.enterThreshold,
+        exitThreshold: activity.diagnostics.exitThreshold
+      }
+    };
+  }
+  for (let i = 0; i < n; i++) {
+    const t = targetTimes[i] ?? 0;
+    let lo = 0;
+    let hi = srcN - 1;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if ((srcTimes[mid] ?? 0) < t) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    let nearest = lo;
+    if (lo > 0 && Math.abs((srcTimes[lo - 1] ?? 0) - t) < Math.abs((srcTimes[lo] ?? 0) - t)) {
+      nearest = lo - 1;
+    }
+    activityLevel[i] = activity.activityLevel[nearest] ?? 0;
+    isActive[i] = activity.isActive[nearest] ?? 0;
+    suppressMask[i] = activity.suppressMask[nearest] ?? 0;
+    frameEnergy[i] = activity.diagnostics.frameEnergy[nearest] ?? 0;
+  }
+  return {
+    times: targetTimes,
+    activityLevel,
+    isActive,
+    suppressMask,
+    diagnostics: {
+      frameEnergy,
+      noiseFloor: activity.diagnostics.noiseFloor,
+      enterThreshold: activity.diagnostics.enterThreshold,
+      exitThreshold: activity.diagnostics.exitThreshold
+    }
+  };
+}
+
+// src/dsp/pitch.ts
+function pitchF0(samples, sampleRate, config) {
+  const result = yinPitchDetection(samples, sampleRate, config);
+  const f0 = result.f0;
+  const activityOpts = config?.activityOptions;
+  if (activityOpts?.activity) {
+    const activity = interpolateActivity(activityOpts.activity, result.times);
+    const behavior = activityOpts.inactiveBehavior ?? "zero";
+    let lastActiveValue = 0;
+    for (let i = 0; i < f0.length; i++) {
+      if (!activity.isActive[i]) {
+        if (behavior === "zero") {
+          f0[i] = 0;
+        } else {
+          f0[i] = lastActiveValue;
+        }
+      } else {
+        lastActiveValue = f0[i] ?? 0;
+      }
+    }
+  }
+  return {
+    times: result.times,
+    values: f0
+  };
+}
+function pitchConfidence(samples, sampleRate, config) {
+  const result = yinPitchDetection(samples, sampleRate, config);
+  const confidence = result.confidence;
+  const activityOpts = config?.activityOptions;
+  if (activityOpts?.activity) {
+    const activity = interpolateActivity(activityOpts.activity, result.times);
+    const behavior = activityOpts.inactiveBehavior ?? "zero";
+    let lastActiveValue = 0;
+    for (let i = 0; i < confidence.length; i++) {
+      if (!activity.isActive[i]) {
+        if (behavior === "zero") {
+          confidence[i] = 0;
+        } else {
+          confidence[i] = lastActiveValue;
+        }
+      } else {
+        lastActiveValue = confidence[i] ?? 0;
+      }
+    }
+  }
+  return {
+    times: result.times,
+    values: confidence
+  };
+}
+function yinPitchDetection(samples, sampleRate, config) {
+  const fMinHz = config?.fMinHz ?? 50;
+  const fMaxHz = config?.fMaxHz ?? 1e3;
+  const hopSize = config?.hopSize ?? 512;
+  const windowSize = config?.windowSize ?? 2048;
+  const threshold = config?.threshold ?? 0.15;
+  const tauMin = Math.max(2, Math.floor(sampleRate / fMaxHz));
+  const tauMax = Math.min(windowSize / 2, Math.ceil(sampleRate / fMinHz));
+  const nFrames = Math.max(0, Math.floor((samples.length - windowSize) / hopSize) + 1);
+  const times = new Float32Array(nFrames);
+  const f0 = new Float32Array(nFrames);
+  const confidence = new Float32Array(nFrames);
+  const d = new Float32Array(tauMax + 1);
+  const dPrime = new Float32Array(tauMax + 1);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const start = frame * hopSize;
+    const frameCenter = start + windowSize / 2;
+    times[frame] = frameCenter / sampleRate;
+    const frameEnd = Math.min(start + windowSize, samples.length);
+    const frameLen = frameEnd - start;
+    let energy = 0;
+    for (let i = 0; i < frameLen; i++) {
+      const s = samples[start + i] ?? 0;
+      energy += s * s;
+    }
+    const rms = Math.sqrt(energy / frameLen);
+    if (rms < 1e-6) {
+      f0[frame] = 0;
+      confidence[frame] = 0;
+      continue;
+    }
+    d[0] = 0;
+    for (let tau = 1; tau <= tauMax && tau < frameLen; tau++) {
+      let sum = 0;
+      const limit = Math.min(frameLen - tau, windowSize - tau);
+      for (let j = 0; j < limit; j++) {
+        const diff = (samples[start + j] ?? 0) - (samples[start + j + tau] ?? 0);
+        sum += diff * diff;
+      }
+      d[tau] = sum;
+    }
+    dPrime[0] = 1;
+    let runningSum = 0;
+    for (let tau = 1; tau <= tauMax && tau < frameLen; tau++) {
+      const dVal = d[tau] ?? 0;
+      runningSum += dVal;
+      if (runningSum > 0) {
+        dPrime[tau] = dVal * tau / runningSum;
+      } else {
+        dPrime[tau] = 1;
+      }
+    }
+    let bestTau = -1;
+    let bestDPrime = 1;
+    for (let tau = tauMin; tau <= tauMax && tau < frameLen - 1; tau++) {
+      const dPrimeVal = dPrime[tau] ?? 1;
+      if (dPrimeVal < threshold) {
+        while (tau + 1 <= tauMax && tau + 1 < frameLen - 1 && (dPrime[tau + 1] ?? 1) < (dPrime[tau] ?? 1)) {
+          tau++;
+        }
+        bestTau = tau;
+        bestDPrime = dPrime[tau] ?? 1;
+        break;
+      }
+    }
+    if (bestTau < 0) {
+      for (let tau = tauMin; tau <= tauMax && tau < frameLen; tau++) {
+        const dPrimeVal = dPrime[tau] ?? 1;
+        if (dPrimeVal < bestDPrime) {
+          bestDPrime = dPrimeVal;
+          bestTau = tau;
+        }
+      }
+    }
+    if (bestTau > tauMin && bestTau < tauMax - 1 && bestTau < frameLen - 1) {
+      const y0 = dPrime[bestTau - 1] ?? 1;
+      const y1 = dPrime[bestTau] ?? 1;
+      const y2 = dPrime[bestTau + 1] ?? 1;
+      const denom = 2 * (2 * y1 - y0 - y2);
+      if (Math.abs(denom) > 1e-10) {
+        const delta2 = (y0 - y2) / denom;
+        const interpolatedTau = bestTau + delta2;
+        if (interpolatedTau >= tauMin && interpolatedTau <= tauMax) {
+          f0[frame] = sampleRate / interpolatedTau;
+          confidence[frame] = Math.max(0, Math.min(1, 1 - bestDPrime));
+          continue;
+        }
+      }
+    }
+    if (bestTau >= tauMin && bestTau <= tauMax) {
+      f0[frame] = sampleRate / bestTau;
+      confidence[frame] = Math.max(0, Math.min(1, 1 - bestDPrime));
+    } else {
+      f0[frame] = 0;
+      confidence[frame] = 0;
+    }
+  }
+  return { times, f0, confidence };
+}
+
 // src/runner/runMir.ts
 function nowMs2() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
@@ -1579,6 +2765,27 @@ async function runMir(audio, request, options = {}) {
     hopSize: 512,
     window: "hann"
   };
+  if (request.fn === "amplitudeEnvelope") {
+    const cpuStart2 = nowMs2();
+    const result = amplitudeEnvelope(audio.mono, audio.sampleRate, {
+      hopSize: specConfig.hopSize,
+      windowSize: specConfig.fftSize
+    });
+    const cpuEnd = nowMs2();
+    return {
+      kind: "1d",
+      times: result.times,
+      values: result.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: cpuEnd - t0,
+          cpuMs: cpuEnd - cpuStart2
+        }
+      }
+    };
+  }
   const cpuStart = nowMs2();
   const spec = await spectrogram(asAudioBufferLike(audio), specConfig, void 0, {
     isCancelled: options.isCancelled
@@ -1908,6 +3115,102 @@ async function runMir(audio, request, options = {}) {
       }
     };
   }
+  if (request.fn === "cqtHarmonicEnergy" || request.fn === "cqtBassPitchMotion" || request.fn === "cqtTonalStability") {
+    const cqtStart = nowMs2();
+    const cqtConfig = withCqtDefaults(request.cqt);
+    const cqt = await cqtSpectrogram(asAudioBufferLike(audio), cqtConfig, {
+      isCancelled: options.isCancelled
+    });
+    const cqtEnd = nowMs2();
+    let signal;
+    if (request.fn === "cqtHarmonicEnergy") {
+      signal = harmonicEnergy(cqt);
+    } else if (request.fn === "cqtBassPitchMotion") {
+      signal = bassPitchMotion(cqt);
+    } else {
+      signal = tonalStability(cqt);
+    }
+    const end2 = nowMs2();
+    return {
+      kind: "1d",
+      times: signal.times,
+      values: signal.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cqtEnd - cqtStart + (end2 - cqtEnd)
+        }
+      }
+    };
+  }
+  if (request.fn === "pitchF0" || request.fn === "pitchConfidence") {
+    const pitchStart = nowMs2();
+    const pitchConfig = {
+      fMinHz: request.pitch?.fMinHz,
+      fMaxHz: request.pitch?.fMaxHz,
+      threshold: request.pitch?.threshold,
+      hopSize: specConfig.hopSize,
+      windowSize: specConfig.fftSize
+    };
+    const result = request.fn === "pitchF0" ? pitchF0(audio.mono, audio.sampleRate, pitchConfig) : pitchConfidence(audio.mono, audio.sampleRate, pitchConfig);
+    const end2 = nowMs2();
+    return {
+      kind: "1d",
+      times: result.times,
+      values: result.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: end2 - pitchStart
+        }
+      }
+    };
+  }
+  if (request.fn === "activity") {
+    const { mel: mel2, cpuExtraMs: melCpuMs } = await computeMel(false);
+    const activityStart = nowMs2();
+    const activityConfig = {
+      energyPercentile: request.activity?.energyPercentile,
+      enterMargin: request.activity?.enterMargin,
+      exitMargin: request.activity?.exitMargin,
+      hangoverMs: request.activity?.hangoverMs,
+      minActiveMs: request.activity?.minActiveMs,
+      smoothMs: request.activity?.smoothMs
+    };
+    const activity = computeActivityFromMel(mel2, activityConfig);
+    const end2 = nowMs2();
+    let activeCount = 0;
+    for (let i = 0; i < activity.isActive.length; i++) {
+      if (activity.isActive[i]) activeCount++;
+    }
+    return {
+      kind: "activity",
+      times: activity.times,
+      activityLevel: activity.activityLevel,
+      isActive: activity.isActive,
+      suppressMask: activity.suppressMask,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + melCpuMs + (end2 - activityStart)
+        }
+      },
+      diagnostics: {
+        noiseFloor: activity.diagnostics.noiseFloor,
+        enterThreshold: activity.diagnostics.enterThreshold,
+        exitThreshold: activity.diagnostics.exitThreshold,
+        totalFrames: activity.times.length,
+        activeFrames: activeCount,
+        activeFraction: activity.times.length > 0 ? activeCount / activity.times.length : 0
+      }
+    };
+  }
   const { mel, usedGpu, gpuMs, cpuExtraMs } = await computeMel(backend === "gpu");
   const end = nowMs2();
   return {
@@ -1926,6 +3229,6 @@ async function runMir(audio, request, options = {}) {
   };
 }
 
-export { beatSalienceFromMel, delta, deltaDelta, detectBeatCandidates, generateTempoHypotheses, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram };
-//# sourceMappingURL=chunk-KIGWMJLC.js.map
-//# sourceMappingURL=chunk-KIGWMJLC.js.map
+export { CQT_DEFAULTS, amplitudeEnvelope, applyActivityGating, bassPitchMotion, beatSalienceFromMel, buildActivityMask, computeActivityFromAudio, computeActivityFromMel, computeActivityFromSpectrogram, computeAllCqtSignals, computeCqt, computeCqtSignal, computeFrameEnergyFromMel, computeFrameEnergyFromSpectrogram, computeSilenceGating, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, estimateNoiseFloor, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, interpolateActivity, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, pitchConfidence, pitchF0, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withBinGateDefaults, withCqtDefaults, withSilenceGateDefaults };
+//# sourceMappingURL=chunk-5WZ7TTDW.js.map
+//# sourceMappingURL=chunk-5WZ7TTDW.js.map