@octoseq/mir 0.1.0-main.ef9b77a → 0.1.0-main.f485112

package/dist/{chunk-OLIDGECY.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;
@@ -2013,6 +2350,395 @@ function computeAllCqtSignals(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();
@@ -2039,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
@@ -2398,6 +3145,72 @@ async function runMir(audio, request, options = {}) {
       }
     };
   }
+  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 {
@@ -2416,6 +3229,6 @@ async function runMir(audio, request, options = {}) {
   };
 }
 
-export { CQT_DEFAULTS, bassPitchMotion, beatSalienceFromMel, computeAllCqtSignals, computeCqt, computeCqtSignal, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withCqtDefaults };
-//# sourceMappingURL=chunk-OLIDGECY.js.map
-//# sourceMappingURL=chunk-OLIDGECY.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