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

package/dist/chunk-5WZ7TTDW.js

@@ -0,0 +1,3234 @@
+import FFT from 'fft.js';
+
+// src/gpu/helpers.ts
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function byteSizeF32(n) {
+  return n * 4;
+}
+function createAndWriteStorageBuffer(gpu, data) {
+  const buf = gpu.device.createBuffer({
+    size: byteSizeF32(data.length),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  gpu.queue.writeBuffer(buf, 0, data);
+  return buf;
+}
+function createUniformBufferU32x4(gpu, u32x4) {
+  if (u32x4.length !== 4) throw new Error("@octoseq/mir: uniform buffer must be 4 u32 values");
+  const buf = gpu.device.createBuffer({
+    size: 16,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  gpu.queue.writeBuffer(buf, 0, u32x4);
+  return buf;
+}
+function createStorageOutBuffer(gpu, byteLength) {
+  return gpu.device.createBuffer({
+    size: byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+  });
+}
+function createReadbackBuffer(gpu, byteLength) {
+  return gpu.device.createBuffer({
+    size: byteLength,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+}
+async function submitAndReadback(gpu, encoder, outBuffer, readback, byteLength) {
+  encoder.copyBufferToBuffer(outBuffer, 0, readback, 0, byteLength);
+  const tSubmit = nowMs();
+  gpu.queue.submit([encoder.finish()]);
+  await readback.mapAsync(GPUMapMode.READ);
+  const tDone = nowMs();
+  const mapped = readback.getMappedRange();
+  const copy = mapped.slice(0);
+  readback.unmap();
+  return {
+    value: copy,
+    timing: {
+      gpuSubmitToReadbackMs: tDone - tSubmit
+    }
+  };
+}
+
+// src/gpu/kernels/onsetEnvelope.wgsl.ts
+var onsetEnvelopeWGSL = (
+  /* wgsl */
+  `
+// Compute onset strength envelope from a (log) mel spectrogram.
+//
+// Input layout: melFlat[t*nMels + m]
+// Output layout: out[t]
+//
+// We compute novelty per frame:
+//   novelty[t] = sum_m max(0, mel[t,m] - mel[t-1,m])   (rectified)
+//            or sum_m abs(...)
+//
+// One invocation computes one frame index (t). This is memory-bound but reduces a full
+// (frames*mels) loop to the GPU and provides an end-to-end submit->readback timing.
+
+struct Params {
+  nMels: u32,
+  nFrames: u32,
+  diffMethod: u32, // 0=rectified, 1=abs
+  _pad: u32,
+};
+
+@group(0) @binding(0) var<storage, read> melFlat: array<f32>;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let t = gid.x;
+  if (t >= params.nFrames) { return; }
+
+  if (t == 0u) {
+    out[t] = 0.0;
+    return;
+  }
+
+  let nMels = params.nMels;
+  var sum: f32 = 0.0;
+
+  // Linear loop: nMels is small (e.g. 64). Keeping it serial per-frame is fine.
+  // (Future optimisation: parallelise reduction within workgroup.)
+  for (var m: u32 = 0u; m < nMels; m = m + 1u) {
+    let a = melFlat[t * nMels + m];
+    let b = melFlat[(t - 1u) * nMels + m];
+    let d = a - b;
+
+    if (params.diffMethod == 1u) {
+      // abs
+      sum = sum + abs(d);
+    } else {
+      // rectified
+      sum = sum + max(0.0, d);
+    }
+  }
+
+  out[t] = sum / max(1.0, f32(nMels));
+}
+`
+);
+
+// src/gpu/onsetEnvelope.ts
+async function gpuOnsetEnvelopeFromMelFlat(gpu, input) {
+  const { device } = gpu;
+  const { nFrames, nMels, melFlat, diffMethod } = input;
+  if (melFlat.length !== nFrames * nMels) {
+    throw new Error("@octoseq/mir: melFlat length mismatch");
+  }
+  const melBuffer = createAndWriteStorageBuffer(gpu, melFlat);
+  const outByteLen = byteSizeF32(nFrames);
+  const outBuffer = createStorageOutBuffer(gpu, outByteLen);
+  const readback = createReadbackBuffer(gpu, outByteLen);
+  const shader = device.createShaderModule({ code: onsetEnvelopeWGSL });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  const diffU32 = diffMethod === "abs" ? 1 : 0;
+  const params = createUniformBufferU32x4(gpu, new Uint32Array([nMels, nFrames, diffU32, 0]));
+  const bindGroup = device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: melBuffer } },
+      { binding: 1, resource: { buffer: outBuffer } },
+      { binding: 2, resource: { buffer: params } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  const wg = Math.ceil(nFrames / 256);
+  pass.dispatchWorkgroups(wg);
+  pass.end();
+  const { value: bytes, timing } = await submitAndReadback(gpu, encoder, outBuffer, readback, outByteLen);
+  melBuffer.destroy();
+  outBuffer.destroy();
+  params.destroy();
+  readback.destroy();
+  return {
+    value: { out: new Float32Array(bytes) },
+    timing
+  };
+}
+
+// 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;
+  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 resolveOptions(opts) {
+  return {
+    useLog: opts?.useLog ?? false,
+    smoothMs: opts?.smoothMs ?? 30,
+    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 = resolveOptions(options);
+  const nFrames = spec.times.length;
+  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];
+    if (!cur || !prev) {
+      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] = 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 = 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: 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 result;
+}
+function onsetEnvelopeFromMel(mel, 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];
+    if (!cur || !prev) {
+      out[t] = 0;
+      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] = 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 = 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 };
+  if (opts.returnDiagnostics && rawNovelty) {
+    result.diagnostics = {
+      frameEnergy,
+      noiseFloor: gating.noiseFloor,
+      enterThreshold: gating.enterThreshold,
+      exitThreshold: gating.exitThreshold,
+      activityMask: gating.activityMask,
+      suppressionMask: gating.suppressionMask,
+      rawNovelty
+    };
+  }
+  return result;
+}
+async function onsetEnvelopeFromMelGpu(mel, gpu, options) {
+  const nFrames = mel.times.length;
+  const nMels = mel.melBands[0]?.length ?? 0;
+  const melFlat = new Float32Array(nFrames * nMels);
+  for (let t = 0; t < nFrames; t++) {
+    const row = mel.melBands[t];
+    if (!row) continue;
+    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
+  });
+  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,
+    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 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] = holdBehavior ? lastActiveValue : 0;
+      continue;
+    }
+    let num = 0;
+    let den = 0;
+    for (let k = 0; k < nBins; k++) {
+      const m = mags[k] ?? 0;
+      const f = k * binHz;
+      num += f * m;
+      den += m;
+    }
+    const centroid = den > 0 ? num / den : 0;
+    out[t] = centroid;
+    lastActiveValue = centroid;
+  }
+  return out;
+}
+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;
+      prev = null;
+      continue;
+    }
+    let sum = 0;
+    for (let k = 0; k < nBins; k++) sum += mags[k] ?? 0;
+    if (sum <= 0) {
+      out[t] = 0;
+      prev = null;
+      continue;
+    }
+    const cur = new Float32Array(nBins);
+    const inv = 1 / sum;
+    for (let k = 0; k < nBins; k++) cur[k] = (mags[k] ?? 0) * inv;
+    if (!prev) {
+      out[t] = 0;
+      prev = cur;
+      continue;
+    }
+    let flux = 0;
+    for (let k = 0; k < nBins; k++) {
+      const d = (cur[k] ?? 0) - (prev[k] ?? 0);
+      flux += Math.abs(d);
+    }
+    out[t] = flux;
+    prev = cur;
+  }
+  return out;
+}
+
+// src/dsp/beatCandidates.ts
+function movingAverage2(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 meanStd(values) {
+  const n = values.length;
+  if (n <= 0) return { mean: 0, std: 0 };
+  let mean = 0;
+  for (let i = 0; i < n; i++) mean += values[i] ?? 0;
+  mean /= n;
+  let varSum = 0;
+  for (let i = 0; i < n; i++) {
+    const d = (values[i] ?? 0) - mean;
+    varSum += d * d;
+  }
+  const std = Math.sqrt(varSum / n);
+  return { mean, std };
+}
+function zScoreNormalize(values) {
+  const { mean, std } = meanStd(values);
+  const n = values.length;
+  const out = new Float32Array(n);
+  if (std === 0 || !Number.isFinite(std)) {
+    out.fill(0);
+    return out;
+  }
+  for (let i = 0; i < n; i++) {
+    out[i] = ((values[i] ?? 0) - mean) / std;
+  }
+  return out;
+}
+function minMaxNormalize(values) {
+  const n = values.length;
+  if (n === 0) return new Float32Array(0);
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const out = new Float32Array(n);
+  const range = max - min;
+  if (range === 0 || !Number.isFinite(range)) {
+    out.fill(0.5);
+    return out;
+  }
+  for (let i = 0; i < n; i++) {
+    out[i] = ((values[i] ?? 0) - min) / range;
+  }
+  return out;
+}
+function beatSalienceFromMel(mel, spec, options) {
+  const smoothMs = options?.smoothMs ?? 50;
+  const onset = onsetEnvelopeFromMel(mel, {
+    smoothMs,
+    diffMethod: "rectified",
+    useLog: false
+  });
+  const flux = spectralFlux(spec);
+  const n = Math.min(onset.times.length, flux.length);
+  const onsetNorm = zScoreNormalize(onset.values.subarray(0, n));
+  const fluxNorm = zScoreNormalize(flux.subarray(0, n));
+  const combined = new Float32Array(n);
+  const onsetWeight = 0.7;
+  const fluxWeight = 0.3;
+  for (let i = 0; i < n; i++) {
+    combined[i] = onsetWeight * (onsetNorm[i] ?? 0) + fluxWeight * (fluxNorm[i] ?? 0);
+  }
+  const dt = n >= 2 ? (onset.times[1] ?? 0) - (onset.times[0] ?? 0) : 0.01;
+  const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
+  const smoothed = movingAverage2(combined, windowFrames | 1);
+  const normalized = minMaxNormalize(smoothed);
+  return {
+    times: onset.times.subarray(0, n),
+    values: normalized
+  };
+}
+function pickBeatCandidates(salience, options, source) {
+  const minIntervalSec = options.minIntervalSec ?? 0.1;
+  const thresholdFactor = options.thresholdFactor ?? 0.5;
+  const { times, values } = salience;
+  const n = values.length;
+  if (n < 3) return [];
+  const { mean, std } = meanStd(values);
+  const threshold = mean + thresholdFactor * std;
+  const candidates = [];
+  let lastPeakTime = -Infinity;
+  for (let i = 1; i < n - 1; i++) {
+    const v = values[i] ?? 0;
+    if (v < threshold) continue;
+    const prev = values[i - 1] ?? 0;
+    const next = values[i + 1] ?? 0;
+    if (!(v > prev && v > next)) continue;
+    const t = times[i] ?? 0;
+    if (t - lastPeakTime < minIntervalSec) {
+      const last = candidates[candidates.length - 1];
+      if (last && v > last.strength) {
+        last.time = t;
+        last.strength = v;
+      }
+      continue;
+    }
+    candidates.push({
+      time: t,
+      strength: v,
+      source
+    });
+    lastPeakTime = t;
+  }
+  return candidates;
+}
+function detectBeatCandidates(mel, spec, options) {
+  const opts = {
+    minIntervalSec: options?.minIntervalSec ?? 0.1,
+    thresholdFactor: options?.thresholdFactor ?? 0.5,
+    smoothMs: options?.smoothMs ?? 50
+  };
+  const salience = beatSalienceFromMel(mel, spec, { smoothMs: opts.smoothMs });
+  const candidates = pickBeatCandidates(salience, opts, "combined");
+  return {
+    candidates,
+    salience
+  };
+}
+
+// src/dsp/tempoHypotheses.ts
+function intervalToBpm(intervalSec) {
+  return 60 / intervalSec;
+}
+function bpmToInterval(bpm) {
+  return 60 / bpm;
+}
+function computeIOIs(candidates, weightByStrength) {
+  if (candidates.length < 2) return [];
+  const iois = [];
+  const sorted = [...candidates].sort((a, b) => a.time - b.time);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const curr = sorted[i];
+    const interval = curr.time - prev.time;
+    if (interval <= 0) continue;
+    const weight = weightByStrength ? Math.sqrt(prev.strength * curr.strength) : 1;
+    iois.push({ intervalSec: interval, weight });
+  }
+  return iois;
+}
+function buildBpmHistogram(iois, minBpm, maxBpm, binSizeBpm) {
+  const numBins = Math.ceil((maxBpm - minBpm) / binSizeBpm);
+  const counts = new Float32Array(numBins);
+  const bpmBins = new Float32Array(numBins);
+  for (let i = 0; i < numBins; i++) {
+    bpmBins[i] = minBpm + (i + 0.5) * binSizeBpm;
+  }
+  const minInterval = bpmToInterval(maxBpm);
+  const maxInterval = bpmToInterval(minBpm);
+  for (const { intervalSec, weight } of iois) {
+    if (intervalSec < minInterval || intervalSec > maxInterval) continue;
+    const bpm = intervalToBpm(intervalSec);
+    const binIndex = Math.floor((bpm - minBpm) / binSizeBpm);
+    if (binIndex >= 0 && binIndex < numBins) {
+      counts[binIndex] = (counts[binIndex] ?? 0) + weight;
+    }
+  }
+  return { bpmBins, counts };
+}
+function findHistogramPeaks(counts, minHeight) {
+  const peaks = [];
+  for (let i = 1; i < counts.length - 1; i++) {
+    const curr = counts[i];
+    const prev = counts[i - 1];
+    const next = counts[i + 1];
+    if (curr > prev && curr > next && curr >= minHeight) {
+      peaks.push({ index: i, height: curr });
+    }
+  }
+  if (counts.length > 0 && counts[0] >= minHeight && counts[0] > (counts[1] ?? 0)) {
+    peaks.push({ index: 0, height: counts[0] });
+  }
+  if (counts.length > 1) {
+    const last = counts.length - 1;
+    if (counts[last] >= minHeight && counts[last] > (counts[last - 1] ?? 0)) {
+      peaks.push({ index: last, height: counts[last] });
+    }
+  }
+  peaks.sort((a, b) => b.height - a.height);
+  return peaks.map((p) => p.index);
+}
+function refinePeakBpm(peakIndex, bpmBins, counts, binSizeBpm) {
+  let totalWeight = 0;
+  let weightedBpm = 0;
+  let minBinBpm = bpmBins[peakIndex] - binSizeBpm / 2;
+  let maxBinBpm = bpmBins[peakIndex] + binSizeBpm / 2;
+  for (let offset = -1; offset <= 1; offset++) {
+    const idx = peakIndex + offset;
+    if (idx < 0 || idx >= bpmBins.length) continue;
+    const w = counts[idx];
+    const bpm = bpmBins[idx];
+    totalWeight += w;
+    weightedBpm += w * bpm;
+    if (w > 0) {
+      minBinBpm = Math.min(minBinBpm, bpm - binSizeBpm / 2);
+      maxBinBpm = Math.max(maxBinBpm, bpm + binSizeBpm / 2);
+    }
+  }
+  const refinedBpm = totalWeight > 0 ? weightedBpm / totalWeight : bpmBins[peakIndex];
+  return {
+    bpm: refinedBpm,
+    peakHeight: counts[peakIndex],
+    binRange: [minBinBpm, maxBinBpm],
+    totalWeight
+  };
+}
+function getHarmonicRatio(bpm1, bpm2, tolerance = 0.03) {
+  const ratios = [0.5, 1 / 3, 2 / 3, 1, 1.5, 2, 3];
+  for (const ratio of ratios) {
+    const expected = bpm1 * ratio;
+    const relativeError = Math.abs(bpm2 - expected) / expected;
+    if (relativeError <= tolerance) {
+      return ratio;
+    }
+  }
+  return null;
+}
+function assignHarmonicFamilies(hypotheses) {
+  if (hypotheses.length === 0) return;
+  const families = /* @__PURE__ */ new Map();
+  for (const hyp of hypotheses) {
+    let foundFamily = false;
+    for (const [familyId, family] of families) {
+      const ratio = getHarmonicRatio(family.rootBpm, hyp.bpm);
+      if (ratio !== null) {
+        hyp.familyId = familyId;
+        hyp.harmonicRatio = ratio;
+        family.members.push(hyp);
+        foundFamily = true;
+        break;
+      }
+    }
+    if (!foundFamily) {
+      const familyId = `fam-${Math.round(hyp.bpm)}`;
+      hyp.familyId = familyId;
+      hyp.harmonicRatio = 1;
+      families.set(familyId, { rootBpm: hyp.bpm, members: [hyp] });
+    }
+  }
+}
+function normalizeConfidence(hypotheses) {
+  if (hypotheses.length === 0) return;
+  const maxHeight = Math.max(...hypotheses.map((h) => h.evidence.peakHeight));
+  if (maxHeight <= 0) return;
+  for (const hyp of hypotheses) {
+    hyp.confidence = hyp.evidence.peakHeight / maxHeight;
+  }
+}
+function generateTempoHypotheses(candidates, options) {
+  const minBpm = options?.minBpm ?? 24;
+  const maxBpm = options?.maxBpm ?? 300;
+  const binSizeBpm = options?.binSizeBpm ?? 1;
+  const maxHypotheses = options?.maxHypotheses ?? 10;
+  const minConfidence = options?.minConfidence ?? 0.05;
+  const weightByStrength = options?.weightByStrength ?? true;
+  const includeHistogram = options?.includeHistogram ?? false;
+  if (candidates.length < 2) {
+    return {
+      hypotheses: [],
+      inputCandidateCount: candidates.length,
+      histogram: includeHistogram ? {
+        bpmBins: new Float32Array(0),
+        counts: new Float32Array(0)
+      } : void 0
+    };
+  }
+  const iois = computeIOIs(candidates, weightByStrength);
+  if (iois.length === 0) {
+    return {
+      hypotheses: [],
+      inputCandidateCount: candidates.length,
+      histogram: includeHistogram ? {
+        bpmBins: new Float32Array(0),
+        counts: new Float32Array(0)
+      } : void 0
+    };
+  }
+  const { bpmBins, counts } = buildBpmHistogram(iois, minBpm, maxBpm, binSizeBpm);
+  const maxCount = Math.max(...counts);
+  const minHeight = maxCount * minConfidence;
+  const peakIndices = findHistogramPeaks(counts, minHeight);
+  const hypotheses = [];
+  for (const peakIndex of peakIndices.slice(0, maxHypotheses * 2)) {
+    const { bpm, peakHeight, binRange, totalWeight } = refinePeakBpm(
+      peakIndex,
+      bpmBins,
+      counts,
+      binSizeBpm
+    );
+    if (maxCount > 0 && peakHeight / maxCount < minConfidence) continue;
+    const evidence = {
+      supportingIntervalCount: Math.round(totalWeight),
+      weightedSupport: totalWeight,
+      peakHeight,
+      binRange
+    };
+    hypotheses.push({
+      id: "",
+      // Will be assigned after sorting
+      bpm: Math.round(bpm * 10) / 10,
+      // Round to 0.1 BPM precision
+      confidence: 0,
+      // Will be normalized
+      evidence,
+      familyId: "",
+      // Will be assigned
+      harmonicRatio: 1
+      // Will be assigned
+    });
+  }
+  assignHarmonicFamilies(hypotheses);
+  normalizeConfidence(hypotheses);
+  const filtered = hypotheses.filter((h) => h.confidence >= minConfidence).sort((a, b) => b.confidence - a.confidence).slice(0, maxHypotheses);
+  for (let i = 0; i < filtered.length; i++) {
+    filtered[i].id = `hyp-${i}`;
+  }
+  return {
+    hypotheses: filtered,
+    inputCandidateCount: candidates.length,
+    histogram: includeHistogram ? { bpmBins, counts } : void 0
+  };
+}
+
+// src/gpu/kernels/melProject.wgsl.ts
+var melProjectWGSL = (
+  /* wgsl */
+  `
+struct Params {
+  nBins: u32,
+  nMels: u32,
+  nFrames: u32,
+  _pad: u32,
+};
+
+@group(0) @binding(0) var<storage, read> mags : array<f32>;
+@group(0) @binding(1) var<storage, read> filters : array<f32>;
+@group(0) @binding(2) var<storage, read_write> out : array<f32>;
+@group(0) @binding(3) var<uniform> params : Params;
+
+fn log10(x: f32) -> f32 {
+  return log(x) / log(10.0);
+}
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let frame = gid.x;
+  let mel = gid.y;
+  if (frame >= params.nFrames || mel >= params.nMels) {
+    return;
+  }
+
+  var sum: f32 = 0.0;
+  let bins = params.nBins;
+  let magBase = frame * bins;
+  let filBase = mel * bins;
+
+  for (var k: u32 = 0u; k < bins; k = k + 1u) {
+    sum = sum + mags[magBase + k] * filters[filBase + k];
+  }
+
+  let eps: f32 = 1e-12;
+  out[frame * params.nMels + mel] = log10(eps + sum);
+}
+`
+);
+
+// src/gpu/melProject.ts
+async function gpuMelProjectFlat(gpu, input) {
+  const { device } = gpu;
+  const { nFrames, nBins, nMels, magsFlat, filterFlat } = input;
+  if (magsFlat.length !== nFrames * nBins) {
+    throw new Error("@octoseq/mir: magsFlat length mismatch");
+  }
+  if (filterFlat.length !== nMels * nBins) {
+    throw new Error("@octoseq/mir: filterFlat length mismatch");
+  }
+  const magsBuffer = createAndWriteStorageBuffer(gpu, magsFlat);
+  const filterBuffer = createAndWriteStorageBuffer(gpu, filterFlat);
+  const outByteLen = byteSizeF32(nFrames * nMels);
+  const outBuffer = createStorageOutBuffer(gpu, outByteLen);
+  const readback = createReadbackBuffer(gpu, outByteLen);
+  const shader = device.createShaderModule({ code: melProjectWGSL });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: {
+      module: shader,
+      entryPoint: "main"
+    }
+  });
+  const params = createUniformBufferU32x4(gpu, new Uint32Array([nBins, nMels, nFrames, 0]));
+  const bindGroup = device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: magsBuffer } },
+      { binding: 1, resource: { buffer: filterBuffer } },
+      { binding: 2, resource: { buffer: outBuffer } },
+      { binding: 3, resource: { buffer: params } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  const wgX = Math.ceil(nFrames / 16);
+  const wgY = Math.ceil(nMels / 16);
+  pass.dispatchWorkgroups(wgX, wgY);
+  pass.end();
+  const { value: bytes, timing } = await submitAndReadback(gpu, encoder, outBuffer, readback, outByteLen);
+  magsBuffer.destroy();
+  filterBuffer.destroy();
+  outBuffer.destroy();
+  params.destroy();
+  readback.destroy();
+  const outFlat = new Float32Array(bytes);
+  return {
+    value: { outFlat },
+    timing
+  };
+}
+
+// src/dsp/mel.ts
+function assertPositiveInt(name, value) {
+  if (!Number.isFinite(value) || value <= 0 || (value | 0) !== value) {
+    throw new Error(`@octoseq/mir: ${name} must be a positive integer`);
+  }
+}
+function hzToMel(hz) {
+  return 2595 * Math.log10(1 + hz / 700);
+}
+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;
+  const fMinClamped = Math.max(0, Math.min(fMin, nyquist));
+  const fMaxClamped = Math.max(0, Math.min(fMax, nyquist));
+  if (fMaxClamped <= fMinClamped) {
+    throw new Error("@octoseq/mir: mel fMax must be > fMin");
+  }
+  const melMin = hzToMel(fMinClamped);
+  const melMax = hzToMel(fMaxClamped);
+  const melPoints = new Float32Array(nMels + 2);
+  for (let i = 0; i < melPoints.length; i++) {
+    melPoints[i] = melMin + i * (melMax - melMin) / (nMels + 1);
+  }
+  const hzPoints = new Float32Array(melPoints.length);
+  for (let i = 0; i < hzPoints.length; i++) hzPoints[i] = melToHz(melPoints[i] ?? 0);
+  const binHz = sampleRate / fftSize;
+  const binPoints = new Int32Array(hzPoints.length);
+  for (let i = 0; i < binPoints.length; i++) {
+    binPoints[i] = Math.max(0, Math.min(nBins - 1, Math.round((hzPoints[i] ?? 0) / binHz)));
+  }
+  const filters = new Array(nMels);
+  for (let m = 0; m < nMels; m++) {
+    const left = binPoints[m] ?? 0;
+    const center = binPoints[m + 1] ?? 0;
+    const right = binPoints[m + 2] ?? 0;
+    const w = new Float32Array(nBins);
+    if (center === left || right === center) {
+      filters[m] = w;
+      continue;
+    }
+    for (let k = left; k < center; k++) {
+      w[k] = (k - left) / (center - left);
+    }
+    for (let k = center; k < right; k++) {
+      w[k] = (right - k) / (right - center);
+    }
+    filters[m] = w;
+  }
+  return filters;
+}
+function cpuMelProject(spec, filters) {
+  const nFrames = spec.times.length;
+  const nMels = filters.length;
+  const out = new Array(nFrames);
+  const eps = 1e-12;
+  for (let t = 0; t < nFrames; t++) {
+    const mags = spec.magnitudes[t];
+    if (!mags) {
+      out[t] = new Float32Array(nMels);
+      continue;
+    }
+    const bands = new Float32Array(nMels);
+    for (let m = 0; m < nMels; m++) {
+      const w = filters[m];
+      if (!w) continue;
+      let sum = 0;
+      for (let k = 0; k < mags.length; k++) {
+        sum += (mags[k] ?? 0) * (w[k] ?? 0);
+      }
+      bands[m] = Math.log10(eps + sum);
+    }
+    out[t] = bands;
+  }
+  return {
+    times: spec.times,
+    melBands: out
+  };
+}
+async function gpuMelProject(spec, filters, gpu) {
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const nMels = filters.length;
+  const magsFlat = new Float32Array(nFrames * nBins);
+  for (let t = 0; t < nFrames; t++) {
+    const mags = spec.magnitudes[t];
+    if (!mags) continue;
+    magsFlat.set(mags, t * nBins);
+  }
+  const filterFlat = new Float32Array(nMels * nBins);
+  for (let m = 0; m < nMels; m++) {
+    filterFlat.set(filters[m] ?? new Float32Array(nBins), m * nBins);
+  }
+  const { value, timing } = await gpuMelProjectFlat(gpu, {
+    nFrames,
+    nBins,
+    nMels,
+    magsFlat,
+    filterFlat
+  });
+  const outFlat = value.outFlat;
+  const melBands = new Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    melBands[t] = outFlat.subarray(t * nMels, (t + 1) * nMels);
+  }
+  return {
+    times: spec.times,
+    melBands,
+    gpuTimings: {
+      gpuSubmitToReadbackMs: timing.gpuSubmitToReadbackMs
+    }
+  };
+}
+async function melSpectrogram(spec, config, gpu) {
+  assertPositiveInt("config.nMels", config.nMels);
+  const fMin = config.fMin ?? 0;
+  const fMax = config.fMax ?? spec.sampleRate / 2;
+  const filters = buildMelFilterBank(
+    spec.sampleRate,
+    spec.fftSize,
+    config.nMels,
+    fMin,
+    fMax
+  );
+  if (gpu) {
+    try {
+      return await gpuMelProject(spec, filters, gpu);
+    } catch {
+      return cpuMelProject(spec, filters);
+    }
+  }
+  return cpuMelProject(spec, filters);
+}
+
+// src/dsp/mfcc.ts
+function assertPositiveInt2(name, v) {
+  if (!Number.isFinite(v) || v <= 0 || (v | 0) !== v) {
+    throw new Error(`@octoseq/mir: ${name} must be a positive integer`);
+  }
+}
+function buildDctMatrix(nCoeffs, nMels) {
+  const out = new Float32Array(nCoeffs * nMels);
+  const scale0 = Math.sqrt(1 / nMels);
+  const scale = Math.sqrt(2 / nMels);
+  for (let i = 0; i < nCoeffs; i++) {
+    for (let j = 0; j < nMels; j++) {
+      const c = Math.cos(Math.PI / nMels * (j + 0.5) * i);
+      out[i * nMels + j] = (i === 0 ? scale0 : scale) * c;
+    }
+  }
+  return out;
+}
+function mfcc(mel, options = {}) {
+  const nFrames = mel.times.length;
+  const nMels = mel.melBands[0]?.length ?? 0;
+  const nCoeffs = options.nCoeffs ?? 13;
+  assertPositiveInt2("options.nCoeffs", nCoeffs);
+  if (nMels <= 0) {
+    return { times: mel.times, coeffs: new Array(nFrames).fill(0).map(() => new Float32Array(nCoeffs)) };
+  }
+  const dct = buildDctMatrix(nCoeffs, nMels);
+  const out = new Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const x = mel.melBands[t] ?? new Float32Array(nMels);
+    const c = new Float32Array(nCoeffs);
+    for (let i = 0; i < nCoeffs; i++) {
+      let sum = 0;
+      const rowOff = i * nMels;
+      for (let j = 0; j < nMels; j++) {
+        sum += (dct[rowOff + j] ?? 0) * (x[j] ?? 0);
+      }
+      c[i] = sum;
+    }
+    out[t] = c;
+  }
+  return { times: mel.times, coeffs: out };
+}
+function delta(features, options = {}) {
+  const N = options.window ?? 2;
+  assertPositiveInt2("options.window", N);
+  const nFrames = features.times.length;
+  const nFeat = features.values[0]?.length ?? 0;
+  const out = new Array(nFrames);
+  let denom = 0;
+  for (let n = 1; n <= N; n++) denom += n * n;
+  denom *= 2;
+  for (let t = 0; t < nFrames; t++) {
+    const d = new Float32Array(nFeat);
+    for (let f = 0; f < nFeat; f++) {
+      let num = 0;
+      for (let n = 1; n <= N; n++) {
+        const tPlus = Math.min(nFrames - 1, t + n);
+        const tMinus = Math.max(0, t - n);
+        const a = features.values[tPlus]?.[f] ?? 0;
+        const b = features.values[tMinus]?.[f] ?? 0;
+        num += n * (a - b);
+      }
+      d[f] = denom > 0 ? num / denom : 0;
+    }
+    out[t] = d;
+  }
+  return { times: features.times, values: out };
+}
+function deltaDelta(features, options = {}) {
+  return delta(delta(features, options), options);
+}
+
+// src/dsp/peakPick.ts
+function meanStd2(values) {
+  const n = values.length;
+  if (n <= 0) return { mean: 0, std: 0 };
+  let mean = 0;
+  for (let i = 0; i < n; i++) mean += values[i] ?? 0;
+  mean /= n;
+  let varSum = 0;
+  for (let i = 0; i < n; i++) {
+    const d = (values[i] ?? 0) - mean;
+    varSum += d * d;
+  }
+  const std = Math.sqrt(varSum / n);
+  return { mean, std };
+}
+function median(values) {
+  const arr = Array.from(values);
+  arr.sort((a, b) => a - b);
+  const n = arr.length;
+  if (n === 0) return 0;
+  const mid = n >>> 1;
+  if (n % 2 === 1) return arr[mid] ?? 0;
+  return ((arr[mid - 1] ?? 0) + (arr[mid] ?? 0)) / 2;
+}
+function peakPick(times, values, options = {}) {
+  if (times.length !== values.length) {
+    throw new Error("@octoseq/mir: peakPick times/values length mismatch");
+  }
+  const n = values.length;
+  if (n === 0) return [];
+  const strict = options.strict ?? true;
+  let thr = options.threshold ?? 0;
+  if (options.adaptive) {
+    const method = options.adaptive.method ?? "meanStd";
+    const factor = options.adaptive.factor ?? 1;
+    if (method === "median") {
+      thr = median(values) * factor;
+    } else {
+      const { mean, std } = meanStd2(values);
+      thr = mean + factor * std;
+    }
+  }
+  const minIntervalSec = options.minIntervalSec ?? 0;
+  const out = [];
+  let lastPeakTime = -Infinity;
+  for (let i = 1; i < n - 1; i++) {
+    const v = values[i] ?? 0;
+    if (!(v >= thr)) continue;
+    const prev = values[i - 1] ?? 0;
+    const next = values[i + 1] ?? 0;
+    const isMax = strict ? v > prev && v > next : v >= prev && v >= next;
+    if (!isMax) continue;
+    const t = times[i] ?? 0;
+    if (t - lastPeakTime < minIntervalSec) {
+      const last = out[out.length - 1];
+      if (last && v > last.strength) {
+        last.time = t;
+        last.strength = v;
+        last.index = i;
+        lastPeakTime = t;
+      }
+      continue;
+    }
+    out.push({ time: t, strength: v, index: i });
+    lastPeakTime = t;
+  }
+  return out;
+}
+
+// src/dsp/hpss.ts
+function assertOddPositiveInt(name, v) {
+  if (!Number.isFinite(v) || v <= 0 || (v | 0) !== v) {
+    throw new Error(`@octoseq/mir: ${name} must be a positive integer`);
+  }
+  if (v % 2 !== 1) {
+    throw new Error(`@octoseq/mir: ${name} must be odd`);
+  }
+}
+function medianOfWindow(values) {
+  const arr = Array.from(values);
+  arr.sort((a, b) => a - b);
+  const mid = arr.length >>> 1;
+  return arr[mid] ?? 0;
+}
+function medianFilterTime(spec, kTime, options) {
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const half = kTime >>> 1;
+  const out = new Array(nFrames);
+  const window = new Float32Array(kTime);
+  for (let t = 0; t < nFrames; t++) {
+    if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    const row = new Float32Array(nBins);
+    for (let k = 0; k < nBins; k++) {
+      for (let i = -half, wi = 0; i <= half; i++, wi++) {
+        const tt = Math.max(0, Math.min(nFrames - 1, t + i));
+        const mags = spec.magnitudes[tt];
+        window[wi] = mags ? mags[k] ?? 0 : 0;
+      }
+      row[k] = medianOfWindow(window);
+    }
+    out[t] = row;
+  }
+  return out;
+}
+function medianFilterFreq(spec, kFreq, options) {
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const half = kFreq >>> 1;
+  const out = new Array(nFrames);
+  const window = new Float32Array(kFreq);
+  for (let t = 0; t < nFrames; t++) {
+    if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    const mags = spec.magnitudes[t] ?? new Float32Array(nBins);
+    const row = new Float32Array(nBins);
+    for (let k = 0; k < nBins; k++) {
+      for (let i = -half, wi = 0; i <= half; i++, wi++) {
+        const kk = Math.max(0, Math.min(nBins - 1, k + i));
+        window[wi] = mags[kk] ?? 0;
+      }
+      row[k] = medianOfWindow(window);
+    }
+    out[t] = row;
+  }
+  return out;
+}
+function hpss(spec, options = {}) {
+  const timeMedian = options.timeMedian ?? 17;
+  const freqMedian = options.freqMedian ?? 17;
+  assertOddPositiveInt("options.timeMedian", timeMedian);
+  assertOddPositiveInt("options.freqMedian", freqMedian);
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const H = medianFilterTime(spec, timeMedian, options);
+  const P = medianFilterFreq(spec, freqMedian, options);
+  const harmonic = new Array(nFrames);
+  const percussive = new Array(nFrames);
+  const soft = options.softMask ?? true;
+  const eps = 1e-12;
+  for (let t = 0; t < nFrames; t++) {
+    if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    const mags = spec.magnitudes[t] ?? new Float32Array(nBins);
+    const hRow = H[t] ?? new Float32Array(nBins);
+    const pRow = P[t] ?? new Float32Array(nBins);
+    const outH = new Float32Array(nBins);
+    const outP = new Float32Array(nBins);
+    for (let k = 0; k < nBins; k++) {
+      const x = mags[k] ?? 0;
+      const h = hRow[k] ?? 0;
+      const p = pRow[k] ?? 0;
+      if (soft) {
+        const denom = Math.max(eps, h + p);
+        const mh = h / denom;
+        const mp = p / denom;
+        outH[k] = x * mh;
+        outP[k] = x * mp;
+      } else {
+        const isH = h >= p;
+        outH[k] = isH ? x : 0;
+        outP[k] = isH ? 0 : x;
+      }
+    }
+    harmonic[t] = outH;
+    percussive[t] = outP;
+  }
+  return {
+    harmonic: { times: spec.times, bins: nBins, frames: nFrames, magnitudes: harmonic },
+    percussive: { times: spec.times, bins: nBins, frames: nFrames, magnitudes: percussive }
+  };
+}
+
+// src/gpu/kernels/hpssMasks.wgsl.ts
+var hpssMasksWGSL = (
+  /* wgsl */
+  `
+struct Params {
+  nBins: u32,
+  nFrames: u32,
+  softMask: u32, // 1 => soft, 0 => hard
+  _pad: u32,
+};
+
+@group(0) @binding(0) var<storage, read> mags : array<f32>;
+@group(0) @binding(1) var<storage, read_write> harmonicMask : array<f32>;
+@group(0) @binding(2) var<storage, read_write> percussiveMask : array<f32>;
+@group(0) @binding(3) var<uniform> params : Params;
+
+fn clamp_i32(x: i32, lo: i32, hi: i32) -> i32 {
+  return max(lo, min(hi, x));
+}
+
+fn swap_if_greater(a: ptr<function, f32>, b: ptr<function, f32>) {
+  // Branchless compare\u2013swap.
+  let av = *a;
+  let bv = *b;
+  *a = min(av, bv);
+  *b = max(av, bv);
+}
+
+// Sorting network for 9 values; returns the 5th smallest (median).
+//
+// Notes:
+// - This is fixed-cost and data-independent.
+// - For our HPSS approximation we only need a robust center value, and exact median-of-9
+//   is a good tradeoff vs kernel size.
+fn median9(v0: f32, v1: f32, v2: f32, v3: f32, v4: f32, v5: f32, v6: f32, v7: f32, v8: f32) -> f32 {
+  var a0 = v0; var a1 = v1; var a2 = v2;
+  var a3 = v3; var a4 = v4; var a5 = v5;
+  var a6 = v6; var a7 = v7; var a8 = v8;
+
+  // 9-input sorting network (compare\u2013swap stages). This is a known minimal-ish network.
+  // We fully sort then take middle; cost is acceptable for 9.
+  // Stage 1
+  swap_if_greater(&a0,&a1); swap_if_greater(&a3,&a4); swap_if_greater(&a6,&a7);
+  // Stage 2
+  swap_if_greater(&a1,&a2); swap_if_greater(&a4,&a5); swap_if_greater(&a7,&a8);
+  // Stage 3
+  swap_if_greater(&a0,&a1); swap_if_greater(&a3,&a4); swap_if_greater(&a6,&a7);
+  // Stage 4
+  swap_if_greater(&a0,&a3); swap_if_greater(&a3,&a6); swap_if_greater(&a0,&a3);
+  // Stage 5
+  swap_if_greater(&a1,&a4); swap_if_greater(&a4,&a7); swap_if_greater(&a1,&a4);
+  // Stage 6
+  swap_if_greater(&a2,&a5); swap_if_greater(&a5,&a8); swap_if_greater(&a2,&a5);
+  // Stage 7
+  swap_if_greater(&a1,&a3); swap_if_greater(&a5,&a7);
+  // Stage 8
+  swap_if_greater(&a2,&a6);
+  // Stage 9
+  swap_if_greater(&a2,&a3); swap_if_greater(&a4,&a6);
+  // Stage 10
+  swap_if_greater(&a2,&a4); swap_if_greater(&a4,&a6);
+  // Stage 11
+  swap_if_greater(&a3,&a5); swap_if_greater(&a5,&a7);
+  // Stage 12
+  swap_if_greater(&a3,&a4); swap_if_greater(&a5,&a6);
+  // Stage 13
+  swap_if_greater(&a4,&a5);
+
+  return a4;
+}
+
+fn mag_at(frame: i32, bin: i32) -> f32 {
+  let f = clamp_i32(frame, 0, i32(params.nFrames) - 1);
+  let b = clamp_i32(bin, 0, i32(params.nBins) - 1);
+  let idx = u32(f) * params.nBins + u32(b);
+  return mags[idx];
+}
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let frame = gid.x;
+  let bin = gid.y;
+
+  if (frame >= params.nFrames || bin >= params.nBins) {
+    return;
+  }
+
+  let f = i32(frame);
+  let b = i32(bin);
+
+  // Harmonic estimate: median in time over 9 taps.
+  let h = median9(
+    mag_at(f-4,b), mag_at(f-3,b), mag_at(f-2,b), mag_at(f-1,b), mag_at(f,b),
+    mag_at(f+1,b), mag_at(f+2,b), mag_at(f+3,b), mag_at(f+4,b)
+  );
+
+  // Percussive estimate: median in frequency over 9 taps.
+  let p = median9(
+    mag_at(f,b-4), mag_at(f,b-3), mag_at(f,b-2), mag_at(f,b-1), mag_at(f,b),
+    mag_at(f,b+1), mag_at(f,b+2), mag_at(f,b+3), mag_at(f,b+4)
+  );
+
+  let eps: f32 = 1e-12;
+  let denom = max(eps, h + p);
+
+  var mh = h / denom;
+  var mp = p / denom;
+
+  // Optional hard mask (kept for compatibility with CPU options).
+  if (params.softMask == 0u) {
+    let isH = h >= p;
+    mh = select(0.0, 1.0, isH);
+    mp = select(1.0, 0.0, isH);
+  }
+
+  let idx = frame * params.nBins + bin;
+  harmonicMask[idx] = mh;
+  percussiveMask[idx] = mp;
+}
+`
+);
+
+// src/gpu/hpssMasks.ts
+async function gpuHpssMasks(gpu, input) {
+  const { device } = gpu;
+  const { nFrames, nBins, magsFlat, softMask } = input;
+  if (magsFlat.length !== nFrames * nBins) {
+    throw new Error("@octoseq/mir: magsFlat length mismatch");
+  }
+  const magsBuffer = createAndWriteStorageBuffer(gpu, magsFlat);
+  const outByteLen = byteSizeF32(nFrames * nBins);
+  const harmonicOutBuffer = createStorageOutBuffer(gpu, outByteLen);
+  const percussiveOutBuffer = createStorageOutBuffer(gpu, outByteLen);
+  const harmonicReadback = createReadbackBuffer(gpu, outByteLen);
+  const percussiveReadback = createReadbackBuffer(gpu, outByteLen);
+  const shader = device.createShaderModule({ code: hpssMasksWGSL });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  const params = createUniformBufferU32x4(gpu, new Uint32Array([nBins, nFrames, softMask ? 1 : 0, 0]));
+  const bindGroup = device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: magsBuffer } },
+      { binding: 1, resource: { buffer: harmonicOutBuffer } },
+      { binding: 2, resource: { buffer: percussiveOutBuffer } },
+      { binding: 3, resource: { buffer: params } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  const wgX = Math.ceil(nFrames / 16);
+  const wgY = Math.ceil(nBins / 16);
+  pass.dispatchWorkgroups(wgX, wgY);
+  pass.end();
+  encoder.copyBufferToBuffer(harmonicOutBuffer, 0, harmonicReadback, 0, outByteLen);
+  encoder.copyBufferToBuffer(percussiveOutBuffer, 0, percussiveReadback, 0, outByteLen);
+  const tSubmit = nowMs();
+  gpu.queue.submit([encoder.finish()]);
+  await Promise.all([harmonicReadback.mapAsync(GPUMapMode.READ), percussiveReadback.mapAsync(GPUMapMode.READ)]);
+  const tDone = nowMs();
+  const hBytes = harmonicReadback.getMappedRange().slice(0);
+  const pBytes = percussiveReadback.getMappedRange().slice(0);
+  harmonicReadback.unmap();
+  percussiveReadback.unmap();
+  magsBuffer.destroy();
+  harmonicOutBuffer.destroy();
+  percussiveOutBuffer.destroy();
+  params.destroy();
+  harmonicReadback.destroy();
+  percussiveReadback.destroy();
+  return {
+    value: {
+      harmonicMaskFlat: new Float32Array(hBytes),
+      percussiveMaskFlat: new Float32Array(pBytes)
+    },
+    timing: {
+      gpuSubmitToReadbackMs: tDone - tSubmit
+    }
+  };
+}
+
+// src/dsp/hpssGpu.ts
+function flattenMagnitudes(mags, nFrames, nBins) {
+  const flat = new Float32Array(nFrames * nBins);
+  for (let t = 0; t < nFrames; t++) {
+    const row = mags[t] ?? new Float32Array(nBins);
+    flat.set(row, t * nBins);
+  }
+  return flat;
+}
+function assertFiniteMask(name, v) {
+  if (!Number.isFinite(v)) {
+    throw new Error(`@octoseq/mir: GPU HPSS produced non-finite ${name}`);
+  }
+}
+async function hpssGpu(spec, gpu, options = {}) {
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+  const magsFlat = flattenMagnitudes(spec.magnitudes, nFrames, nBins);
+  const soft = options.softMask ?? true;
+  const masks = await gpuHpssMasks(gpu, {
+    nFrames,
+    nBins,
+    magsFlat,
+    softMask: soft
+  });
+  if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+  const hMask = masks.value.harmonicMaskFlat;
+  const pMask = masks.value.percussiveMaskFlat;
+  const harmonic = new Array(nFrames);
+  const percussive = new Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    if (options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    const mags = spec.magnitudes[t] ?? new Float32Array(nBins);
+    const outH = new Float32Array(nBins);
+    const outP = new Float32Array(nBins);
+    const base = t * nBins;
+    for (let k = 0; k < nBins; k++) {
+      const x = mags[k] ?? 0;
+      const mh = hMask[base + k] ?? 0;
+      const mp = pMask[base + k] ?? 0;
+      assertFiniteMask("mask", mh);
+      assertFiniteMask("mask", mp);
+      const ch = Math.max(0, Math.min(1, mh));
+      const cp = Math.max(0, Math.min(1, mp));
+      outH[k] = x * ch;
+      outP[k] = x * cp;
+    }
+    harmonic[t] = outH;
+    percussive[t] = outP;
+  }
+  return {
+    harmonic: { times: spec.times, bins: nBins, frames: nFrames, magnitudes: harmonic },
+    percussive: { times: spec.times, bins: nBins, frames: nFrames, magnitudes: percussive },
+    gpuMs: masks.timing.gpuSubmitToReadbackMs
+  };
+}
+
+// src/dsp/fft.ts
+function hannWindow(size) {
+  const w = new Float32Array(size);
+  for (let n = 0; n < size; n++) {
+    w[n] = 0.5 - 0.5 * Math.cos(2 * Math.PI * n / size);
+  }
+  return w;
+}
+function createFftJsBackend(fftSize) {
+  if (!Number.isFinite(fftSize) || fftSize <= 0 || (fftSize | 0) !== fftSize) {
+    throw new Error("@octoseq/mir: fftSize must be a positive integer");
+  }
+  const fft = new FFT(fftSize);
+  const inReal = new Float32Array(fftSize);
+  const outComplexInterleaved = fft.createComplexArray();
+  const outReal = new Float32Array(fftSize);
+  const outImag = new Float32Array(fftSize);
+  return {
+    fftSize,
+    forwardReal(frame) {
+      if (frame.length !== fftSize) {
+        throw new Error(
+          `@octoseq/mir: FFT input length (${frame.length}) must equal fftSize (${fftSize})`
+        );
+      }
+      inReal.set(frame);
+      fft.realTransform(outComplexInterleaved, inReal);
+      fft.completeSpectrum(outComplexInterleaved);
+      for (let k = 0; k < fftSize; k++) {
+        const re = outComplexInterleaved[2 * k] ?? 0;
+        const im = outComplexInterleaved[2 * k + 1] ?? 0;
+        outReal[k] = re === 0 ? 0 : re;
+        outImag[k] = im === 0 ? 0 : im;
+      }
+      return { real: outReal, imag: outImag };
+    }
+  };
+}
+
+// src/dsp/fftBackend.ts
+var backendCache = /* @__PURE__ */ new Map();
+function getFftBackend(fftSize) {
+  const existing = backendCache.get(fftSize);
+  if (existing) return existing;
+  const created = createFftJsBackend(fftSize);
+  backendCache.set(fftSize, created);
+  return created;
+}
+
+// src/dsp/spectrogram.ts
+function assertPositiveInt3(name, value) {
+  if (!Number.isFinite(value) || value <= 0 || (value | 0) !== value) {
+    throw new Error(`@octoseq/mir: ${name} must be a positive integer`);
+  }
+}
+function mixToMono(audio) {
+  const nCh = audio.numberOfChannels;
+  if (nCh <= 0) {
+    throw new Error("@octoseq/mir: audio.numberOfChannels must be >= 1");
+  }
+  if (nCh === 1) {
+    return audio.getChannelData(0);
+  }
+  const length = audio.getChannelData(0).length;
+  const out = new Float32Array(length);
+  for (let ch = 0; ch < nCh; ch++) {
+    const data = audio.getChannelData(ch);
+    if (data.length !== length) {
+      throw new Error(
+        "@octoseq/mir: all channels must have equal length (AudioBuffer-like invariant)"
+      );
+    }
+    for (let i = 0; i < length; i++) {
+      out[i] = (out[i] ?? 0) + (data[i] ?? 0);
+    }
+  }
+  const inv = 1 / nCh;
+  for (let i = 0; i < length; i++) out[i] = (out[i] ?? 0) * inv;
+  return out;
+}
+async function spectrogram(audio, config, gpu, options = {}) {
+  assertPositiveInt3("config.fftSize", config.fftSize);
+  assertPositiveInt3("config.hopSize", config.hopSize);
+  if (config.window !== "hann") {
+    throw new Error(
+      `@octoseq/mir: unsupported window '${config.window}'. v0.1 supports only 'hann'.`
+    );
+  }
+  const fftSize = config.fftSize;
+  if ((fftSize & fftSize - 1) !== 0) {
+    throw new Error("@octoseq/mir: config.fftSize must be a power of two");
+  }
+  const hopSize = config.hopSize;
+  if (hopSize > fftSize) {
+    throw new Error(
+      "@octoseq/mir: config.hopSize must be <= config.fftSize"
+    );
+  }
+  const sr = audio.sampleRate;
+  const mono = mixToMono(audio);
+  const nFrames = Math.max(0, 1 + Math.floor((mono.length - fftSize) / hopSize));
+  const times = new Float32Array(nFrames);
+  const mags = new Array(nFrames);
+  const window = hannWindow(fftSize);
+  const fft = getFftBackend(fftSize);
+  const windowedFrame = new Float32Array(fftSize);
+  let totalFftMs = 0;
+  const nowMs3 = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+  for (let frame = 0; frame < nFrames; frame++) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const start = frame * hopSize;
+    times[frame] = (start + fftSize / 2) / sr;
+    for (let i = 0; i < fftSize; i++) {
+      const s = mono[start + i] ?? 0;
+      windowedFrame[i] = s * (window[i] ?? 0);
+    }
+    const t0 = nowMs3();
+    const { real, imag } = fft.forwardReal(windowedFrame);
+    totalFftMs += nowMs3() - t0;
+    const nBins = (fftSize >>> 1) + 1;
+    const out = new Float32Array(nBins);
+    for (let k = 0; k < nBins; k++) {
+      const re = real[k] ?? 0;
+      const im = imag[k] ?? 0;
+      out[k] = Math.hypot(re, im);
+    }
+    mags[frame] = out;
+  }
+  mags.cpuFftTotalMs = totalFftMs;
+  return {
+    sampleRate: sr,
+    fftSize,
+    hopSize,
+    times,
+    magnitudes: mags
+  };
+}
+
+// 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();
+}
+function asAudioBufferLike(audio) {
+  return {
+    sampleRate: audio.sampleRate,
+    numberOfChannels: 1,
+    getChannelData: () => audio.mono
+  };
+}
+async function runMir(audio, request, options = {}) {
+  options = {
+    ...options,
+    onset: { ...request.onset, ...options.onset },
+    peakPick: { ...request.peakPick, ...options.peakPick },
+    hpss: { ...request.hpss, ...options.hpss },
+    mfcc: { ...request.mfcc, ...options.mfcc }
+  };
+  const t0 = nowMs2();
+  const backend = request.backend ?? "cpu";
+  const specConfig = request.spectrogram ?? {
+    fftSize: 2048,
+    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
+  });
+  const cpuAfterSpec = nowMs2();
+  if (options.isCancelled?.()) {
+    throw new Error("@octoseq/mir: cancelled");
+  }
+  if (request.fn === "spectralCentroid") {
+    const values = spectralCentroid(spec);
+    const cpuEnd = nowMs2();
+    return {
+      kind: "1d",
+      times: spec.times,
+      values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: cpuEnd - t0,
+          cpuMs: cpuEnd - cpuStart
+        }
+      }
+    };
+  }
+  if (request.fn === "spectralFlux") {
+    const values = spectralFlux(spec);
+    const cpuEnd = nowMs2();
+    return {
+      kind: "1d",
+      times: spec.times,
+      values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: cpuEnd - t0,
+          cpuMs: cpuEnd - cpuStart
+        }
+      }
+    };
+  }
+  const melConfig = request.mel ?? { nMels: 64 };
+  const computeMel = async (useGpu) => {
+    const melCpuStart = nowMs2();
+    if (useGpu) {
+      if (!options.gpu) {
+        throw new Error("@octoseq/mir: backend='gpu' requested but no MirGPU provided");
+      }
+      const gpuStart = nowMs2();
+      try {
+        const mel3 = await melSpectrogram(spec, melConfig, options.gpu);
+        const gpuEnd = nowMs2();
+        const gpuKernelMs = mel3.gpuTimings?.gpuSubmitToReadbackMs;
+        return {
+          mel: mel3,
+          usedGpu: true,
+          gpuMs: gpuKernelMs ?? gpuEnd - gpuStart,
+          cpuExtraMs: nowMs2() - melCpuStart - (gpuEnd - gpuStart)
+        };
+      } catch (e) {
+        if (options.strictGpu) throw e;
+      }
+    }
+    const mel2 = await melSpectrogram(spec, melConfig, void 0);
+    const melCpuEnd = nowMs2();
+    return {
+      mel: mel2,
+      usedGpu: false,
+      cpuExtraMs: melCpuEnd - melCpuStart
+    };
+  };
+  if (request.fn === "melSpectrogram") {
+    const { mel: mel2, usedGpu: usedGpu2, gpuMs: gpuMs2, cpuExtraMs: cpuExtraMs2 } = await computeMel(backend === "gpu");
+    const end2 = nowMs2();
+    return {
+      kind: "2d",
+      times: mel2.times,
+      data: mel2.melBands,
+      meta: {
+        backend: usedGpu2 ? "gpu" : "cpu",
+        usedGpu: usedGpu2,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + cpuExtraMs2,
+          gpuMs: gpuMs2
+        }
+      }
+    };
+  }
+  if (request.fn === "onsetEnvelope") {
+    if (backend === "gpu") {
+      if (!options.gpu) throw new Error("@octoseq/mir: backend='gpu' requested but no MirGPU provided");
+      const { mel: mel3, usedGpu: usedGpuForMel, gpuMs: melGpuMs, cpuExtraMs: melCpuMs2 } = await computeMel(true);
+      nowMs2();
+      try {
+        const onsetGpu = await onsetEnvelopeFromMelGpu(mel3, options.gpu, {
+          diffMethod: options.onset?.diffMethod
+        });
+        const end3 = nowMs2();
+        return {
+          kind: "1d",
+          times: onsetGpu.times,
+          values: onsetGpu.values,
+          meta: {
+            backend: "gpu",
+            usedGpu: true,
+            timings: {
+              totalMs: end3 - t0,
+              cpuMs: cpuAfterSpec - cpuStart + melCpuMs2,
+              gpuMs: (melGpuMs ?? 0) + onsetGpu.gpuTimings.gpuSubmitToReadbackMs
+            }
+          }
+        };
+      } catch (e) {
+        if (options.strictGpu) throw e;
+      } finally {
+      }
+    }
+    const { mel: mel2, cpuExtraMs: melCpuMs } = await computeMel(false);
+    const onset = onsetEnvelopeFromMel(mel2, {
+      smoothMs: options.onset?.smoothMs,
+      diffMethod: options.onset?.diffMethod,
+      useLog: options.onset?.useLog
+    });
+    const end2 = nowMs2();
+    return {
+      kind: "1d",
+      times: onset.times,
+      values: onset.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + melCpuMs
+        }
+      }
+    };
+  }
+  if (request.fn === "onsetPeaks") {
+    const { mel: mel2, cpuExtraMs: melCpuMs } = await computeMel(false);
+    const onset = onsetEnvelopeFromMel(mel2, {
+      smoothMs: options.onset?.smoothMs,
+      diffMethod: options.onset?.diffMethod,
+      useLog: options.onset?.useLog
+    });
+    const events = peakPick(onset.times, onset.values, {
+      minIntervalSec: options.peakPick?.minIntervalSec,
+      threshold: options.peakPick?.threshold,
+      adaptive: options.peakPick?.adaptiveFactor ? { method: "meanStd", factor: options.peakPick.adaptiveFactor } : void 0
+    });
+    const end2 = nowMs2();
+    return {
+      kind: "events",
+      times: onset.times,
+      events,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + melCpuMs
+        }
+      }
+    };
+  }
+  if (request.fn === "beatCandidates") {
+    const { mel: mel2, cpuExtraMs: melCpuMs } = await computeMel(false);
+    const beatOpts = request.beatCandidates ?? {};
+    const result = detectBeatCandidates(mel2, spec, {
+      minIntervalSec: beatOpts.minIntervalSec,
+      thresholdFactor: beatOpts.thresholdFactor,
+      smoothMs: beatOpts.smoothMs
+    });
+    const end2 = nowMs2();
+    return {
+      kind: "beatCandidates",
+      times: result.salience.times,
+      candidates: result.candidates,
+      salience: beatOpts.includeSalience ? result.salience : void 0,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + melCpuMs
+        }
+      }
+    };
+  }
+  if (request.fn === "tempoHypotheses") {
+    const { mel: mel2, cpuExtraMs: melCpuMs } = await computeMel(false);
+    const beatOpts = request.beatCandidates ?? {};
+    const beatResult = detectBeatCandidates(mel2, spec, {
+      minIntervalSec: beatOpts.minIntervalSec,
+      thresholdFactor: beatOpts.thresholdFactor,
+      smoothMs: beatOpts.smoothMs
+    });
+    const tempoStart = nowMs2();
+    const tempoOpts = request.tempoHypotheses ?? {};
+    const result = generateTempoHypotheses(beatResult.candidates, {
+      minBpm: tempoOpts.minBpm,
+      maxBpm: tempoOpts.maxBpm,
+      binSizeBpm: tempoOpts.binSizeBpm,
+      maxHypotheses: tempoOpts.maxHypotheses,
+      minConfidence: tempoOpts.minConfidence,
+      weightByStrength: tempoOpts.weightByStrength,
+      includeHistogram: tempoOpts.includeHistogram
+    });
+    const end2 = nowMs2();
+    return {
+      kind: "tempoHypotheses",
+      times: spec.times,
+      hypotheses: result.hypotheses,
+      inputCandidateCount: result.inputCandidateCount,
+      histogram: result.histogram,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cpuAfterSpec - cpuStart + melCpuMs + (end2 - tempoStart)
+        }
+      }
+    };
+  }
+  if (request.fn === "hpssHarmonic" || request.fn === "hpssPercussive") {
+    const hpssSpecConfig = options.hpss?.spectrogram ?? specConfig;
+    const needsHpssSpec = hpssSpecConfig.fftSize !== specConfig.fftSize || hpssSpecConfig.hopSize !== specConfig.hopSize;
+    let hpssSpec;
+    let hpssCpuStart = cpuAfterSpec;
+    if (needsHpssSpec) {
+      hpssCpuStart = nowMs2();
+      hpssSpec = await spectrogram(asAudioBufferLike(audio), hpssSpecConfig, void 0, {
+        isCancelled: options.isCancelled
+      });
+    } else {
+      hpssSpec = spec;
+    }
+    const hpssAfterSpec = nowMs2();
+    if (backend === "gpu") {
+      if (!options.gpu) throw new Error("@octoseq/mir: backend='gpu' requested but no MirGPU provided");
+      const hpssStart2 = nowMs2();
+      try {
+        const out = await hpssGpu(hpssSpec, options.gpu, {
+          timeMedian: options.hpss?.timeMedian,
+          freqMedian: options.hpss?.freqMedian,
+          softMask: true,
+          // preserve CPU default
+          isCancelled: options.isCancelled
+        });
+        const end3 = nowMs2();
+        const chosen2 = request.fn === "hpssHarmonic" ? out.harmonic : out.percussive;
+        return {
+          kind: "2d",
+          times: chosen2.times,
+          data: chosen2.magnitudes,
+          meta: {
+            backend: "gpu",
+            usedGpu: true,
+            timings: {
+              totalMs: end3 - t0,
+              cpuMs: (needsHpssSpec ? hpssAfterSpec - hpssCpuStart : cpuAfterSpec - cpuStart) + (end3 - hpssStart2 - out.gpuMs),
+              gpuMs: out.gpuMs
+            }
+          }
+        };
+      } catch (e) {
+        if (options.strictGpu) throw e;
+      }
+    }
+    const hpssStart = nowMs2();
+    const { harmonic, percussive } = hpss(hpssSpec, {
+      timeMedian: options.hpss?.timeMedian,
+      freqMedian: options.hpss?.freqMedian,
+      isCancelled: options.isCancelled
+    });
+    const end2 = nowMs2();
+    const cpuMs = (needsHpssSpec ? hpssAfterSpec - hpssCpuStart : cpuAfterSpec - cpuStart) + (end2 - hpssStart);
+    const chosen = request.fn === "hpssHarmonic" ? harmonic : percussive;
+    return {
+      kind: "2d",
+      times: chosen.times,
+      data: chosen.magnitudes,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: { totalMs: end2 - t0, cpuMs }
+      }
+    };
+  }
+  if (request.fn === "mfcc" || request.fn === "mfccDelta" || request.fn === "mfccDeltaDelta") {
+    const mfccSpecConfig = options.mfcc?.spectrogram ?? specConfig;
+    const needsMfccSpec = mfccSpecConfig.fftSize !== specConfig.fftSize || mfccSpecConfig.hopSize !== specConfig.hopSize;
+    let mfccMel;
+    let mfccCpuMs;
+    if (needsMfccSpec) {
+      const mfccCpuStart = nowMs2();
+      const mfccSpec = await spectrogram(asAudioBufferLike(audio), mfccSpecConfig, void 0, {
+        isCancelled: options.isCancelled
+      });
+      const mfccMelResult = await melSpectrogram(mfccSpec, melConfig, void 0);
+      mfccMel = mfccMelResult;
+      mfccCpuMs = nowMs2() - mfccCpuStart;
+    } else {
+      const { mel: mel2, cpuExtraMs: cpuExtraMs2 } = await computeMel(false);
+      mfccMel = mel2;
+      mfccCpuMs = cpuAfterSpec - cpuStart + cpuExtraMs2;
+    }
+    const mfccStart = nowMs2();
+    const base = mfcc(mfccMel, { nCoeffs: options.mfcc?.nCoeffs });
+    const features = { times: base.times, values: base.coeffs };
+    const chosen = request.fn === "mfcc" ? features : request.fn === "mfccDelta" ? delta(features) : deltaDelta(features);
+    const end2 = nowMs2();
+    return {
+      kind: "2d",
+      times: chosen.times,
+      data: chosen.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: mfccCpuMs + (end2 - mfccStart)
+        }
+      }
+    };
+  }
+  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 {
+    kind: "2d",
+    times: mel.times,
+    data: mel.melBands,
+    meta: {
+      backend: usedGpu ? "gpu" : "cpu",
+      usedGpu,
+      timings: {
+        totalMs: end - t0,
+        cpuMs: cpuAfterSpec - cpuStart + cpuExtraMs,
+        gpuMs
+      }
+    }
+  };
+}
+
+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