@octoseq/mir 0.1.0-main.2e286ce

package/dist/index.js

@@ -0,0 +1,1234 @@
+import { peakPick } from './chunk-DUWYCAVG.js';
+export { delta, deltaDelta, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram } from './chunk-DUWYCAVG.js';
+
+// src/gpu/context.ts
+var MirGPU = class _MirGPU {
+  device;
+  queue;
+  constructor(device) {
+    this.device = device;
+    this.queue = device.queue;
+  }
+  static async create() {
+    if (typeof navigator === "undefined") {
+      throw new Error(
+        "@octoseq/mir: WebGPU is only available in the browser (navigator is undefined)."
+      );
+    }
+    const nav = navigator;
+    if (!nav.gpu) {
+      throw new Error(
+        "@octoseq/mir: WebGPU is unavailable (navigator.gpu is missing). Use CPU mode or a WebGPU-capable browser."
+      );
+    }
+    const adapter = await nav.gpu.requestAdapter();
+    if (!adapter) {
+      throw new Error(
+        "@octoseq/mir: Failed to acquire a WebGPU adapter. WebGPU may be disabled or unsupported."
+      );
+    }
+    const device = await adapter.requestDevice();
+    return new _MirGPU(device);
+  }
+};
+
+// src/util/normalise.ts
+function normaliseForWaveform(data, options = {}) {
+  const center = options.center ?? false;
+  const targetMin = options.min ?? (center ? -1 : 0);
+  const targetMax = options.max ?? 1;
+  if (!Number.isFinite(targetMin) || !Number.isFinite(targetMax)) {
+    throw new Error("@octoseq/mir: normaliseForWaveform min/max must be finite");
+  }
+  if (targetMax === targetMin) {
+    throw new Error("@octoseq/mir: normaliseForWaveform max must differ from min");
+  }
+  let srcMin = Infinity;
+  let srcMax = -Infinity;
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i] ?? 0;
+    if (v < srcMin) srcMin = v;
+    if (v > srcMax) srcMax = v;
+  }
+  if (!Number.isFinite(srcMin) || !Number.isFinite(srcMax) || srcMax === srcMin) {
+    const out2 = new Float32Array(data.length);
+    const mid = (targetMin + targetMax) / 2;
+    out2.fill(mid);
+    return out2;
+  }
+  const out = new Float32Array(data.length);
+  const scale = (targetMax - targetMin) / (srcMax - srcMin);
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i] ?? 0;
+    out[i] = targetMin + (v - srcMin) * scale;
+  }
+  return out;
+}
+
+// src/util/display.ts
+function spectrogramToDb(magnitudes2d, options = {}) {
+  const eps = options.epsilon ?? 1e-12;
+  const floorDb = options.floorDb;
+  const out = new Array(magnitudes2d.length);
+  for (let t = 0; t < magnitudes2d.length; t++) {
+    const row = magnitudes2d[t] ?? new Float32Array(0);
+    const dbRow = new Float32Array(row.length);
+    for (let k = 0; k < row.length; k++) {
+      const mag = row[k] ?? 0;
+      const db = 20 * Math.log10(Math.max(eps, mag));
+      dbRow[k] = floorDb !== void 0 ? Math.max(floorDb, db) : db;
+    }
+    out[t] = dbRow;
+  }
+  return out;
+}
+function clampDb(db2d, minDb, maxDb) {
+  const out = new Array(db2d.length);
+  for (let t = 0; t < db2d.length; t++) {
+    const row = db2d[t] ?? new Float32Array(0);
+    const clamped = new Float32Array(row.length);
+    for (let k = 0; k < row.length; k++) {
+      const v = row[k] ?? 0;
+      clamped[k] = v < minDb ? minDb : v > maxDb ? maxDb : v;
+    }
+    out[t] = clamped;
+  }
+  return out;
+}
+
+// src/util/stats.ts
+function minMax(values) {
+  const n = values.length >>> 0;
+  if (n === 0) return { min: Infinity, max: -Infinity };
+  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;
+  }
+  return { min, max };
+}
+
+// src/search/fingerprintV1.ts
+function l2Norm(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i] ?? 0;
+    sum += x * x;
+  }
+  return Math.sqrt(sum);
+}
+function weightedStats(frames, start, endExclusive, dimHint = 0) {
+  const nFrames = Math.max(0, endExclusive - start);
+  const first = frames[start];
+  const dim = first ? first.length : dimHint;
+  const mean = new Float32Array(dim);
+  const variance = new Float32Array(dim);
+  if (nFrames <= 0 || dim <= 0) return { mean, variance };
+  const weights = new Float32Array(nFrames);
+  const normFrames = new Array(nFrames);
+  let totalWeight = 0;
+  for (let i = 0; i < nFrames; i++) {
+    const f = frames[start + i];
+    if (!f) {
+      normFrames[i] = new Float32Array(dim);
+      continue;
+    }
+    const w = l2Norm(f);
+    weights[i] = w;
+    totalWeight += w;
+    const nf = new Float32Array(dim);
+    const d = w > 1e-12 ? w : 1;
+    for (let j = 0; j < dim; j++) nf[j] = f[j] / d;
+    normFrames[i] = nf;
+  }
+  if (totalWeight <= 1e-12) totalWeight = 1;
+  for (let i = 0; i < nFrames; i++) {
+    const w = weights[i];
+    const nf = normFrames[i];
+    if (!w || w <= 0) continue;
+    const scale = w / totalWeight;
+    for (let j = 0; j < dim; j++) {
+      mean[j] += nf[j] * scale;
+    }
+  }
+  for (let i = 0; i < nFrames; i++) {
+    const w = weights[i];
+    const nf = normFrames[i];
+    if (!w || w <= 0) continue;
+    const scale = w / totalWeight;
+    for (let j = 0; j < dim; j++) {
+      const diff = nf[j] - mean[j];
+      variance[j] += diff * diff * scale;
+    }
+  }
+  return { mean, variance };
+}
+function findFrameWindow(times, t0, t1) {
+  let start = 0;
+  while (start < times.length && (times[start] ?? 0) < t0) start++;
+  let end = start;
+  while (end < times.length && (times[end] ?? 0) <= t1) end++;
+  return { startFrame: start, endFrameExclusive: Math.max(start, end) };
+}
+function fingerprintV1(params) {
+  const { t0, t1, mel, onsetEnvelope, mfcc: mfcc2 } = params;
+  const tt0 = Math.min(t0, t1);
+  const tt1 = Math.max(t0, t1);
+  const dur = Math.max(1e-6, tt1 - tt0);
+  const melDimHint = mel.melBands.find((f) => f?.length)?.length ?? 0;
+  const melWindow = findFrameWindow(mel.times, tt0, tt1);
+  const melStats = weightedStats(mel.melBands, melWindow.startFrame, melWindow.endFrameExclusive, melDimHint);
+  let onsetSum = 0;
+  let onsetMax = -Infinity;
+  let onsetN = 0;
+  for (let i = 0; i < onsetEnvelope.times.length; i++) {
+    const t = onsetEnvelope.times[i] ?? 0;
+    if (t < tt0 || t > tt1) continue;
+    const v = onsetEnvelope.values[i] ?? 0;
+    onsetSum += v;
+    onsetN++;
+    if (v > onsetMax) onsetMax = v;
+  }
+  const onsetMean = onsetN > 0 ? onsetSum / onsetN : 0;
+  const onsetMaxSafe = Number.isFinite(onsetMax) ? onsetMax : 0;
+  const peaks = peakPick(onsetEnvelope.times, onsetEnvelope.values, {
+    minIntervalSec: params.peakPick?.minIntervalSec,
+    threshold: params.peakPick?.threshold,
+    adaptive: params.peakPick?.adaptiveFactor ? { method: "meanStd", factor: params.peakPick.adaptiveFactor } : void 0,
+    strict: true
+  });
+  const peaksInWindow = peaks.filter((p) => p.time >= tt0 && p.time <= tt1);
+  const peakDensityHz = peaksInWindow.length / dur;
+  let mfccStats;
+  const mfccDimHint = mfcc2?.values.find((f) => f?.length)?.length ?? 0;
+  if (mfcc2) {
+    const mfccWindow = findFrameWindow(mfcc2.times, tt0, tt1);
+    const mfccFramesSliced = [];
+    for (let i = mfccWindow.startFrame; i < mfccWindow.endFrameExclusive; i++) {
+      const full = mfcc2.values[i] ?? new Float32Array(0);
+      const start = Math.min(1, full.length);
+      const end = Math.min(13, full.length);
+      mfccFramesSliced.push(full.subarray(start, end));
+    }
+    const s = weightedStats(mfccFramesSliced, 0, mfccFramesSliced.length, mfccDimHint ? Math.max(0, mfccDimHint - 1) : 0);
+    mfccStats = { mean: s.mean, variance: s.variance };
+  }
+  return {
+    version: "v1",
+    t0: tt0,
+    t1: tt1,
+    mel: {
+      mean: melStats.mean,
+      variance: melStats.variance
+    },
+    onset: {
+      mean: onsetMean,
+      max: onsetMaxSafe,
+      peakDensityHz
+    },
+    ...mfccStats ? { mfcc: mfccStats } : {}
+  };
+}
+
+// src/search/similarity.ts
+function l2Norm2(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i] ?? 0;
+    sum += x * x;
+  }
+  return Math.sqrt(sum);
+}
+function normaliseL2InPlace(v, eps = 1e-12) {
+  const n = l2Norm2(v);
+  const d = n > eps ? n : 1;
+  for (let i = 0; i < v.length; i++) v[i] = (v[i] ?? 0) / d;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) throw new Error("@octoseq/mir: cosineSimilarity length mismatch");
+  let dot2 = 0;
+  let aa = 0;
+  let bb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    dot2 += x * y;
+    aa += x * x;
+    bb += y * y;
+  }
+  const denom = Math.sqrt(aa) * Math.sqrt(bb);
+  if (denom <= 0) return 0;
+  const cos = dot2 / denom;
+  return Math.max(0, cos);
+}
+function pushScaled(dst, src, scale) {
+  for (let i = 0; i < src.length; i++) dst.push((src[i] ?? 0) * scale);
+}
+function fingerprintToVectorV1(fp, weights = {}) {
+  const wMel = weights.mel ?? 1;
+  const wTrans = weights.transient ?? 1;
+  const wMfcc = weights.mfcc ?? 1;
+  const melBlock = new Float32Array(fp.mel.mean.length + fp.mel.variance.length);
+  melBlock.set(fp.mel.mean, 0);
+  melBlock.set(fp.mel.variance, fp.mel.mean.length);
+  normaliseL2InPlace(melBlock);
+  const transBlock = new Float32Array([fp.onset.mean, fp.onset.max, fp.onset.peakDensityHz]);
+  normaliseL2InPlace(transBlock);
+  let mfccBlock = null;
+  if (fp.mfcc) {
+    mfccBlock = new Float32Array(fp.mfcc.mean.length + fp.mfcc.variance.length);
+    mfccBlock.set(fp.mfcc.mean, 0);
+    mfccBlock.set(fp.mfcc.variance, fp.mfcc.mean.length);
+    normaliseL2InPlace(mfccBlock);
+  }
+  const out = [];
+  pushScaled(out, melBlock, wMel);
+  pushScaled(out, transBlock, wTrans);
+  if (mfccBlock) pushScaled(out, mfccBlock, wMfcc);
+  return new Float32Array(out);
+}
+function similarityFingerprintV1(a, b, weights = {}) {
+  const va = fingerprintToVectorV1(a, weights);
+  const vb = fingerprintToVectorV1(b, weights);
+  return cosineSimilarity(va, vb);
+}
+
+// src/search/searchTrackV1.ts
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function clamp01(x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  return x;
+}
+async function searchTrackV1(params) {
+  const tStart = nowMs();
+  const options = params.options ?? {};
+  const hopSec = Math.max(5e-3, options.hopSec ?? 0.03);
+  const threshold = clamp01(options.threshold ?? 0.75);
+  const qt0 = Math.min(params.queryRegion.t0, params.queryRegion.t1);
+  const qt1 = Math.max(params.queryRegion.t0, params.queryRegion.t1);
+  const windowSec = Math.max(1e-3, qt1 - qt0);
+  const minSpacingSec = Math.max(0, options.minCandidateSpacingSec ?? windowSec * 0.8);
+  const tFp0 = nowMs();
+  const queryFp = fingerprintV1({
+    t0: qt0,
+    t1: qt1,
+    mel: params.mel,
+    onsetEnvelope: params.onsetEnvelope,
+    mfcc: params.mfcc,
+    peakPick: options.queryPeakPick
+  });
+  const fingerprintMs = nowMs() - tFp0;
+  const scanStartMs = nowMs();
+  const trackDuration = Math.max(
+    params.mel.times.length ? params.mel.times[params.mel.times.length - 1] ?? 0 : 0,
+    params.onsetEnvelope.times.length ? params.onsetEnvelope.times[params.onsetEnvelope.times.length - 1] ?? 0 : 0
+  );
+  const nWindows = Math.max(0, Math.floor((trackDuration - windowSec) / hopSec) + 1);
+  const times = new Float32Array(nWindows);
+  const sim = new Float32Array(nWindows);
+  let skippedWindows = 0;
+  let scannedWindows = 0;
+  for (let w = 0; w < nWindows; w++) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const t0 = w * hopSec;
+    const t1 = t0 + windowSec;
+    if (options.skipWindowOverlap) {
+      const s0 = options.skipWindowOverlap.t0;
+      const s1 = options.skipWindowOverlap.t1;
+      const overlaps = t0 < s1 && t1 > s0;
+      if (overlaps) {
+        times[w] = t0;
+        sim[w] = 0;
+        skippedWindows++;
+        continue;
+      }
+    }
+    times[w] = t0;
+    const fp = fingerprintV1({
+      t0,
+      t1,
+      mel: params.mel,
+      onsetEnvelope: params.onsetEnvelope,
+      mfcc: params.mfcc,
+      peakPick: options.queryPeakPick
+    });
+    const score = similarityFingerprintV1(queryFp, fp, options.weights);
+    sim[w] = clamp01(score);
+    scannedWindows++;
+  }
+  const scanMs = nowMs() - scanStartMs;
+  const events = peakPick(times, sim, {
+    threshold,
+    minIntervalSec: minSpacingSec,
+    strict: options.candidatePeakPick?.strict ?? true
+  });
+  const candidates = events.map((e) => {
+    const windowStartSec = e.time;
+    const windowEndSec = windowStartSec + windowSec;
+    return {
+      timeSec: e.time,
+      score: e.strength,
+      windowStartSec,
+      windowEndSec
+    };
+  });
+  const totalMs = nowMs() - tStart;
+  return {
+    times,
+    similarity: sim,
+    candidates,
+    meta: {
+      fingerprintMs,
+      scanMs,
+      totalMs,
+      windowSec,
+      hopSec,
+      skippedWindows,
+      scannedWindows
+    }
+  };
+}
+
+// src/search/featureVectorV1.ts
+function makeFeatureVectorLayoutV1(params) {
+  const melDim = Math.max(0, params.melDim);
+  const mfccDim = Math.max(0, params.mfccDim ?? 0);
+  const includeContrast = params.includeContrast ?? true;
+  let offset = 0;
+  const melMeanFg = { offset, length: melDim };
+  offset += melDim;
+  const melVarianceFg = { offset, length: melDim };
+  offset += melDim;
+  const onsetFg = { offset, length: 3 };
+  offset += 3;
+  const layout = { dim: 0, melMeanFg, melVarianceFg, onsetFg };
+  if (mfccDim > 0) {
+    layout.mfccMeanFg = { offset, length: mfccDim };
+    layout.mfccVarianceFg = { offset: offset + mfccDim, length: mfccDim };
+    offset += mfccDim * 2;
+  }
+  if (includeContrast) {
+    layout.melContrast = { offset, length: melDim };
+    offset += melDim;
+    layout.onsetContrast = { offset, length: 3 };
+    offset += 3;
+    if (mfccDim > 0) {
+      layout.mfccMeanContrast = { offset, length: mfccDim };
+      layout.mfccVarianceContrast = { offset: offset + mfccDim, length: mfccDim };
+      offset += mfccDim * 2;
+    }
+  }
+  layout.dim = offset;
+  return layout;
+}
+
+// src/search/refinedModelV1.ts
+function clamp012(x) {
+  return x <= 0 ? 0 : x >= 1 ? 1 : x;
+}
+function sigmoid(x) {
+  const z = x > 20 ? 20 : x < -20 ? -20 : x;
+  return 1 / (1 + Math.exp(-z));
+}
+function dot(a, b) {
+  const n = Math.min(a.length, b.length);
+  let s = 0;
+  for (let i = 0; i < n; i++) s += (a[i] ?? 0) * (b[i] ?? 0);
+  return s;
+}
+function sliceDot(w, x, offset, length) {
+  const end = Math.min(w.length, x.length, offset + length);
+  let sum = 0;
+  for (let i = offset; i < end; i++) sum += (w[i] ?? 0) * (x[i] ?? 0);
+  return sum;
+}
+function logitContributionsByGroupV1(w, b, x, layout) {
+  const melForeground = sliceDot(w, x, layout.melMeanFg.offset, layout.melMeanFg.length) + sliceDot(w, x, layout.melVarianceFg.offset, layout.melVarianceFg.length);
+  const melContrast = layout.melContrast ? sliceDot(w, x, layout.melContrast.offset, layout.melContrast.length) : 0;
+  const onsetForeground = sliceDot(w, x, layout.onsetFg.offset, layout.onsetFg.length);
+  const onsetContrast = layout.onsetContrast ? sliceDot(w, x, layout.onsetContrast.offset, layout.onsetContrast.length) : 0;
+  const mfccForeground = layout.mfccMeanFg && layout.mfccVarianceFg ? sliceDot(w, x, layout.mfccMeanFg.offset, layout.mfccMeanFg.length) + sliceDot(w, x, layout.mfccVarianceFg.offset, layout.mfccVarianceFg.length) : 0;
+  const mfccContrast = layout.mfccMeanContrast && layout.mfccVarianceContrast ? sliceDot(w, x, layout.mfccMeanContrast.offset, layout.mfccMeanContrast.length) + sliceDot(w, x, layout.mfccVarianceContrast.offset, layout.mfccVarianceContrast.length) : 0;
+  const mel = melForeground + melContrast;
+  const onset = onsetForeground + onsetContrast;
+  const mfcc2 = mfccForeground + mfccContrast;
+  const logit = mel + onset + mfcc2 + b;
+  return {
+    logit,
+    bias: b,
+    mel,
+    melForeground,
+    ...layout.melContrast ? { melContrast } : {},
+    onset,
+    onsetForeground,
+    ...layout.onsetContrast ? { onsetContrast } : {},
+    ...layout.mfccMeanFg || layout.mfccMeanContrast ? {
+      mfcc: mfcc2,
+      mfccForeground,
+      ...layout.mfccMeanContrast ? { mfccContrast } : {}
+    } : {}
+  };
+}
+function l2Norm3(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i] ?? 0;
+    sum += x * x;
+  }
+  return Math.sqrt(sum);
+}
+function cosineSimilarity01(a, b) {
+  const n = Math.min(a.length, b.length);
+  let ab = 0;
+  let aa = 0;
+  let bb = 0;
+  for (let i = 0; i < n; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    ab += x * y;
+    aa += x * x;
+    bb += y * y;
+  }
+  const denom = Math.sqrt(aa) * Math.sqrt(bb);
+  if (denom <= 0) return 0;
+  const cos = ab / denom;
+  const clamped = Math.max(-1, Math.min(1, cos));
+  return (clamped + 1) / 2;
+}
+function sliceSumSquares(w, offset, length) {
+  let sum = 0;
+  const end = Math.min(w.length, offset + length);
+  for (let i = offset; i < end; i++) {
+    const x = w[i] ?? 0;
+    sum += x * x;
+  }
+  return sum;
+}
+function summariseWeightL2ByGroup(w, layout) {
+  const melForegroundSq = sliceSumSquares(w, layout.melMeanFg.offset, layout.melMeanFg.length) + sliceSumSquares(w, layout.melVarianceFg.offset, layout.melVarianceFg.length);
+  const melContrastSq = layout.melContrast ? sliceSumSquares(w, layout.melContrast.offset, layout.melContrast.length) : 0;
+  const onsetForegroundSq = sliceSumSquares(w, layout.onsetFg.offset, layout.onsetFg.length);
+  const onsetContrastSq = layout.onsetContrast ? sliceSumSquares(w, layout.onsetContrast.offset, layout.onsetContrast.length) : 0;
+  const mfccForegroundSq = layout.mfccMeanFg && layout.mfccVarianceFg ? sliceSumSquares(w, layout.mfccMeanFg.offset, layout.mfccMeanFg.length) + sliceSumSquares(w, layout.mfccVarianceFg.offset, layout.mfccVarianceFg.length) : 0;
+  const mfccContrastSq = layout.mfccMeanContrast && layout.mfccVarianceContrast ? sliceSumSquares(w, layout.mfccMeanContrast.offset, layout.mfccMeanContrast.length) + sliceSumSquares(w, layout.mfccVarianceContrast.offset, layout.mfccVarianceContrast.length) : 0;
+  const mel = Math.sqrt(melForegroundSq + melContrastSq);
+  const onset = Math.sqrt(onsetForegroundSq + onsetContrastSq);
+  const mfcc2 = mfccForegroundSq + mfccContrastSq > 0 ? Math.sqrt(mfccForegroundSq + mfccContrastSq) : void 0;
+  return {
+    mel,
+    melForeground: Math.sqrt(melForegroundSq),
+    ...melContrastSq > 0 ? { melContrast: Math.sqrt(melContrastSq) } : {},
+    onset,
+    onsetForeground: Math.sqrt(onsetForegroundSq),
+    ...onsetContrastSq > 0 ? { onsetContrast: Math.sqrt(onsetContrastSq) } : {},
+    ...mfcc2 != null ? {
+      mfcc: mfcc2,
+      mfccForeground: Math.sqrt(mfccForegroundSq),
+      ...mfccContrastSq > 0 ? { mfccContrast: Math.sqrt(mfccContrastSq) } : {}
+    } : {}
+  };
+}
+function trainLogisticModelV1(params) {
+  const pos = params.positives;
+  const neg = params.negatives;
+  const dim = params.layout.dim;
+  const iterations = Math.max(1, params.options?.iterations ?? 80);
+  const learningRate = Math.max(1e-4, params.options?.learningRate ?? 0.15);
+  const l2 = Math.max(0, params.options?.l2 ?? 0.01);
+  const w = new Float32Array(dim);
+  let b = 0;
+  const posW = pos.length > 0 ? 0.5 / pos.length : 0;
+  const negW = neg.length > 0 ? 0.5 / neg.length : 0;
+  let lastLoss = Infinity;
+  let itersUsed = 0;
+  for (let iter = 0; iter < iterations; iter++) {
+    itersUsed = iter + 1;
+    const gradW = new Float32Array(dim);
+    let gradB = 0;
+    let loss = 0;
+    const accumulate = (x, y, weight) => {
+      const s = dot(w, x) + b;
+      const p = sigmoid(s);
+      const err = p - y;
+      gradB += weight * err;
+      for (let j = 0; j < dim; j++) gradW[j] = (gradW[j] ?? 0) + weight * err * (x[j] ?? 0);
+      const pSafe = Math.min(1 - 1e-9, Math.max(1e-9, p));
+      loss += weight * (y ? -Math.log(pSafe) : -Math.log(1 - pSafe));
+    };
+    for (const x of pos) accumulate(x, 1, posW);
+    for (const x of neg) accumulate(x, 0, negW);
+    if (l2 > 0) {
+      for (let j = 0; j < dim; j++) {
+        gradW[j] = (gradW[j] ?? 0) + l2 * (w[j] ?? 0);
+      }
+      loss += l2 * l2Norm3(w) ** 2 / 2;
+    }
+    const lr = learningRate / (1 + iter * 0.01);
+    for (let j = 0; j < dim; j++) w[j] = (w[j] ?? 0) - lr * (gradW[j] ?? 0);
+    b -= lr * gradB;
+    if (Math.abs(lastLoss - loss) < 1e-6) break;
+    lastLoss = loss;
+  }
+  return {
+    kind: "logistic",
+    w,
+    b,
+    explain: {
+      kind: "logistic",
+      positives: pos.length,
+      negatives: neg.length,
+      weightL2: summariseWeightL2ByGroup(w, params.layout),
+      training: { iterations: itersUsed, finalLoss: Number.isFinite(lastLoss) ? lastLoss : 0 }
+    }
+  };
+}
+function buildPrototypeModelV1(params) {
+  const dim = params.layout.dim;
+  const proto = new Float32Array(dim);
+  const n = Math.max(1, params.positives.length);
+  for (const x of params.positives) {
+    for (let j = 0; j < dim; j++) proto[j] = (proto[j] ?? 0) + (x[j] ?? 0) / n;
+  }
+  return {
+    kind: "prototype",
+    prototype: proto,
+    explain: {
+      kind: "prototype",
+      positives: params.positives.length,
+      negatives: 0
+    }
+  };
+}
+function scoreWithModelV1(model, x) {
+  if (model.kind === "baseline") return 0;
+  if (model.kind === "prototype") return clamp012(cosineSimilarity01(model.prototype, x));
+  return clamp012(sigmoid(dot(model.w, x) + model.b));
+}
+
+// src/search/searchTrackV1Guided.ts
+function nowMs2() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function clamp013(x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  return x;
+}
+function zScoreInPlace(out, mean, invStd) {
+  const n = Math.min(out.length, mean.length, invStd.length);
+  for (let j = 0; j < n; j++) out[j] = ((out[j] ?? 0) - (mean[j] ?? 0)) * (invStd[j] ?? 1);
+}
+function decideModelKind(params) {
+  if (!params.enabled) return { kind: "baseline", positives: [], negatives: [] };
+  const positives = params.labels.filter((l) => l.status === "accepted");
+  const negatives = params.labels.filter((l) => l.status === "rejected");
+  if (positives.length < 2) return { kind: "baseline", positives, negatives };
+  if (negatives.length === 0) return { kind: "prototype", positives, negatives };
+  return { kind: "logistic", positives, negatives };
+}
+function advanceStartIndex(times, start, t0) {
+  let i = start;
+  while (i < times.length && (times[i] ?? 0) < t0) i++;
+  return i;
+}
+function advanceEndIndex(times, endExclusive, t1) {
+  let i = endExclusive;
+  while (i < times.length && (times[i] ?? 0) <= t1) i++;
+  return i;
+}
+function cosineSimilarity01ByBlocks(query, window, layout, weights) {
+  const wMel = weights?.mel ?? 1;
+  const wTrans = weights?.transient ?? 1;
+  const wMfcc = weights?.mfcc ?? 1;
+  const addBlock = (offset, length, weight, acc2) => {
+    if (length <= 0 || weight === 0) return;
+    const ww = weight * weight;
+    const eps = 1e-12;
+    let dotRaw = 0;
+    let qSumSq = 0;
+    let xSumSq = 0;
+    const end = Math.min(query.length, window.length, offset + length);
+    for (let i = offset; i < end; i++) {
+      const q = query[i] ?? 0;
+      const x = window[i] ?? 0;
+      dotRaw += q * x;
+      qSumSq += q * q;
+      xSumSq += x * x;
+    }
+    const qNorm = Math.sqrt(qSumSq);
+    const xNorm = Math.sqrt(xSumSq);
+    if (qNorm > eps) acc2.aa += ww;
+    if (xNorm > eps) acc2.bb += ww;
+    if (!(qNorm > eps && xNorm > eps)) return;
+    acc2.dot += ww * (dotRaw / (qNorm * xNorm));
+  };
+  const acc = { dot: 0, aa: 0, bb: 0 };
+  addBlock(layout.melMeanFg.offset, layout.melMeanFg.length + layout.melVarianceFg.length, wMel, acc);
+  addBlock(layout.onsetFg.offset, layout.onsetFg.length, wTrans, acc);
+  if (layout.mfccMeanFg && layout.mfccVarianceFg) {
+    addBlock(layout.mfccMeanFg.offset, layout.mfccMeanFg.length + layout.mfccVarianceFg.length, wMfcc, acc);
+  }
+  if (layout.melContrast) addBlock(layout.melContrast.offset, layout.melContrast.length, wMel, acc);
+  if (layout.onsetContrast) addBlock(layout.onsetContrast.offset, layout.onsetContrast.length, wTrans, acc);
+  if (layout.mfccMeanContrast && layout.mfccVarianceContrast) {
+    addBlock(layout.mfccMeanContrast.offset, layout.mfccMeanContrast.length + layout.mfccVarianceContrast.length, wMfcc, acc);
+  }
+  const denom = Math.sqrt(acc.aa) * Math.sqrt(acc.bb);
+  if (denom <= 0) return 0;
+  const cos = acc.dot / denom;
+  const clamped = Math.max(-1, Math.min(1, cos));
+  return (clamped + 1) / 2;
+}
+function buildSparseTableMax(values, isCancelled) {
+  const n = values.length;
+  const log = new Uint8Array(n + 1);
+  for (let i = 2; i <= n; i++) log[i] = (log[i >>> 1] ?? 0) + 1;
+  const maxK = log[n] ?? 0;
+  const table = [];
+  table[0] = values;
+  for (let k = 1; k <= maxK; k++) {
+    const span = 1 << k;
+    const half = span >>> 1;
+    const prev = table[k - 1];
+    const len = Math.max(0, n - span + 1);
+    const cur = new Float32Array(len);
+    for (let i = 0; i < len; i++) {
+      if ((i & 2047) === 0 && isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+      const a = prev[i] ?? 0;
+      const b = prev[i + half] ?? 0;
+      cur[i] = a > b ? a : b;
+    }
+    table[k] = cur;
+  }
+  return {
+    query: (start, endExclusive) => {
+      const l = Math.max(0, start | 0);
+      const r = Math.min(n, endExclusive | 0);
+      const len = r - l;
+      if (len <= 0) return -Infinity;
+      const k = log[len] ?? 0;
+      const span = 1 << k;
+      const row = table[k];
+      const a = row[l] ?? -Infinity;
+      const b = row[r - span] ?? -Infinity;
+      return a > b ? a : b;
+    }
+  };
+}
+function computeBackgroundWindow(params) {
+  const fgStartSec = Math.min(params.fgStartSec, params.fgEndSec);
+  const fgEndSec = Math.max(params.fgStartSec, params.fgEndSec);
+  const fgDur = Math.max(1e-6, fgEndSec - fgStartSec);
+  const desired = Math.max(fgDur, fgDur * Math.max(1, params.backgroundScale));
+  const maxDur = Math.max(fgDur, params.trackDurationSec);
+  const dur = Math.min(desired, maxDur);
+  const center = (fgStartSec + fgEndSec) / 2;
+  let bgStart = center - dur / 2;
+  let bgEnd = bgStart + dur;
+  if (bgStart < 0) {
+    bgStart = 0;
+    bgEnd = Math.min(params.trackDurationSec, dur);
+  }
+  if (bgEnd > params.trackDurationSec) {
+    bgEnd = params.trackDurationSec;
+    bgStart = Math.max(0, bgEnd - dur);
+  }
+  bgStart = Math.min(bgStart, fgStartSec);
+  bgEnd = Math.max(bgEnd, fgEndSec);
+  return { bgStartSec: bgStart, bgEndSec: bgEnd };
+}
+var SlidingMoments = class {
+  constructor(dim, addFrame, removeFrame) {
+    this.dim = dim;
+    this.addFrame = addFrame;
+    this.removeFrame = removeFrame;
+    this.sum = new Float64Array(dim);
+    this.sumSq = new Float64Array(dim);
+  }
+  start = 0;
+  end = 0;
+  sum;
+  sumSq;
+  update(newStart, newEnd) {
+    const s = Math.max(0, newStart | 0);
+    const e = Math.max(s, newEnd | 0);
+    while (this.end < e) {
+      this.addFrame(this.end, this.sum, this.sumSq);
+      this.end++;
+    }
+    while (this.start < s) {
+      this.removeFrame(this.start, this.sum, this.sumSq);
+      this.start++;
+    }
+    if (this.start > s || this.end > e) {
+      this.sum.fill(0);
+      this.sumSq.fill(0);
+      this.start = s;
+      this.end = s;
+      while (this.end < e) {
+        this.addFrame(this.end, this.sum, this.sumSq);
+        this.end++;
+      }
+    }
+  }
+};
+async function searchTrackV1Guided(params) {
+  const tStart = nowMs2();
+  const options = params.options ?? {};
+  const hopSec = Math.max(5e-3, options.hopSec ?? 0.03);
+  const threshold = clamp013(options.threshold ?? 0.75);
+  const localContrastEnabled = options.localContrast?.enabled ?? true;
+  const backgroundScale = Math.max(1, options.localContrast?.backgroundScale ?? 3);
+  const qt0 = Math.min(params.queryRegion.t0, params.queryRegion.t1);
+  const qt1 = Math.max(params.queryRegion.t0, params.queryRegion.t1);
+  const windowSec = Math.max(1e-3, qt1 - qt0);
+  const minSpacingSec = Math.max(0, options.minCandidateSpacingSec ?? windowSec * 0.8);
+  const refinementEnabled = !!options.refinement?.enabled;
+  const refinementLabels = options.refinement?.labels ?? [];
+  const includeQueryAsPositive = options.refinement?.includeQueryAsPositive ?? true;
+  const modelDecision = decideModelKind({ enabled: refinementEnabled, labels: refinementLabels });
+  const baselineExplain = refinementEnabled ? {
+    kind: "baseline",
+    positives: modelDecision.positives.length,
+    negatives: modelDecision.negatives.length
+  } : { kind: "baseline", positives: 0, negatives: 0 };
+  const tPrep0 = nowMs2();
+  const timesFrames = params.mel.times;
+  const nFrames = timesFrames.length;
+  const trackDuration = Math.max(
+    nFrames ? timesFrames[nFrames - 1] ?? 0 : 0,
+    params.onsetEnvelope.times.length ? params.onsetEnvelope.times[params.onsetEnvelope.times.length - 1] ?? 0 : 0
+  );
+  const nWindows = Math.max(0, Math.floor((trackDuration - windowSec) / hopSec) + 1);
+  const times = new Float32Array(nWindows);
+  const scores = new Float32Array(nWindows);
+  if (nWindows === 0) {
+    const totalMs2 = nowMs2() - tStart;
+    return {
+      times,
+      scores,
+      candidates: [],
+      curveKind: "similarity",
+      model: baselineExplain,
+      meta: {
+        fingerprintMs: 0,
+        scanMs: 0,
+        modelMs: 0,
+        totalMs: totalMs2,
+        windowSec,
+        hopSec,
+        skippedWindows: 0,
+        scannedWindows: 0
+      }
+    };
+  }
+  const skipOverlap = options.skipWindowOverlap;
+  const shouldSkip = (t0, t1) => {
+    if (!skipOverlap) return false;
+    const s0 = skipOverlap.t0;
+    const s1 = skipOverlap.t1;
+    return t0 < s1 && t1 > s0;
+  };
+  const melDim = params.mel.melBands[0]?.length ?? 0;
+  const mfccFullDim = params.mfcc?.values[0]?.length ?? 0;
+  const mfccDim = Math.max(0, Math.min(12, mfccFullDim - 1));
+  const layout = makeFeatureVectorLayoutV1({ melDim, mfccDim, includeContrast: localContrastEnabled });
+  const melScale = new Float32Array(nFrames);
+  const melBands = params.mel.melBands;
+  for (let t = 0; t < nFrames; t++) {
+    if ((t & 2047) === 0 && options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    const row = melBands[t];
+    if (!row) {
+      melScale[t] = 1;
+      continue;
+    }
+    let sumSq = 0;
+    for (let i = 0; i < melDim; i++) {
+      const x = row[i] ?? 0;
+      sumSq += x * x;
+    }
+    const n = Math.sqrt(sumSq);
+    melScale[t] = n > 1e-12 ? 1 / n : 1;
+  }
+  const mfccScale = mfccDim > 0 ? new Float32Array(nFrames) : null;
+  const mfccFrames = params.mfcc?.values ?? null;
+  if (mfccScale && mfccFrames) {
+    for (let t = 0; t < nFrames; t++) {
+      if ((t & 2047) === 0 && options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+      const row = mfccFrames[t];
+      if (!row) {
+        mfccScale[t] = 1;
+        continue;
+      }
+      let sumSq = 0;
+      for (let i = 0; i < mfccDim; i++) {
+        const x = row[i + 1] ?? 0;
+        sumSq += x * x;
+      }
+      const n = Math.sqrt(sumSq);
+      mfccScale[t] = n > 1e-12 ? 1 / n : 1;
+    }
+  }
+  const onsetValues = new Float32Array(nFrames);
+  const onsetSrc = params.onsetEnvelope.values;
+  for (let i = 0; i < nFrames; i++) onsetValues[i] = onsetSrc[i] ?? 0;
+  const onsetPrefix = new Float64Array(nFrames + 1);
+  onsetPrefix[0] = 0;
+  for (let i = 0; i < nFrames; i++) {
+    if ((i & 4095) === 0 && options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+    onsetPrefix[i + 1] = (onsetPrefix[i] ?? 0) + (onsetValues[i] ?? 0);
+  }
+  const onsetMax = buildSparseTableMax(onsetValues, options.isCancelled);
+  const onsetPeaks = peakPick(timesFrames, onsetValues, {
+    minIntervalSec: options.queryPeakPick?.minIntervalSec,
+    threshold: options.queryPeakPick?.threshold,
+    adaptive: options.queryPeakPick?.adaptiveFactor ? { method: "meanStd", factor: options.queryPeakPick.adaptiveFactor } : void 0,
+    strict: true
+  });
+  const isPeak = new Uint8Array(nFrames);
+  for (const p of onsetPeaks) {
+    const idx = p.index | 0;
+    if (idx >= 0 && idx < nFrames) isPeak[idx] = 1;
+  }
+  const peakPrefix = new Uint32Array(nFrames + 1);
+  for (let i = 0; i < nFrames; i++) peakPrefix[i + 1] = (peakPrefix[i] ?? 0) + (isPeak[i] ?? 0);
+  const fingerprintMs = nowMs2() - tPrep0;
+  const addMelFrame = (frame, sum, sumSq) => {
+    const row = melBands[frame];
+    const s = melScale[frame] ?? 1;
+    for (let i = 0; i < melDim; i++) {
+      const x = (row?.[i] ?? 0) * s;
+      sum[i] = (sum[i] ?? 0) + x;
+      sumSq[i] = (sumSq[i] ?? 0) + x * x;
+    }
+  };
+  const removeMelFrame = (frame, sum, sumSq) => {
+    const row = melBands[frame];
+    const s = melScale[frame] ?? 1;
+    for (let i = 0; i < melDim; i++) {
+      const x = (row?.[i] ?? 0) * s;
+      sum[i] = (sum[i] ?? 0) - x;
+      sumSq[i] = (sumSq[i] ?? 0) - x * x;
+    }
+  };
+  const addMfccFrame = (frame, sum, sumSq) => {
+    const row = mfccFrames?.[frame];
+    const s = mfccScale?.[frame] ?? 1;
+    for (let i = 0; i < mfccDim; i++) {
+      const x = (row?.[i + 1] ?? 0) * s;
+      sum[i] = (sum[i] ?? 0) + x;
+      sumSq[i] = (sumSq[i] ?? 0) + x * x;
+    }
+  };
+  const removeMfccFrame = (frame, sum, sumSq) => {
+    const row = mfccFrames?.[frame];
+    const s = mfccScale?.[frame] ?? 1;
+    for (let i = 0; i < mfccDim; i++) {
+      const x = (row?.[i + 1] ?? 0) * s;
+      sum[i] = (sum[i] ?? 0) - x;
+      sumSq[i] = (sumSq[i] ?? 0) - x * x;
+    }
+  };
+  const melFg = new SlidingMoments(melDim, addMelFrame, removeMelFrame);
+  const melBg = new SlidingMoments(melDim, addMelFrame, removeMelFrame);
+  const mfccFg = mfccDim > 0 ? new SlidingMoments(mfccDim, addMfccFrame, removeMfccFrame) : null;
+  const mfccBg = mfccDim > 0 ? new SlidingMoments(mfccDim, addMfccFrame, removeMfccFrame) : null;
+  const writeVectorFromState = (opts) => {
+    const out = opts.out;
+    out.fill(0);
+    const fgCount = Math.max(0, opts.fgEndIdx - opts.fgStartIdx);
+    const bgCount = Math.max(0, opts.bgEndIdx - opts.bgStartIdx);
+    const bgExCount = Math.max(0, bgCount - fgCount);
+    for (let i = 0; i < melDim; i++) {
+      const sum = melFg.sum[i] ?? 0;
+      const sumSq = melFg.sumSq[i] ?? 0;
+      const mean = fgCount > 0 ? sum / fgCount : 0;
+      const variance = fgCount > 0 ? Math.max(0, sumSq / fgCount - mean * mean) : 0;
+      out[layout.melMeanFg.offset + i] = mean;
+      out[layout.melVarianceFg.offset + i] = variance;
+      if (layout.melContrast) {
+        const bgSum = melBg.sum[i] ?? 0;
+        const bgMeanEx = bgExCount > 0 ? (bgSum - sum) / bgExCount : mean;
+        out[layout.melContrast.offset + i] = mean - bgMeanEx;
+      }
+    }
+    const fgOnsetSum = (onsetPrefix[opts.fgEndIdx] ?? 0) - (onsetPrefix[opts.fgStartIdx] ?? 0);
+    const fgOnsetMean = fgCount > 0 ? fgOnsetSum / fgCount : 0;
+    const fgOnsetMaxRaw = onsetMax.query(opts.fgStartIdx, opts.fgEndIdx);
+    const fgOnsetMax = Number.isFinite(fgOnsetMaxRaw) && fgOnsetMaxRaw !== -Infinity ? fgOnsetMaxRaw : 0;
+    const fgPeaks = (peakPrefix[opts.fgEndIdx] ?? 0) - (peakPrefix[opts.fgStartIdx] ?? 0);
+    const fgDur = Math.max(1e-6, opts.fgEndSec - opts.fgStartSec);
+    const fgPeakDensity = fgPeaks / fgDur;
+    out[layout.onsetFg.offset + 0] = fgOnsetMean;
+    out[layout.onsetFg.offset + 1] = fgOnsetMax;
+    out[layout.onsetFg.offset + 2] = fgPeakDensity;
+    if (layout.onsetContrast) {
+      const bgOnsetSum = (onsetPrefix[opts.bgEndIdx] ?? 0) - (onsetPrefix[opts.bgStartIdx] ?? 0);
+      const bgOnsetMeanEx = bgExCount > 0 ? (bgOnsetSum - fgOnsetSum) / bgExCount : fgOnsetMean;
+      const leftMax = onsetMax.query(opts.bgStartIdx, opts.fgStartIdx);
+      const rightMax = onsetMax.query(opts.fgEndIdx, opts.bgEndIdx);
+      const bgOnsetMaxEx = Math.max(
+        Number.isFinite(leftMax) && leftMax !== -Infinity ? leftMax : -Infinity,
+        Number.isFinite(rightMax) && rightMax !== -Infinity ? rightMax : -Infinity
+      );
+      const bgOnsetMaxExSafe = bgOnsetMaxEx === -Infinity ? fgOnsetMax : bgOnsetMaxEx;
+      const bgPeaks = (peakPrefix[opts.bgEndIdx] ?? 0) - (peakPrefix[opts.bgStartIdx] ?? 0);
+      const bgPeaksEx = Math.max(0, bgPeaks - fgPeaks);
+      const bgExDur = Math.max(1e-6, opts.bgEndSec - opts.bgStartSec - fgDur);
+      const bgPeakDensityEx = bgPeaksEx / bgExDur;
+      out[layout.onsetContrast.offset + 0] = fgOnsetMean - bgOnsetMeanEx;
+      out[layout.onsetContrast.offset + 1] = fgOnsetMax - bgOnsetMaxExSafe;
+      out[layout.onsetContrast.offset + 2] = fgPeakDensity - bgPeakDensityEx;
+    }
+    if (mfccDim > 0 && mfccFg && mfccBg && layout.mfccMeanFg && layout.mfccVarianceFg) {
+      for (let i = 0; i < mfccDim; i++) {
+        const sum = mfccFg.sum[i] ?? 0;
+        const sumSq = mfccFg.sumSq[i] ?? 0;
+        const mean = fgCount > 0 ? sum / fgCount : 0;
+        const variance = fgCount > 0 ? Math.max(0, sumSq / fgCount - mean * mean) : 0;
+        out[layout.mfccMeanFg.offset + i] = mean;
+        out[layout.mfccVarianceFg.offset + i] = variance;
+        if (layout.mfccMeanContrast && layout.mfccVarianceContrast) {
+          const bgSum = mfccBg.sum[i] ?? 0;
+          const bgSumSq = mfccBg.sumSq[i] ?? 0;
+          const bgMeanEx = bgExCount > 0 ? (bgSum - sum) / bgExCount : mean;
+          const bgVarEx = bgExCount > 0 ? Math.max(0, (bgSumSq - sumSq) / bgExCount - bgMeanEx * bgMeanEx) : variance;
+          out[layout.mfccMeanContrast.offset + i] = mean - bgMeanEx;
+          out[layout.mfccVarianceContrast.offset + i] = variance - bgVarEx;
+        }
+      }
+    }
+  };
+  const computeVectorForInterval = (t0, t1, out) => {
+    const fgStartSec = Math.min(t0, t1);
+    const fgEndSec = Math.max(t0, t1);
+    const { bgStartSec, bgEndSec } = computeBackgroundWindow({
+      fgStartSec,
+      fgEndSec,
+      trackDurationSec: trackDuration,
+      backgroundScale
+    });
+    const fgStartIdx = advanceStartIndex(timesFrames, 0, fgStartSec);
+    const fgEndIdx = advanceEndIndex(timesFrames, fgStartIdx, fgEndSec);
+    const bgStartIdx = advanceStartIndex(timesFrames, 0, bgStartSec);
+    const bgEndIdx = advanceEndIndex(timesFrames, bgStartIdx, bgEndSec);
+    melFg.update(fgStartIdx, fgEndIdx);
+    melBg.update(bgStartIdx, bgEndIdx);
+    mfccFg?.update(fgStartIdx, fgEndIdx);
+    mfccBg?.update(bgStartIdx, bgEndIdx);
+    writeVectorFromState({
+      fgStartIdx,
+      fgEndIdx,
+      bgStartIdx,
+      bgEndIdx,
+      fgStartSec,
+      fgEndSec,
+      bgStartSec,
+      bgEndSec,
+      out
+    });
+  };
+  const queryVec = new Float32Array(layout.dim);
+  computeVectorForInterval(qt0, qt1, queryVec);
+  const resetSlidingState = () => {
+    melFg.update(0, 0);
+    melBg.update(0, 0);
+    mfccFg?.update(0, 0);
+    mfccBg?.update(0, 0);
+  };
+  const buildWindowVectorsPass = (onWindow) => {
+    resetSlidingState();
+    let fgStartIdx = 0;
+    let fgEndIdx = 0;
+    let bgStartIdx = 0;
+    let bgEndIdx = 0;
+    const vec = new Float32Array(layout.dim);
+    for (let w = 0; w < nWindows; w++) {
+      if ((w & 255) === 0 && options.isCancelled?.()) throw new Error("@octoseq/mir: cancelled");
+      const t0 = w * hopSec;
+      const t1 = t0 + windowSec;
+      times[w] = t0;
+      fgStartIdx = advanceStartIndex(timesFrames, fgStartIdx, t0);
+      fgEndIdx = advanceEndIndex(timesFrames, fgEndIdx, t1);
+      const { bgStartSec, bgEndSec } = computeBackgroundWindow({
+        fgStartSec: t0,
+        fgEndSec: t1,
+        trackDurationSec: trackDuration,
+        backgroundScale
+      });
+      bgStartIdx = advanceStartIndex(timesFrames, bgStartIdx, bgStartSec);
+      bgEndIdx = advanceEndIndex(timesFrames, bgEndIdx, bgEndSec);
+      melFg.update(fgStartIdx, fgEndIdx);
+      melBg.update(bgStartIdx, bgEndIdx);
+      mfccFg?.update(fgStartIdx, fgEndIdx);
+      mfccBg?.update(bgStartIdx, bgEndIdx);
+      writeVectorFromState({
+        fgStartIdx,
+        fgEndIdx,
+        bgStartIdx,
+        bgEndIdx,
+        fgStartSec: t0,
+        fgEndSec: t1,
+        bgStartSec,
+        bgEndSec,
+        out: vec
+      });
+      onWindow(w, t0, t1, { start: bgStartSec, end: bgEndSec }, vec);
+    }
+  };
+  let skippedWindows = 0;
+  let scannedWindows = 0;
+  const scanStartMs = nowMs2();
+  let curveKind = "similarity";
+  let modelExplain = baselineExplain;
+  let modelMs = 0;
+  let trainedModel = null;
+  let zMean = null;
+  let zInvStd = null;
+  const runBaselineSimilarityScan = () => {
+    skippedWindows = 0;
+    scannedWindows = 0;
+    buildWindowVectorsPass((w, t0, t1, _bg, vec) => {
+      if (shouldSkip(t0, t1)) {
+        scores[w] = 0;
+        skippedWindows++;
+        return;
+      }
+      scannedWindows++;
+      scores[w] = cosineSimilarity01ByBlocks(queryVec, vec, layout, options.weights);
+    });
+  };
+  if (modelDecision.kind === "baseline") {
+    runBaselineSimilarityScan();
+  } else {
+    const tModel0 = nowMs2();
+    curveKind = "confidence";
+    try {
+      const dim = layout.dim;
+      const sum = new Float64Array(dim);
+      const sumSq = new Float64Array(dim);
+      buildWindowVectorsPass((_w, _t0, _t1, _bg, vec) => {
+        for (let j = 0; j < dim; j++) {
+          const x = vec[j] ?? 0;
+          sum[j] = (sum[j] ?? 0) + x;
+          sumSq[j] = (sumSq[j] ?? 0) + x * x;
+        }
+      });
+      const mean = new Float32Array(dim);
+      const invStd = new Float32Array(dim);
+      const n = Math.max(1, nWindows);
+      for (let j = 0; j < dim; j++) {
+        const mu = (sum[j] ?? 0) / n;
+        const ex2 = (sumSq[j] ?? 0) / n;
+        const v = Math.max(0, ex2 - mu * mu);
+        const std = Math.sqrt(v);
+        mean[j] = mu;
+        invStd[j] = std > 1e-6 ? 1 / std : 1;
+      }
+      zMean = mean;
+      zInvStd = invStd;
+      const positives = [];
+      const negatives = [];
+      const makeExample = (t0, t1) => {
+        const v = new Float32Array(dim);
+        computeVectorForInterval(t0, t1, v);
+        zScoreInPlace(v, mean, invStd);
+        return v;
+      };
+      for (const l of modelDecision.positives) positives.push(makeExample(l.t0, l.t1));
+      for (const l of modelDecision.negatives) negatives.push(makeExample(l.t0, l.t1));
+      if (includeQueryAsPositive) {
+        const q = new Float32Array(dim);
+        q.set(queryVec);
+        zScoreInPlace(q, mean, invStd);
+        positives.push(q);
+      }
+      trainedModel = modelDecision.kind === "logistic" ? trainLogisticModelV1({ positives, negatives, layout }) : buildPrototypeModelV1({ positives, layout });
+      modelExplain = trainedModel.explain;
+      skippedWindows = 0;
+      scannedWindows = 0;
+      buildWindowVectorsPass((w, t0, t1, _bg, vec) => {
+        if (shouldSkip(t0, t1)) {
+          scores[w] = 0;
+          skippedWindows++;
+          return;
+        }
+        scannedWindows++;
+        zScoreInPlace(vec, mean, invStd);
+        scores[w] = scoreWithModelV1(trainedModel, vec);
+      });
+    } catch (e) {
+      if (e instanceof Error && e.message === "@octoseq/mir: cancelled") throw e;
+      curveKind = "similarity";
+      modelExplain = baselineExplain;
+      trainedModel = null;
+      zMean = null;
+      zInvStd = null;
+      runBaselineSimilarityScan();
+    } finally {
+      modelMs = nowMs2() - tModel0;
+    }
+  }
+  const scanMs = nowMs2() - scanStartMs;
+  const events = peakPick(times, scores, {
+    threshold,
+    minIntervalSec: minSpacingSec,
+    strict: options.candidatePeakPick?.strict ?? true
+  });
+  const candidates = events.map((e) => {
+    const windowStartSec = e.time;
+    const windowEndSec = windowStartSec + windowSec;
+    return {
+      timeSec: e.time,
+      score: e.strength,
+      windowStartSec,
+      windowEndSec
+    };
+  });
+  if (trainedModel?.kind === "logistic" && zMean && zInvStd) {
+    const tmp = new Float32Array(layout.dim);
+    for (const c of candidates) {
+      tmp.fill(0);
+      computeVectorForInterval(c.windowStartSec, c.windowEndSec, tmp);
+      zScoreInPlace(tmp, zMean, zInvStd);
+      c.explain = {
+        groupLogit: logitContributionsByGroupV1(trainedModel.w, trainedModel.b, tmp, layout)
+      };
+    }
+  }
+  const totalMs = nowMs2() - tStart;
+  return {
+    times,
+    scores,
+    candidates,
+    curveKind,
+    model: modelExplain,
+    meta: {
+      fingerprintMs,
+      scanMs,
+      modelMs,
+      totalMs,
+      windowSec,
+      hopSec,
+      skippedWindows,
+      scannedWindows
+    }
+  };
+}
+
+// src/index.ts
+var MIR_VERSION = "0.1.0";
+function helloMir(name = "world") {
+  return `Hello, ${name} from @octoseq/mir v${MIR_VERSION}`;
+}
+
+export { MIR_VERSION, MirGPU, clampDb, fingerprintToVectorV1, fingerprintV1, helloMir, minMax, normaliseForWaveform, searchTrackV1, searchTrackV1Guided, similarityFingerprintV1, spectrogramToDb };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map