@octoseq/mir 0.1.0-main.2e286ce → 0.1.0-main.4baa7cd

package/dist/{chunk-DUWYCAVG.js → chunk-KIGWMJLC.js}

@@ -53,6 +53,646 @@ async function submitAndReadback(gpu, encoder, outBuffer, readback, byteLength)
   };
 }
 
+// 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/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 defaultOptions(opts) {
+  return {
+    useLog: opts?.useLog ?? false,
+    smoothMs: opts?.smoothMs ?? 30,
+    diffMethod: opts?.diffMethod ?? "rectified"
+  };
+}
+function logCompress(x) {
+  return Math.log1p(Math.max(0, x));
+}
+function onsetEnvelopeFromSpectrogram(spec, options) {
+  const opts = defaultOptions(options);
+  const nFrames = spec.times.length;
+  const out = new Float32Array(nFrames);
+  const nBins = (spec.fftSize >>> 1) + 1;
+  out[0] = 0;
+  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;
+    }
+    let sum = 0;
+    for (let k = 0; k < nBins; k++) {
+      let a = cur[k] ?? 0;
+      let b = prev[k] ?? 0;
+      if (opts.useLog) {
+        a = logCompress(a);
+        b = logCompress(b);
+      }
+      const d = a - b;
+      sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+    }
+    out[t] = nBins > 0 ? sum / nBins : 0;
+  }
+  const smoothMs = opts.smoothMs;
+  if (smoothMs > 0 && nFrames >= 2) {
+    const dt = (spec.times[1] ?? 0) - (spec.times[0] ?? 0);
+    const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
+    return {
+      times: spec.times,
+      values: movingAverage(out, windowFrames | 1)
+    };
+  }
+  return { times: spec.times, values: out };
+}
+function onsetEnvelopeFromMel(mel, options) {
+  const opts = defaultOptions(options);
+  const nFrames = mel.times.length;
+  const out = new Float32Array(nFrames);
+  out[0] = 0;
+  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;
+    let sum = 0;
+    for (let m = 0; m < nBands; m++) {
+      let a = cur[m] ?? 0;
+      let b = prev[m] ?? 0;
+      if (opts.useLog) {
+        a = logCompress(a);
+        b = logCompress(b);
+      }
+      const d = a - b;
+      sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+    }
+    out[t] = nBands > 0 ? sum / nBands : 0;
+  }
+  const smoothMs = opts.smoothMs;
+  if (smoothMs > 0 && nFrames >= 2) {
+    const dt = (mel.times[1] ?? 0) - (mel.times[0] ?? 0);
+    const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
+    return {
+      times: mel.times,
+      values: movingAverage(out, windowFrames | 1)
+    };
+  }
+  return { times: mel.times, values: out };
+}
+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 { value, timing } = await gpuOnsetEnvelopeFromMelFlat(gpu, {
+    nFrames,
+    nMels,
+    melFlat,
+    diffMethod
+  });
+  return {
+    times: mel.times,
+    values: value.out,
+    gpuTimings: { gpuSubmitToReadbackMs: timing.gpuSubmitToReadbackMs }
+  };
+}
+
+// src/dsp/spectral.ts
+function spectralCentroid(spec) {
+  const nFrames = spec.times.length;
+  const out = new Float32Array(nFrames);
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const binHz = spec.sampleRate / spec.fftSize;
+  for (let t = 0; t < nFrames; t++) {
+    const mags = spec.magnitudes[t];
+    if (!mags) {
+      out[t] = 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;
+    }
+    out[t] = den > 0 ? num / den : 0;
+  }
+  return out;
+}
+function spectralFlux(spec) {
+  const nFrames = spec.times.length;
+  const out = new Float32Array(nFrames);
+  const nBins = (spec.fftSize >>> 1) + 1;
+  let prev = null;
+  for (let t = 0; t < nFrames; t++) {
+    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 */
@@ -275,324 +915,92 @@ async function melSpectrogram(spec, config, gpu) {
     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/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/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;
+  );
+  if (gpu) {
+    try {
+      return await gpuMelProject(spec, filters, gpu);
+    } catch {
+      return cpuMelProject(spec, filters);
+    }
   }
-  return out;
-}
-function defaultOptions(opts) {
-  return {
-    useLog: opts?.useLog ?? false,
-    smoothMs: opts?.smoothMs ?? 30,
-    diffMethod: opts?.diffMethod ?? "rectified"
-  };
+  return cpuMelProject(spec, filters);
 }
-function logCompress(x) {
-  return Math.log1p(Math.max(0, x));
+
+// 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 onsetEnvelopeFromSpectrogram(spec, options) {
-  const opts = defaultOptions(options);
-  const nFrames = spec.times.length;
-  const out = new Float32Array(nFrames);
-  const nBins = (spec.fftSize >>> 1) + 1;
-  out[0] = 0;
-  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;
-    }
-    let sum = 0;
-    for (let k = 0; k < nBins; k++) {
-      let a = cur[k] ?? 0;
-      let b = prev[k] ?? 0;
-      if (opts.useLog) {
-        a = logCompress(a);
-        b = logCompress(b);
-      }
-      const d = a - b;
-      sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+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;
     }
-    out[t] = nBins > 0 ? sum / nBins : 0;
-  }
-  const smoothMs = opts.smoothMs;
-  if (smoothMs > 0 && nFrames >= 2) {
-    const dt = (spec.times[1] ?? 0) - (spec.times[0] ?? 0);
-    const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
-    return {
-      times: spec.times,
-      values: movingAverage(out, windowFrames | 1)
-    };
   }
