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

package/dist/{chunk-DUWYCAVG.js → chunk-OLIDGECY.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 */
@@ -162,6 +802,20 @@ function hzToMel(hz) {
 function melToHz(mel) {
   return 700 * (Math.pow(10, mel / 2595) - 1);
 }
+function hzToFeatureIndex(hz, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const melHz = hzToMel(hz);
+  const normalized = (melHz - melMin) / (melMax - melMin);
+  return normalized * (config.nMels - 1);
+}
+function featureIndexToHz(index, config) {
+  const melMin = hzToMel(config.fMin);
+  const melMax = hzToMel(config.fMax);
+  const normalized = index / (config.nMels - 1);
+  const mel = melMin + normalized * (melMax - melMin);
+  return melToHz(mel);
+}
 function buildMelFilterBank(sampleRate, fftSize, nMels, fMin, fMax) {
   const nBins = (fftSize >>> 1) + 1;
   const nyquist = sampleRate / 2;
@@ -351,248 +1005,16 @@ function delta(features, options = {}) {
       }
       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;
-  }
-  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)
-    };
+    out[t] = d;
   }
-  return { times: mel.times, values: out };
+  return { times: features.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 }
-  };
+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 +1051,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 +1427,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);
@@ -1207,6 +1567,452 @@ async function spectrogram(audio, config, gpu, options = {}) {
   };
 }
 
