@octoseq/mir 0.1.0-main.0d2814e

package/dist/chunk-DUWYCAVG.js

@@ -0,0 +1,1525 @@
+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/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 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/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/peakPick.ts
+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 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 } = meanStd(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/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);
+  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/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"
+  };
+  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 === "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)
+        }
+      }
+    };
+  }
+  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 { delta, deltaDelta, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram };
+//# sourceMappingURL=chunk-DUWYCAVG.js.map
+//# sourceMappingURL=chunk-DUWYCAVG.js.map