-  return { times: spec.times, values: out };
+  return out;
 }
-function onsetEnvelopeFromMel(mel, options) {
-  const opts = defaultOptions(options);
+function mfcc(mel, options = {}) {
   const nFrames = mel.times.length;
-  const out = new Float32Array(nFrames);
-  out[0] = 0;
-  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;
-    let sum = 0;
-    for (let m = 0; m < nBands; m++) {
-      let a = cur[m] ?? 0;
-      let b = prev[m] ?? 0;
-      if (opts.useLog) {
-        a = logCompress(a);
-        b = logCompress(b);
+  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);
       }
-      const d = a - b;
-      sum += opts.diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+      c[i] = sum;
     }
-    out[t] = nBands > 0 ? sum / nBands : 0;
-  }
-  const smoothMs = opts.smoothMs;
-  if (smoothMs > 0 && nFrames >= 2) {
-    const dt = (mel.times[1] ?? 0) - (mel.times[0] ?? 0);
-    const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / Math.max(1e-9, dt)));
-    return {
-      times: mel.times,
-      values: movingAverage(out, windowFrames | 1)
-    };
+    out[t] = c;
   }
-  return { times: mel.times, values: out };
+  return { times: mel.times, coeffs: out };
 }
-async function onsetEnvelopeFromMelGpu(mel, gpu, options) {
-  const nFrames = mel.times.length;
-  const nMels = mel.melBands[0]?.length ?? 0;
-  const melFlat = new Float32Array(nFrames * nMels);
+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 row = mel.melBands[t];
-    if (!row) continue;
-    melFlat.set(row, t * nMels);
+    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;
   }
-  const diffMethod = options?.diffMethod ?? "rectified";
-  const { value, timing } = await gpuOnsetEnvelopeFromMelFlat(gpu, {
-    nFrames,
-    nMels,
-    melFlat,
-    diffMethod
-  });
-  return {
-    times: mel.times,
-    values: value.out,
-    gpuTimings: { gpuSubmitToReadbackMs: timing.gpuSubmitToReadbackMs }
-  };
+  return { times: features.times, values: out };
+}
+function deltaDelta(features, options = {}) {
+  return delta(delta(features, options), options);
 }
 
 // src/dsp/peakPick.ts
-function meanStd(values) {
+function meanStd2(values) {
   const n = values.length;
   if (n <= 0) return { mean: 0, std: 0 };
   let mean = 0;
@@ -629,7 +1037,7 @@ function peakPick(times, values, options = {}) {
     if (method === "median") {
       thr = median(values) * factor;
     } else {
-      const { mean, std } = meanStd(values);
+      const { mean, std } = meanStd2(values);
       thr = mean + factor * std;
     }
   }
@@ -1005,68 +1413,6 @@ async function hpssGpu(spec, gpu, options = {}) {
   };
 }
 
-// src/dsp/spectral.ts
-function spectralCentroid(spec) {
-  const nFrames = spec.times.length;
-  const out = new Float32Array(nFrames);
-  const nBins = (spec.fftSize >>> 1) + 1;
-  const binHz = spec.sampleRate / spec.fftSize;
-  for (let t = 0; t < nFrames; t++) {
-    const mags = spec.magnitudes[t];
-    if (!mags) {
-      out[t] = 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;
-    }
-    out[t] = den > 0 ? num / den : 0;
-  }
-  return out;
-}
-function spectralFlux(spec) {
-  const nFrames = spec.times.length;
-  const out = new Float32Array(nFrames);
-  const nBins = (spec.fftSize >>> 1) + 1;
-  let prev = null;
-  for (let t = 0; t < nFrames; t++) {
-    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/fft.ts
 function hannWindow(size) {
   const w = new Float32Array(size);
@@ -1400,6 +1746,66 @@ async function runMir(audio, request, options = {}) {
       }
     };
   }
+  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;
@@ -1520,6 +1926,6 @@ async function runMir(audio, request, options = {}) {
   };
 }
 
-export { delta, deltaDelta, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram };
-//# sourceMappingURL=chunk-DUWYCAVG.js.map
-//# sourceMappingURL=chunk-DUWYCAVG.js.map
+export { beatSalienceFromMel, delta, deltaDelta, detectBeatCandidates, generateTempoHypotheses, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram };
+//# sourceMappingURL=chunk-KIGWMJLC.js.map
+//# sourceMappingURL=chunk-KIGWMJLC.js.map