+// src/dsp/cqt.ts
+var CQT_DEFAULTS = {
+  /** Quarter-tone resolution (24 bins per octave) */
+  binsPerOctave: 24,
+  /** C1 (lowest note on a standard piano) */
+  fMin: 32.7,
+  /** C9 (well above audible range for most content) */
+  fMax: 8372
+};
+function cqtBinToHz(bin, config) {
+  return config.fMin * Math.pow(2, bin / config.binsPerOctave);
+}
+function hzToCqtBin(hz, config) {
+  if (hz <= 0) return -Infinity;
+  return config.binsPerOctave * Math.log2(hz / config.fMin);
+}
+function getNumOctaves(config) {
+  return Math.log2(config.fMax / config.fMin);
+}
+function getNumBins(config) {
+  const nOctaves = getNumOctaves(config);
+  return Math.ceil(nOctaves * config.binsPerOctave);
+}
+function getCqtBinFrequencies(config) {
+  const nBins = getNumBins(config);
+  const freqs = new Float32Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    freqs[k] = cqtBinToHz(k, config);
+  }
+  return freqs;
+}
+var kernelBankCache = /* @__PURE__ */ new Map();
+function kernelCacheKey(config, fftSize, sampleRate) {
+  return `${config.binsPerOctave}:${config.fMin}:${config.fMax}:${fftSize}:${sampleRate}`;
+}
+function createCqtKernel(binIndex, config, fftSize, sampleRate) {
+  const centerFreq = cqtBinToHz(binIndex, config);
+  const freqResolution = sampleRate / fftSize;
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const bandwidth = centerFreq / Q;
+  const fLow = centerFreq - bandwidth / 2;
+  const fHigh = centerFreq + bandwidth / 2;
+  const startBin = Math.max(0, Math.floor(fLow / freqResolution));
+  const endBin = Math.min(
+    Math.floor(fftSize / 2) + 1,
+    Math.ceil(fHigh / freqResolution) + 1
+  );
+  const numBins = Math.max(1, endBin - startBin);
+  const weights = new Float32Array(numBins);
+  for (let i = 0; i < numBins; i++) {
+    const binFreq = (startBin + i) * freqResolution;
+    if (binFreq <= centerFreq) {
+      if (centerFreq > fLow) {
+        weights[i] = (binFreq - fLow) / (centerFreq - fLow);
+      } else {
+        weights[i] = 1;
+      }
+    } else {
+      if (fHigh > centerFreq) {
+        weights[i] = (fHigh - binFreq) / (fHigh - centerFreq);
+      } else {
+        weights[i] = 1;
+      }
+    }
+    weights[i] = Math.max(0, Math.min(1, weights[i] ?? 0));
+  }
+  let sum = 0;
+  for (let i = 0; i < numBins; i++) {
+    sum += weights[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < numBins; i++) {
+      weights[i] = (weights[i] ?? 0) / sum;
+    }
+  }
+  return {
+    centerFreq,
+    startBin,
+    endBin,
+    weights
+  };
+}
+function getCqtKernelBank(config, fftSize, sampleRate) {
+  const key = kernelCacheKey(config, fftSize, sampleRate);
+  const cached = kernelBankCache.get(key);
+  if (cached) return cached;
+  const nBins = getNumBins(config);
+  const kernels = new Array(nBins);
+  for (let k = 0; k < nBins; k++) {
+    kernels[k] = createCqtKernel(k, config, fftSize, sampleRate);
+  }
+  const bank = {
+    config,
+    fftSize,
+    sampleRate,
+    kernels
+  };
+  kernelBankCache.set(key, bank);
+  return bank;
+}
+function applyCqtKernels(stftMagnitudes, kernelBank) {
+  const nCqtBins = kernelBank.kernels.length;
+  const cqtMagnitudes = new Float32Array(nCqtBins);
+  for (let k = 0; k < nCqtBins; k++) {
+    const kernel = kernelBank.kernels[k];
+    if (!kernel) continue;
+    let sum = 0;
+    for (let i = 0; i < kernel.weights.length; i++) {
+      const stftBin = kernel.startBin + i;
+      const stftMag = stftMagnitudes[stftBin] ?? 0;
+      const weight = kernel.weights[i] ?? 0;
+      sum += stftMag * weight;
+    }
+    cqtMagnitudes[k] = sum;
+  }
+  return cqtMagnitudes;
+}
+function withCqtDefaults(partial) {
+  return {
+    binsPerOctave: partial?.binsPerOctave ?? CQT_DEFAULTS.binsPerOctave,
+    fMin: partial?.fMin ?? CQT_DEFAULTS.fMin,
+    fMax: partial?.fMax ?? CQT_DEFAULTS.fMax,
+    hopSize: partial?.hopSize
+  };
+}
+async function cqtSpectrogram(audio, config, options = {}) {
+  const sampleRate = audio.sampleRate;
+  if (config.fMin <= 0) {
+    throw new Error("@octoseq/mir: CQT fMin must be positive");
+  }
+  if (config.fMax <= config.fMin) {
+    throw new Error("@octoseq/mir: CQT fMax must be greater than fMin");
+  }
+  if (config.binsPerOctave <= 0) {
+    throw new Error("@octoseq/mir: CQT binsPerOctave must be positive");
+  }
+  const Q = 1 / (Math.pow(2, 1 / config.binsPerOctave) - 1);
+  const minFreqResolution = config.fMin / Q / 2;
+  const minFftSize = Math.ceil(sampleRate / minFreqResolution);
+  let fftSize = 1;
+  while (fftSize < minFftSize) {
+    fftSize *= 2;
+  }
+  fftSize = Math.min(fftSize, 16384);
+  const hopSize = config.hopSize ?? Math.floor(fftSize / 4);
+  const stft = await spectrogram(
+    audio,
+    { fftSize, hopSize, window: "hann" },
+    void 0,
+    { isCancelled: options.isCancelled }
+  );
+  const kernelBank = getCqtKernelBank(config, fftSize, sampleRate);
+  const nFrames = stft.magnitudes.length;
+  const cqtMagnitudes = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const stftFrame = stft.magnitudes[frame];
+    if (!stftFrame) continue;
+    cqtMagnitudes[frame] = applyCqtKernels(stftFrame, kernelBank);
+  }
+  const nOctaves = getNumOctaves(config);
+  getNumBins(config);
+  return {
+    sampleRate,
+    config,
+    times: stft.times,
+    magnitudes: cqtMagnitudes,
+    nOctaves,
+    binsPerOctave: config.binsPerOctave,
+    binFrequencies: getCqtBinFrequencies(config)
+  };
+}
+async function computeCqt(audio, config, options = {}) {
+  const startTime = performance.now();
+  const fullConfig = withCqtDefaults(config);
+  const cqt = await cqtSpectrogram(audio, fullConfig, options);
+  const endTime = performance.now();
+  return {
+    cqt,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+
+// src/dsp/cqtSignals.ts
+var BASS_MIN_HZ = 20;
+var BASS_MAX_HZ = 300;
+var TONAL_STABILITY_WINDOW_FRAMES = 20;
+var CHROMA_BINS = 12;
+function normalizeMinMax(values) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min;
+  const result = new Float32Array(values.length);
+  if (range > 0) {
+    for (let i = 0; i < values.length; i++) {
+      result[i] = ((values[i] ?? 0) - min) / range;
+    }
+  } else {
+    result.fill(0.5);
+  }
+  return result;
+}
+function weightedCentroid(values, startIndex = 0) {
+  let sumWeighted = 0;
+  let sumWeights = 0;
+  for (let i = 0; i < values.length; i++) {
+    const weight = values[i] ?? 0;
+    sumWeighted += (startIndex + i) * weight;
+    sumWeights += weight;
+  }
+  return sumWeights > 0 ? sumWeighted / sumWeights : startIndex + values.length / 2;
+}
+function computeHarmonicEnergyFrame(frame, cqt) {
+  if (frame.length === 0) return 0;
+  let totalEnergy = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    totalEnergy += mag * mag;
+  }
+  if (totalEnergy === 0) return 0;
+  let maxMag = 0;
+  let fundamentalBin = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const mag = frame[i] ?? 0;
+    if (mag > maxMag) {
+      maxMag = mag;
+      fundamentalBin = i;
+    }
+  }
+  const fundamentalFreq = cqtBinToHz(fundamentalBin, cqt.config);
+  let harmonicEnergy2 = 0;
+  const numHarmonics = 6;
+  for (let h = 1; h <= numHarmonics; h++) {
+    const harmonicFreq = fundamentalFreq * h;
+    const harmonicBin = Math.round(hzToCqtBin(harmonicFreq, cqt.config));
+    if (harmonicBin >= 0 && harmonicBin < frame.length) {
+      const mag = frame[harmonicBin] ?? 0;
+      const weight = 1 / h;
+      harmonicEnergy2 += mag * mag * weight;
+    }
+  }
+  let weightSum = 0;
+  for (let h = 1; h <= numHarmonics; h++) {
+    weightSum += 1 / h;
+  }
+  harmonicEnergy2 /= weightSum;
+  return Math.min(1, harmonicEnergy2 / totalEnergy);
+}
+function harmonicEnergy(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const values = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      values[frame] = computeHarmonicEnergyFrame(cqtFrame, cqt);
+    }
+  }
+  const normalized = normalizeMinMax(values);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "harmonicEnergy",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function bassPitchMotion(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const bassStartBin = Math.max(0, Math.floor(hzToCqtBin(BASS_MIN_HZ, cqt.config)));
+  const bassEndBin = Math.min(
+    cqt.magnitudes[0]?.length ?? 0,
+    Math.ceil(hzToCqtBin(BASS_MAX_HZ, cqt.config))
+  );
+  const bassNumBins = bassEndBin - bassStartBin;
+  if (bassNumBins <= 0) {
+    return {
+      kind: "cqt1d",
+      signalId: "bassPitchMotion",
+      times: cqt.times,
+      values: new Float32Array(nFrames),
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: { totalMs: 0, cpuMs: 0 }
+      }
+    };
+  }
+  const centroids = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (!cqtFrame) continue;
+    const bassBins = new Float32Array(bassNumBins);
+    for (let i = 0; i < bassNumBins; i++) {
+      bassBins[i] = cqtFrame[bassStartBin + i] ?? 0;
+    }
+    centroids[frame] = weightedCentroid(bassBins, bassStartBin);
+  }
+  const motion = new Float32Array(nFrames);
+  for (let frame = 1; frame < nFrames; frame++) {
+    motion[frame] = Math.abs((centroids[frame] ?? 0) - (centroids[frame - 1] ?? 0));
+  }
+  motion[0] = motion[1] ?? 0;
+  const normalized = normalizeMinMax(motion);
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "bassPitchMotion",
+    times: cqt.times,
+    values: normalized,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeChroma(frame, binsPerOctave) {
+  const chroma = new Float32Array(CHROMA_BINS);
+  const binsPerSemitone = binsPerOctave / CHROMA_BINS;
+  for (let i = 0; i < frame.length; i++) {
+    const chromaBin = Math.floor(i % binsPerOctave / binsPerSemitone) % CHROMA_BINS;
+    const mag = frame[i] ?? 0;
+    chroma[chromaBin] = (chroma[chromaBin] ?? 0) + mag * mag;
+  }
+  let sum = 0;
+  for (let i = 0; i < CHROMA_BINS; i++) {
+    sum += chroma[i] ?? 0;
+  }
+  if (sum > 0) {
+    for (let i = 0; i < CHROMA_BINS; i++) {
+      chroma[i] = (chroma[i] ?? 0) / sum;
+    }
+  }
+  return chroma;
+}
+function tonalStability(cqt) {
+  const startTime = performance.now();
+  const nFrames = cqt.magnitudes.length;
+  const chromas = new Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const cqtFrame = cqt.magnitudes[frame];
+    if (cqtFrame) {
+      chromas[frame] = computeChroma(cqtFrame, cqt.binsPerOctave);
+    } else {
+      chromas[frame] = new Float32Array(CHROMA_BINS);
+    }
+  }
+  const halfWindow = Math.floor(TONAL_STABILITY_WINDOW_FRAMES / 2);
+  const instability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const windowStart = Math.max(0, frame - halfWindow);
+    const windowEnd = Math.min(nFrames, frame + halfWindow + 1);
+    const windowSize = windowEnd - windowStart;
+    const avgChroma = new Float32Array(CHROMA_BINS);
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          avgChroma[c] = (avgChroma[c] ?? 0) + (chroma[c] ?? 0);
+        }
+      }
+    }
+    for (let c = 0; c < CHROMA_BINS; c++) {
+      avgChroma[c] = (avgChroma[c] ?? 0) / windowSize;
+    }
+    let totalVariance = 0;
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          const diff = (chroma[c] ?? 0) - (avgChroma[c] ?? 0);
+          totalVariance += diff * diff;
+        }
+      }
+    }
+    totalVariance /= windowSize * CHROMA_BINS;
+    instability[frame] = totalVariance;
+  }
+  const normalizedInstability = normalizeMinMax(instability);
+  const stability = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    stability[frame] = 1 - (normalizedInstability[frame] ?? 0);
+  }
+  const endTime = performance.now();
+  return {
+    kind: "cqt1d",
+    signalId: "tonalStability",
+    times: cqt.times,
+    values: stability,
+    meta: {
+      backend: "cpu",
+      usedGpu: false,
+      timings: {
+        totalMs: endTime - startTime,
+        cpuMs: endTime - startTime
+      }
+    }
+  };
+}
+function computeCqtSignal(cqt, signalId) {
+  switch (signalId) {
+    case "harmonicEnergy":
+      return harmonicEnergy(cqt);
+    case "bassPitchMotion":
+      return bassPitchMotion(cqt);
+    case "tonalStability":
+      return tonalStability(cqt);
+    default:
+      throw new Error(`@octoseq/mir: unknown CQT signal ID: ${signalId}`);
+  }
+}
+function computeAllCqtSignals(cqt) {
+  const results = /* @__PURE__ */ new Map();
+  results.set("harmonicEnergy", harmonicEnergy(cqt));
+  results.set("bassPitchMotion", bassPitchMotion(cqt));
+  results.set("tonalStability", tonalStability(cqt));
+  return results;
+}
+
 // src/runner/runMir.ts
 function nowMs2() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
@@ -1400,6 +2206,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;
@@ -1502,6 +2368,36 @@ async function runMir(audio, request, options = {}) {
       }
     };
   }
+  if (request.fn === "cqtHarmonicEnergy" || request.fn === "cqtBassPitchMotion" || request.fn === "cqtTonalStability") {
+    const cqtStart = nowMs2();
+    const cqtConfig = withCqtDefaults(request.cqt);
+    const cqt = await cqtSpectrogram(asAudioBufferLike(audio), cqtConfig, {
+      isCancelled: options.isCancelled
+    });
+    const cqtEnd = nowMs2();
+    let signal;
+    if (request.fn === "cqtHarmonicEnergy") {
+      signal = harmonicEnergy(cqt);
+    } else if (request.fn === "cqtBassPitchMotion") {
+      signal = bassPitchMotion(cqt);
+    } else {
+      signal = tonalStability(cqt);
+    }
+    const end2 = nowMs2();
+    return {
+      kind: "1d",
+      times: signal.times,
+      values: signal.values,
+      meta: {
+        backend: "cpu",
+        usedGpu: false,
+        timings: {
+          totalMs: end2 - t0,
+          cpuMs: cqtEnd - cqtStart + (end2 - cqtEnd)
+        }
+      }
+    };
+  }
   const { mel, usedGpu, gpuMs, cpuExtraMs } = await computeMel(backend === "gpu");
   const end = nowMs2();
   return {
@@ -1520,6 +2416,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 { CQT_DEFAULTS, bassPitchMotion, beatSalienceFromMel, computeAllCqtSignals, computeCqt, computeCqtSignal, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withCqtDefaults };
+//# sourceMappingURL=chunk-OLIDGECY.js.map
+//# sourceMappingURL=chunk-OLIDGECY.js.map