@octoseq/mir 0.1.0-main.994cb4e → 0.1.0-main.9ea6d2e

package/dist/index.js

@@ -1,5 +1,5 @@
-import { withCqtDefaults, cqtSpectrogram, harmonicEnergy, bassPitchMotion, tonalStability, peakPick, cqtBinToHz, getNumBins } from './chunk-OLIDGECY.js';
-export { CQT_DEFAULTS, bassPitchMotion, beatSalienceFromMel, computeAllCqtSignals, computeCqt, computeCqtSignal, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withCqtDefaults } from './chunk-OLIDGECY.js';
+import { peakPick, hzToCqtBin, cqtBinToHz, withCqtDefaults, cqtSpectrogram, harmonicEnergy, bassPitchMotion, tonalStability, getNumBins } from './chunk-CI7QGWP7.js';
+export { CQT_DEFAULTS, amplitudeEnvelope, bassPitchMotion, beatSalienceFromMel, computeAllCqtSignals, computeCqt, computeCqtSignal, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withCqtDefaults } from './chunk-CI7QGWP7.js';
 
 // src/gpu/context.ts
 var MirGPU = class _MirGPU {
@@ -104,6 +104,314 @@ function generateBeatTimes(bpm, phaseOffset, userNudge, audioDuration) {
   return beats;
 }
 
+// src/dsp/peakPicking.ts
+var DEFAULT_PEAK_PICKING_PARAMS = {
+  threshold: 0.3,
+  minDistance: 0.1,
+  preMax: 2,
+  postMax: 2
+};
+function pickPeaks(times, values, params = {}) {
+  const {
+    threshold,
+    minDistance,
+    preMax,
+    postMax
+  } = { ...DEFAULT_PEAK_PICKING_PARAMS, ...params };
+  if (times.length === 0 || values.length === 0) {
+    return {
+      times: new Float32Array(0),
+      strengths: new Float32Array(0)
+    };
+  }
+  let minVal = values[0];
+  let maxVal = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (v < minVal) minVal = v;
+    if (v > maxVal) maxVal = v;
+  }
+  const range = maxVal - minVal;
+  if (range <= 0) {
+    return {
+      times: new Float32Array(0),
+      strengths: new Float32Array(0)
+    };
+  }
+  const normalize = (v) => (v - minVal) / range;
+  const peakIndices = [];
+  const peakStrengths = [];
+  for (let i = preMax; i < values.length - postMax; i++) {
+    const currentVal = values[i];
+    const normalizedVal = normalize(currentVal);
+    if (normalizedVal < threshold) continue;
+    let isMax = true;
+    for (let j = 1; j <= preMax; j++) {
+      if (values[i - j] >= currentVal) {
+        isMax = false;
+        break;
+      }
+    }
+    if (isMax) {
+      for (let j = 1; j <= postMax; j++) {
+        if (values[i + j] > currentVal) {
+          isMax = false;
+          break;
+        }
+      }
+    }
+    if (isMax) {
+      peakIndices.push(i);
+      peakStrengths.push(normalizedVal);
+    }
+  }
+  const filteredIndices = [];
+  const filteredStrengths = [];
+  for (let i = 0; i < peakIndices.length; i++) {
+    const idx = peakIndices[i];
+    const time = times[idx];
+    const strength = peakStrengths[i];
+    let shouldKeep = true;
+    for (let j = 0; j < filteredIndices.length; j++) {
+      const prevIdx = filteredIndices[j];
+      const prevTime = times[prevIdx];
+      const prevStrength = filteredStrengths[j];
+      if (Math.abs(time - prevTime) < minDistance) {
+        if (strength > prevStrength) {
+          filteredIndices[j] = idx;
+          filteredStrengths[j] = strength;
+        }
+        shouldKeep = false;
+        break;
+      }
+    }
+    if (shouldKeep) {
+      filteredIndices.push(idx);
+      filteredStrengths.push(strength);
+    }
+  }
+  const resultTimes = new Float32Array(filteredIndices.length);
+  const resultStrengths = new Float32Array(filteredStrengths.length);
+  for (let i = 0; i < filteredIndices.length; i++) {
+    resultTimes[i] = times[filteredIndices[i]];
+    resultStrengths[i] = filteredStrengths[i];
+  }
+  return {
+    times: resultTimes,
+    strengths: resultStrengths
+  };
+}
+function computeAdaptiveThreshold(values, windowSize = 20, thresholdMultiplier = 1.5) {
+  if (values.length === 0) {
+    return new Float32Array(0);
+  }
+  let minVal = values[0];
+  let maxVal = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (v < minVal) minVal = v;
+    if (v > maxVal) maxVal = v;
+  }
+  const range = maxVal - minVal;
+  if (range <= 0) {
+    return new Float32Array(values.length).fill(0.5);
+  }
+  const halfWindow = Math.floor(windowSize / 2);
+  const thresholdCurve = new Float32Array(values.length);
+  for (let i = 0; i < values.length; i++) {
+    const start = Math.max(0, i - halfWindow);
+    const end = Math.min(values.length, i + halfWindow + 1);
+    const windowLen = end - start;
+    let sum = 0;
+    for (let j = start; j < end; j++) {
+      sum += values[j];
+    }
+    const mean = sum / windowLen;
+    let sumSq = 0;
+    for (let j = start; j < end; j++) {
+      const diff = values[j] - mean;
+      sumSq += diff * diff;
+    }
+    const std = Math.sqrt(sumSq / windowLen);
+    const adaptiveThresh = mean + thresholdMultiplier * std;
+    thresholdCurve[i] = Math.max(0, Math.min(1, (adaptiveThresh - minVal) / range));
+  }
+  return thresholdCurve;
+}
+function pickPeaksAdaptive(times, values, windowSize = 20, params = {}, includeThresholdCurve = false) {
+  const {
+    threshold,
+    minDistance,
+    preMax,
+    postMax
+  } = { ...DEFAULT_PEAK_PICKING_PARAMS, threshold: 1.5, ...params };
+  if (times.length === 0 || values.length === 0) {
+    return {
+      times: new Float32Array(0),
+      strengths: new Float32Array(0)
+    };
+  }
+  const adaptiveThreshold = new Float32Array(values.length);
+  const halfWindow = Math.floor(windowSize / 2);
+  for (let i = 0; i < values.length; i++) {
+    const start = Math.max(0, i - halfWindow);
+    const end = Math.min(values.length, i + halfWindow + 1);
+    const windowLen = end - start;
+    let sum = 0;
+    for (let j = start; j < end; j++) {
+      sum += values[j];
+    }
+    const mean = sum / windowLen;
+    let sumSq = 0;
+    for (let j = start; j < end; j++) {
+      const diff = values[j] - mean;
+      sumSq += diff * diff;
+    }
+    const std = Math.sqrt(sumSq / windowLen);
+    adaptiveThreshold[i] = mean + threshold * std;
+  }
+  let minVal = values[0];
+  let maxVal = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (v < minVal) minVal = v;
+    if (v > maxVal) maxVal = v;
+  }
+  const range = maxVal - minVal;
+  const normalize = range > 0 ? (v) => (v - minVal) / range : () => 0.5;
+  const peakIndices = [];
+  const peakStrengths = [];
+  for (let i = preMax; i < values.length - postMax; i++) {
+    const currentVal = values[i];
+    if (currentVal < adaptiveThreshold[i]) continue;
+    let isMax = true;
+    for (let j = 1; j <= preMax; j++) {
+      if (values[i - j] >= currentVal) {
+        isMax = false;
+        break;
+      }
+    }
+    if (isMax) {
+      for (let j = 1; j <= postMax; j++) {
+        if (values[i + j] > currentVal) {
+          isMax = false;
+          break;
+        }
+      }
+    }
+    if (isMax) {
+      peakIndices.push(i);
+      peakStrengths.push(normalize(currentVal));
+    }
+  }
+  const filteredIndices = [];
+  const filteredStrengths = [];
+  for (let i = 0; i < peakIndices.length; i++) {
+    const idx = peakIndices[i];
+    const time = times[idx];
+    const strength = peakStrengths[i];
+    let shouldKeep = true;
+    for (let j = 0; j < filteredIndices.length; j++) {
+      const prevIdx = filteredIndices[j];
+      const prevTime = times[prevIdx];
+      const prevStrength = filteredStrengths[j];
+      if (Math.abs(time - prevTime) < minDistance) {
+        if (strength > prevStrength) {
+          filteredIndices[j] = idx;
+          filteredStrengths[j] = strength;
+        }
+        shouldKeep = false;
+        break;
+      }
+    }
+    if (shouldKeep) {
+      filteredIndices.push(idx);
+      filteredStrengths.push(strength);
+    }
+  }
+  const resultTimes = new Float32Array(filteredIndices.length);
+  const resultStrengths = new Float32Array(filteredStrengths.length);
+  for (let i = 0; i < filteredIndices.length; i++) {
+    resultTimes[i] = times[filteredIndices[i]];
+    resultStrengths[i] = filteredStrengths[i];
+  }
+  const baseResult = {
+    times: resultTimes,
+    strengths: resultStrengths
+  };
+  if (!includeThresholdCurve) {
+    return baseResult;
+  }
+  const normalizedThreshold = new Float32Array(values.length);
+  for (let i = 0; i < values.length; i++) {
+    normalizedThreshold[i] = range > 0 ? Math.max(0, Math.min(1, (adaptiveThreshold[i] - minVal) / range)) : 0.5;
+  }
+  return {
+    ...baseResult,
+    thresholdCurve: normalizedThreshold,
+    thresholdTimes: times
+  };
+}
+function applyHysteresisGate(times, values, peakTimes, peakStrengths, params) {
+  const { onThreshold, offThreshold, minDistance } = params;
+  if (peakTimes.length === 0) {
+    return { times: new Float32Array(0), strengths: new Float32Array(0) };
+  }
+  let minVal = values[0];
+  let maxVal = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (v < minVal) minVal = v;
+    if (v > maxVal) maxVal = v;
+  }
+  const range = maxVal - minVal;
+  const normalize = range > 0 ? (v) => (v - minVal) / range : () => 0.5;
+  const getIndexForTime = (t) => {
+    let lo = 0;
+    let hi = times.length - 1;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (times[mid] < t) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    return lo;
+  };
+  const filteredTimes = [];
+  const filteredStrengths = [];
+  let lastPeakTime = -Infinity;
+  let gateOpen = true;
+  for (let i = 0; i < peakTimes.length; i++) {
+    const peakTime = peakTimes[i];
+    const peakStrength = peakStrengths[i];
+    if (peakTime - lastPeakTime < minDistance) {
+      continue;
+    }
+    if (!gateOpen) {
+      const startIdx = getIndexForTime(lastPeakTime);
+      const endIdx = getIndexForTime(peakTime);
+      for (let j = startIdx; j < endIdx && j < values.length; j++) {
+        if (normalize(values[j]) < offThreshold) {
+          gateOpen = true;
+          break;
+        }
+      }
+    }
+    if (gateOpen && peakStrength >= onThreshold) {
+      filteredTimes.push(peakTime);
+      filteredStrengths.push(peakStrength);
+      lastPeakTime = peakTime;
+      gateOpen = false;
+    }
+  }
+  return {
+    times: new Float32Array(filteredTimes),
+    strengths: new Float32Array(filteredStrengths)
+  };
+}
+
 // src/dsp/musicalTime.ts
 function findSegmentAtTime(time, segments) {
   for (const segment of segments) {
@@ -315,7 +623,7 @@ function validateBandStructure(structure) {
 function createBandStructure() {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
-    version: 1,
+    version: 2,
     bands: [],
     createdAt: now,
     modifiedAt: now
@@ -326,6 +634,7 @@ function createConstantBand(label, lowHz, highHz, duration, options) {
   return {
     id: options?.id ?? generateBandId(),
     label,
+    sourceId: options?.sourceId ?? "mixdown",
     enabled: options?.enabled ?? true,
     timeScope: { kind: "global" },
     frequencyShape: [
@@ -350,6 +659,7 @@ function createSectionedBand(label, lowHz, highHz, startTime, endTime, options)
   return {
     id: options?.id ?? generateBandId(),
     label,
+    sourceId: options?.sourceId ?? "mixdown",
     enabled: options?.enabled ?? true,
     timeScope: { kind: "sectioned", startTime, endTime },
     frequencyShape: [
@@ -369,7 +679,7 @@ function createSectionedBand(label, lowHz, highHz, startTime, endTime, options)
     }
   };
 }
-function createStandardBands(duration) {
+function createStandardBands(duration, sourceId = "mixdown") {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const bands = [
     { label: "Sub Bass", lowHz: 20, highHz: 60 },
@@ -382,6 +692,7 @@ function createStandardBands(duration) {
   return bands.map((b, index) => ({
     id: generateBandId(),
     label: b.label,
+    sourceId,
     enabled: true,
     timeScope: { kind: "global" },
     frequencyShape: [
@@ -402,10 +713,11 @@ function createStandardBands(duration) {
     }
   }));
 }
-function bandsActiveAt(structure, time) {
+function bandsActiveAt(structure, time, sourceId) {
   if (!structure) return [];
   return structure.bands.filter((band) => {
     if (!band.enabled) return false;
+    if (sourceId !== void 0 && band.sourceId !== sourceId) return false;
     if (band.timeScope.kind === "global") return true;
     return time >= band.timeScope.startTime && time < band.timeScope.endTime;
   });
@@ -991,6 +1303,44 @@ function bandSpectralFlux(spec, band, options) {
     diagnostics: computeDiagnostics(masked.energyRetainedPerFrame)
   };
 }
+function bandSpectralCentroid(spec, band, options) {
+  const startMs = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const masked = applyBandMaskToSpectrogram(spec, band, {
+    edgeSmoothHz: options?.edgeSmoothHz
+  });
+  const nFrames = masked.times.length;
+  const nBins = (masked.fftSize >>> 1) + 1;
+  const binHz = masked.sampleRate / masked.fftSize;
+  const out = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const mags = masked.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;
+      if (m > 0) {
+        const f = k * binHz;
+        num += f * m;
+        den += m;
+      }
+    }
+    out[t] = den > 0 ? num / den : 0;
+  }
+  return {
+    kind: "bandMir1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandSpectralCentroid",
+    times: masked.times,
+    values: out,
+    meta: createMeta(startMs),
+    diagnostics: computeDiagnostics(masked.energyRetainedPerFrame)
+  };
+}
 async function runBandMirBatch(spec, request, options) {
   const startMs = typeof performance !== "undefined" ? performance.now() : Date.now();
   const results = /* @__PURE__ */ new Map();
@@ -1015,6 +1365,9 @@ async function runBandMirBatch(spec, request, options) {
         case "bandSpectralFlux":
           result = bandSpectralFlux(spec, band, options);
           break;
+        case "bandSpectralCentroid":
+          result = bandSpectralCentroid(spec, band, options);
+          break;
         default:
           const _exhaustive = fn;
           throw new Error(`Unknown band MIR function: ${_exhaustive}`);
@@ -1037,93 +1390,670 @@ function getBandMirFunctionLabel(fn) {
       return "Onset Strength";
     case "bandSpectralFlux":
       return "Spectral Flux";
+    case "bandSpectralCentroid":
+      return "Spectral Centroid";
     default:
       return fn;
   }
 }
 
-// src/dsp/bandProposal.ts
-var PROPOSAL_DEFAULTS = {
-  maxProposals: 8,
-  minSalience: 0.3,
-  minSeparationOctaves: 0.5,
-  analysisWindow: 0
-  // 0 = full track
-};
-function generateProposalId() {
-  return `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+// src/dsp/bandEvents.ts
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
-function generateBandId2() {
-  return `band-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+function createMeta2(startMs) {
+  const endMs = nowMs();
+  const timings = {
+    totalMs: endMs - startMs,
+    cpuMs: endMs - startMs,
+    gpuMs: 0
+  };
+  return {
+    backend: "cpu",
+    usedGpu: false,
+    timings
+  };
 }
-function computeAverageCqtSpectrum(cqt) {
-  const nBins = cqt.magnitudes[0]?.length ?? 0;
-  const nFrames = cqt.magnitudes.length;
-  const average = new Float32Array(nBins);
-  for (let frame = 0; frame < nFrames; frame++) {
-    const frameMags = cqt.magnitudes[frame];
-    if (!frameMags) continue;
-    for (let bin = 0; bin < nBins; bin++) {
-      average[bin] = (average[bin] ?? 0) + (frameMags[bin] ?? 0);
-    }
+function computeEventDiagnostics(events, durationSec) {
+  const eventCount = events.length;
+  const eventsPerSecond = durationSec > 0 ? eventCount / durationSec : 0;
+  const warnings = [];
+  if (durationSec > 1 && eventCount === 0) {
+    warnings.push("No events detected - signal may be too quiet or noisy");
+  } else if (eventsPerSecond > 20) {
+    warnings.push("Very high event density (>20/sec) - consider adjusting threshold");
+  } else if (durationSec > 10 && eventsPerSecond < 0.1) {
+    warnings.push("Very sparse events (<0.1/sec) - signal may not be active");
   }
-  for (let bin = 0; bin < nBins; bin++) {
-    average[bin] = (average[bin] ?? 0) / nFrames;
+  return {
+    eventCount,
+    eventsPerSecond,
+    warnings
+  };
+}
+function bandOnsetPeaks(signal, options) {
+  const startMs = nowMs();
+  const minIntervalSec = options?.minIntervalSec ?? 0.0625;
+  const adaptiveFactor = options?.adaptiveFactor ?? 0.8;
+  const strict = options?.strict ?? true;
+  const { times, values } = signal;
+  const pickOptions = {
+    minIntervalSec,
+    adaptive: {
+      method: "meanStd",
+      factor: adaptiveFactor
+    },
+    strict
+  };
+  const peaks = peakPick(times, values, pickOptions);
+  const maxStrength = peaks.reduce((max, p) => Math.max(max, p.strength), 0);
+  const events = peaks.map((p) => ({
+    time: p.time,
+    weight: maxStrength > 0 ? p.strength / maxStrength : 1
+  }));
+  const duration = times.length >= 2 ? (times[times.length - 1] ?? 0) - (times[0] ?? 0) : 0;
+  return {
+    kind: "bandEvents",
+    bandId: signal.bandId,
+    bandLabel: signal.bandLabel,
+    fn: "bandOnsetPeaks",
+    events,
+    sourceSignal: {
+      fn: signal.fn,
+      times: signal.times,
+      values: signal.values
+    },
+    meta: createMeta2(startMs),
+    diagnostics: computeEventDiagnostics(events, duration)
+  };
+}
+function bandBeatCandidates(onsetPeaks, options) {
+  const startMs = nowMs();
+  const minIntervalSec = options?.minIntervalSec ?? 0.1;
+  const thresholdFactor = options?.thresholdFactor ?? 0.5;
+  const weights = onsetPeaks.events.map((e) => e.weight);
+  const meanWeight = weights.length > 0 ? weights.reduce((sum, w) => sum + w, 0) / weights.length : 0;
+  const variance = weights.length > 0 ? weights.reduce((sum, w) => sum + (w - meanWeight) ** 2, 0) / weights.length : 0;
+  const stdWeight = Math.sqrt(variance);
+  const threshold = meanWeight + thresholdFactor * stdWeight;
+  const candidates = [];
+  let lastTime = -Infinity;
+  for (const event of onsetPeaks.events) {
+    if (event.weight < threshold) continue;
+    if (event.time - lastTime < minIntervalSec) {
+      const last = candidates[candidates.length - 1];
+      if (last && event.weight > last.weight) {
+        last.time = event.time;
+        last.weight = event.weight;
+        lastTime = event.time;
+      }
+      continue;
+    }
+    candidates.push({
+      time: event.time,
+      weight: event.weight,
+      beatPosition: event.beatPosition,
+      beatPhase: event.beatPhase
+    });
+    lastTime = event.time;
   }
-  return average;
+  const duration = onsetPeaks.sourceSignal?.times ? onsetPeaks.sourceSignal.times.length >= 2 ? (onsetPeaks.sourceSignal.times[onsetPeaks.sourceSignal.times.length - 1] ?? 0) - (onsetPeaks.sourceSignal.times[0] ?? 0) : 0 : 0;
+  return {
+    kind: "bandEvents",
+    bandId: onsetPeaks.bandId,
+    bandLabel: onsetPeaks.bandLabel,
+    fn: "bandBeatCandidates",
+    events: candidates,
+    // Don't include source signal to save memory
+    meta: createMeta2(startMs),
+    diagnostics: computeEventDiagnostics(candidates, duration)
+  };
 }
-function findLocalMaxima(values, minNeighborDistance = 3) {
-  const peaks = [];
-  for (let i = minNeighborDistance; i < values.length - minNeighborDistance; i++) {
-    let isPeak = true;
-    const centerVal = values[i] ?? 0;
-    for (let j = -minNeighborDistance; j <= minNeighborDistance; j++) {
-      if (j === 0) continue;
-      if ((values[i + j] ?? 0) >= centerVal) {
-        isPeak = false;
-        break;
+async function runBandEventsBatch(request) {
+  const startMs = nowMs();
+  const results = /* @__PURE__ */ new Map();
+  const sourceFunction = request.sourceFunction ?? "bandOnsetStrength";
+  for (const [bandId, mirResults] of request.bandMirResults.entries()) {
+    const bandEventResults = [];
+    const sourceSignal = mirResults.find((r) => r.fn === sourceFunction);
+    if (!sourceSignal) {
+      continue;
+    }
+    for (const fn of request.functions) {
+      switch (fn) {
+        case "bandOnsetPeaks": {
+          const result = bandOnsetPeaks(sourceSignal, request.onsetPeaksOptions);
+          bandEventResults.push(result);
+          break;
+        }
+        case "bandBeatCandidates": {
+          let onsetPeaksResult = bandEventResults.find(
+            (r) => r.fn === "bandOnsetPeaks"
+          );
+          if (!onsetPeaksResult) {
+            onsetPeaksResult = bandOnsetPeaks(
+              sourceSignal,
+              request.onsetPeaksOptions
+            );
+            if (!request.functions.includes("bandOnsetPeaks")) ; else {
+              bandEventResults.push(onsetPeaksResult);
+            }
+          }
+          const result = bandBeatCandidates(
+            onsetPeaksResult,
+            request.beatCandidatesOptions
+          );
+          bandEventResults.push(result);
+          break;
+        }
+        default: {
+          const _exhaustive = fn;
+          throw new Error(`Unknown band event function: ${_exhaustive}`);
+        }
       }
     }
-    if (isPeak && centerVal > 0) {
-      peaks.push(i);
+    if (bandEventResults.length > 0) {
+      results.set(bandId, bandEventResults);
     }
   }
-  return peaks;
+  const endMs = nowMs();
+  return {
+    results,
+    totalTimingMs: endMs - startMs
+  };
 }
-function computeBandwidth(values, peakBin, cqt) {
-  const peakMag = values[peakBin] ?? 0;
-  const threshold = peakMag * 0.707;
-  let lowBin = peakBin;
-  while (lowBin > 0 && (values[lowBin - 1] ?? 0) >= threshold) {
-    lowBin--;
+function getBandEventFunctionLabel(fn) {
+  switch (fn) {
+    case "bandOnsetPeaks":
+      return "Onset Peaks";
+    case "bandBeatCandidates":
+      return "Beat Candidates";
+    default:
+      return fn;
   }
-  let highBin = peakBin;
-  while (highBin < values.length - 1 && (values[highBin + 1] ?? 0) >= threshold) {
-    highBin++;
+}
+
+// src/dsp/bandCqt.ts
+function nowMs2() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function createMeta3(startMs) {
+  const endMs = nowMs2();
+  const timings = {
+    totalMs: endMs - startMs,
+    cpuMs: endMs - startMs,
+    gpuMs: 0
+  };
+  return {
+    backend: "cpu",
+    usedGpu: false,
+    timings
+  };
+}
+function computeDiagnostics2(energyRetainedPerFrame) {
+  const totalFrames = energyRetainedPerFrame.length;
+  let sum = 0;
+  let weakCount = 0;
+  let emptyCount = 0;
+  for (let i = 0; i < totalFrames; i++) {
+    const e = energyRetainedPerFrame[i] ?? 0;
+    sum += e;
+    if (e < 0.01) weakCount++;
+    if (e === 0) emptyCount++;
   }
-  const lowHz = cqtBinToHz(lowBin, cqt.config);
-  const highHz = cqtBinToHz(highBin, cqt.config);
-  const bandwidthOctaves = Math.log2(highHz / lowHz);
-  return { lowBin, highBin, lowHz, highHz, bandwidthOctaves };
+  const meanEnergyRetained = totalFrames > 0 ? sum / totalFrames : 0;
+  const warnings = [];
+  if (meanEnergyRetained < 0.01) {
+    warnings.push("Band contains very little CQT energy - check frequency range");
+  }
+  if (emptyCount > totalFrames * 0.5) {
+    warnings.push("More than half of frames are empty in CQT - band may not be active");
+  }
+  return {
+    meanEnergyRetained,
+    weakFrameCount: weakCount,
+    emptyFrameCount: emptyCount,
+    totalFrames,
+    warnings
+  };
 }
-function computeTemporalVariance(cqt, lowBin, highBin) {
-  const nFrames = cqt.magnitudes.length;
-  const bandEnergies = new Float32Array(nFrames);
-  for (let frame = 0; frame < nFrames; frame++) {
-    const frameMags = cqt.magnitudes[frame];
-    if (!frameMags) continue;
-    let energy = 0;
-    for (let bin = lowBin; bin <= highBin; bin++) {
-      const mag = frameMags[bin] ?? 0;
-      energy += mag * mag;
+function getBandBoundsAtTime(band, timeSec) {
+  for (const seg of band.frequencyShape) {
+    if (timeSec >= seg.startTime && timeSec < seg.endTime) {
+      const ratio = (timeSec - seg.startTime) / (seg.endTime - seg.startTime);
+      const lowHz = seg.lowHzStart + ratio * (seg.lowHzEnd - seg.lowHzStart);
+      const highHz = seg.highHzStart + ratio * (seg.highHzEnd - seg.highHzStart);
+      return { lowHz, highHz };
     }
-    bandEnergies[frame] = energy;
   }
-  let sum = 0;
-  for (let i = 0; i < nFrames; i++) {
-    sum += bandEnergies[i] ?? 0;
+  const first = band.frequencyShape[0];
+  if (first) {
+    return { lowHz: first.lowHzStart, highHz: first.highHzStart };
   }
-  const mean = sum / nFrames;
+  return { lowHz: 20, highHz: 2e4 };
+}
+function applyBandMaskToCqt(cqt, band, options) {
+  const edgeSmoothBins = options?.edgeSmoothBins ?? 0;
+  const nFrames = cqt.times.length;
+  const nBins = cqt.binFrequencies.length;
+  const maskedMagnitudes = new Array(nFrames);
+  const energyRetainedPerFrame = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = cqt.magnitudes[t];
+    if (!frame) {
+      maskedMagnitudes[t] = new Float32Array(nBins);
+      energyRetainedPerFrame[t] = 0;
+      continue;
+    }
+    const timeSec = cqt.times[t] ?? 0;
+    const { lowHz, highHz } = getBandBoundsAtTime(band, timeSec);
+    const lowBin = Math.max(0, Math.floor(hzToCqtBin(lowHz, cqt.config)));
+    const highBin = Math.min(nBins, Math.ceil(hzToCqtBin(highHz, cqt.config)));
+    const maskedFrame = new Float32Array(nBins);
+    let originalEnergy = 0;
+    let retainedEnergy = 0;
+    for (let k = 0; k < nBins; k++) {
+      const mag = frame[k] ?? 0;
+      originalEnergy += mag * mag;
+      if (k >= lowBin && k < highBin) {
+        let weight = 1;
+        if (edgeSmoothBins > 0) {
+          const distFromLow = k - lowBin;
+          const distFromHigh = highBin - 1 - k;
+          const minDist = Math.min(distFromLow, distFromHigh);
+          if (minDist < edgeSmoothBins) {
+            weight = (minDist + 1) / (edgeSmoothBins + 1);
+          }
+        }
+        maskedFrame[k] = mag * weight;
+        retainedEnergy += (mag * weight) ** 2;
+      }
+    }
+    maskedMagnitudes[t] = maskedFrame;
+    energyRetainedPerFrame[t] = originalEnergy > 0 ? Math.sqrt(retainedEnergy / originalEnergy) : 0;
+  }
+  return {
+    times: cqt.times,
+    magnitudes: maskedMagnitudes,
+    config: cqt.config,
+    energyRetainedPerFrame,
+    binFrequencies: cqt.binFrequencies
+  };
+}
+function bandCqtHarmonicEnergy(cqt, band, options) {
+  const startMs = nowMs2();
+  const masked = applyBandMaskToCqt(cqt, band, options);
+  const nFrames = masked.times.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    if (options?.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const frame = masked.magnitudes[t];
+    if (!frame) {
+      values[t] = 0;
+      continue;
+    }
+    let totalEnergy = 0;
+    for (let k = 0; k < frame.length; k++) {
+      const mag = frame[k] ?? 0;
+      totalEnergy += mag * mag;
+    }
+    if (totalEnergy === 0) {
+      values[t] = 0;
+      continue;
+    }
+    let maxMag = 0;
+    let fundamentalBin = 0;
+    for (let k = 0; k < frame.length; k++) {
+      const mag = frame[k] ?? 0;
+      if (mag > maxMag) {
+        maxMag = mag;
+        fundamentalBin = k;
+      }
+    }
+    const fundamentalFreq = cqtBinToHz(fundamentalBin, cqt.config);
+    let harmonicEnergy2 = 0;
+    const numHarmonics = 6;
+    for (let h = 1; h <= numHarmonics; h++) {
+      const harmonicFreq = fundamentalFreq * h;
+      const harmonicBin = Math.round(hzToCqtBin(harmonicFreq, cqt.config));
+      if (harmonicBin >= 0 && harmonicBin < frame.length) {
+        const mag = frame[harmonicBin] ?? 0;
+        const weight = 1 / h;
+        harmonicEnergy2 += mag * mag * weight;
+      }
+    }
+    let weightSum = 0;
+    for (let h = 1; h <= numHarmonics; h++) {
+      weightSum += 1 / h;
+    }
+    harmonicEnergy2 /= weightSum;
+    values[t] = Math.min(1, harmonicEnergy2 / totalEnergy);
+  }
+  const normalized = normalizeMinMax(values);
+  return {
+    kind: "bandCqt1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandCqtHarmonicEnergy",
+    times: masked.times,
+    values: normalized,
+    meta: createMeta3(startMs),
+    diagnostics: computeDiagnostics2(masked.energyRetainedPerFrame)
+  };
+}
+function bandCqtBassPitchMotion(cqt, band, options) {
+  const startMs = nowMs2();
+  const masked = applyBandMaskToCqt(cqt, band, options);
+  const nFrames = masked.times.length;
+  const BASS_MIN_HZ = 20;
+  const BASS_MAX_HZ = 300;
+  const bassStartBin = Math.max(0, Math.floor(hzToCqtBin(BASS_MIN_HZ, cqt.config)));
+  const bassEndBin = Math.min(
+    masked.binFrequencies.length,
+    Math.ceil(hzToCqtBin(BASS_MAX_HZ, cqt.config))
+  );
+  const bassNumBins = bassEndBin - bassStartBin;
+  if (bassNumBins <= 0) {
+    return {
+      kind: "bandCqt1d",
+      bandId: band.id,
+      bandLabel: band.label,
+      fn: "bandCqtBassPitchMotion",
+      times: masked.times,
+      values: new Float32Array(nFrames),
+      meta: createMeta3(startMs),
+      diagnostics: {
+        ...computeDiagnostics2(masked.energyRetainedPerFrame),
+        warnings: ["Band does not overlap bass frequency range (20-300 Hz)"]
+      }
+    };
+  }
+  const centroids = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = masked.magnitudes[t];
+    if (!frame) continue;
+    let num = 0;
+    let den = 0;
+    for (let k = bassStartBin; k < bassEndBin; k++) {
+      const mag = frame[k] ?? 0;
+      if (mag > 0) {
+        num += k * mag;
+        den += mag;
+      }
+    }
+    centroids[t] = den > 0 ? num / den : bassStartBin + bassNumBins / 2;
+  }
+  const motion = new Float32Array(nFrames);
+  for (let t = 1; t < nFrames; t++) {
+    motion[t] = Math.abs((centroids[t] ?? 0) - (centroids[t - 1] ?? 0));
+  }
+  if (nFrames > 1) {
+    motion[0] = motion[1] ?? 0;
+  }
+  const normalized = normalizeMinMax(motion);
+  return {
+    kind: "bandCqt1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandCqtBassPitchMotion",
+    times: masked.times,
+    values: normalized,
+    meta: createMeta3(startMs),
+    diagnostics: computeDiagnostics2(masked.energyRetainedPerFrame)
+  };
+}
+function bandCqtTonalStability(cqt, band, options) {
+  const startMs = nowMs2();
+  const masked = applyBandMaskToCqt(cqt, band, options);
+  const nFrames = masked.times.length;
+  const CHROMA_BINS = 12;
+  const WINDOW_FRAMES = 20;
+  const chromas = new Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = masked.magnitudes[t];
+    const chroma = new Float32Array(CHROMA_BINS);
+    if (frame) {
+      const binsPerSemitone = cqt.binsPerOctave / CHROMA_BINS;
+      for (let k = 0; k < frame.length; k++) {
+        const chromaBin = Math.floor(k % cqt.binsPerOctave / binsPerSemitone) % CHROMA_BINS;
+        const mag = frame[k] ?? 0;
+        chroma[chromaBin] = (chroma[chromaBin] ?? 0) + mag * mag;
+      }
+      let sum = 0;
+      for (let c = 0; c < CHROMA_BINS; c++) {
+        sum += chroma[c] ?? 0;
+      }
+      if (sum > 0) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          chroma[c] = (chroma[c] ?? 0) / sum;
+        }
+      }
+    }
+    chromas[t] = chroma;
+  }
+  const halfWindow = Math.floor(WINDOW_FRAMES / 2);
+  const instability = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const windowStart = Math.max(0, t - halfWindow);
+    const windowEnd = Math.min(nFrames, t + halfWindow + 1);
+    const windowSize = windowEnd - windowStart;
+    const avgChroma = new Float32Array(CHROMA_BINS);
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          avgChroma[c] = (avgChroma[c] ?? 0) + (chroma[c] ?? 0);
+        }
+      }
+    }
+    for (let c = 0; c < CHROMA_BINS; c++) {
+      avgChroma[c] = (avgChroma[c] ?? 0) / windowSize;
+    }
+    let totalVariance = 0;
+    for (let w = windowStart; w < windowEnd; w++) {
+      const chroma = chromas[w];
+      if (chroma) {
+        for (let c = 0; c < CHROMA_BINS; c++) {
+          const diff = (chroma[c] ?? 0) - (avgChroma[c] ?? 0);
+          totalVariance += diff * diff;
+        }
+      }
+    }
+    totalVariance /= windowSize * CHROMA_BINS;
+    instability[t] = totalVariance;
+  }
+  const normalizedInstability = normalizeMinMax(instability);
+  const stability = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    stability[t] = 1 - (normalizedInstability[t] ?? 0);
+  }
+  return {
+    kind: "bandCqt1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandCqtTonalStability",
+    times: masked.times,
+    values: stability,
+    meta: createMeta3(startMs),
+    diagnostics: computeDiagnostics2(masked.energyRetainedPerFrame)
+  };
+}
+function normalizeMinMax(values) {
+  const n = values.length;
+  if (n === 0) return new Float32Array(0);
+  let min = Infinity;
+  let max = -Infinity;
+  for (let i = 0; i < n; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const out = new Float32Array(n);
+  const range = max - min;
+  if (range === 0 || !Number.isFinite(range)) {
+    out.fill(0.5);
+    return out;
+  }
+  for (let i = 0; i < n; i++) {
+    out[i] = ((values[i] ?? 0) - min) / range;
+  }
+  return out;
+}
+async function runBandCqtBatch(cqt, request, options) {
+  const startMs = nowMs2();
+  const results = /* @__PURE__ */ new Map();
+  for (const band of request.bands) {
+    if (options?.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    if (!band.enabled) continue;
+    const bandResults = [];
+    for (const fn of request.functions) {
+      if (options?.isCancelled?.()) {
+        throw new Error("@octoseq/mir: cancelled");
+      }
+      let result;
+      switch (fn) {
+        case "bandCqtHarmonicEnergy":
+          result = bandCqtHarmonicEnergy(cqt, band, options);
+          break;
+        case "bandCqtBassPitchMotion":
+          result = bandCqtBassPitchMotion(cqt, band, options);
+          break;
+        case "bandCqtTonalStability":
+          result = bandCqtTonalStability(cqt, band, options);
+          break;
+        default:
+          const _exhaustive = fn;
+          throw new Error(`Unknown band CQT function: ${_exhaustive}`);
+      }
+      bandResults.push(result);
+    }
+    results.set(band.id, bandResults);
+  }
+  const endMs = nowMs2();
+  return {
+    results,
+    totalTimingMs: endMs - startMs
+  };
+}
+function getBandCqtFunctionLabel(fn) {
+  switch (fn) {
+    case "bandCqtHarmonicEnergy":
+      return "Harmonic Energy (CQT)";
+    case "bandCqtBassPitchMotion":
+      return "Bass Pitch Motion (CQT)";
+    case "bandCqtTonalStability":
+      return "Tonal Stability (CQT)";
+    default:
+      return fn;
+  }
+}
+
+// src/dsp/bandProposal.ts
+var PROPOSAL_DEFAULTS = {
+  maxProposals: 8,
+  minSalience: 0.3,
+  minSeparationOctaves: 0.5,
+  minBandwidthHz: 20,
+  analysisWindow: 0
+  // 0 = full track
+};
+function generateProposalId() {
+  return `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function generateBandId2() {
+  return `band-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function computeAverageCqtSpectrum(cqt) {
+  const nBins = cqt.magnitudes[0]?.length ?? 0;
+  const nFrames = cqt.magnitudes.length;
+  const average = new Float32Array(nBins);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const frameMags = cqt.magnitudes[frame];
+    if (!frameMags) continue;
+    for (let bin = 0; bin < nBins; bin++) {
+      average[bin] = (average[bin] ?? 0) + (frameMags[bin] ?? 0);
+    }
+  }
+  for (let bin = 0; bin < nBins; bin++) {
+    average[bin] = (average[bin] ?? 0) / nFrames;
+  }
+  return average;
+}
+function findLocalMaxima(values, minNeighborDistance = 3) {
+  const peaks = [];
+  for (let i = minNeighborDistance; i < values.length - minNeighborDistance; i++) {
+    let isPeak = true;
+    const centerVal = values[i] ?? 0;
+    for (let j = -minNeighborDistance; j <= minNeighborDistance; j++) {
+      if (j === 0) continue;
+      if ((values[i + j] ?? 0) >= centerVal) {
+        isPeak = false;
+        break;
+      }
+    }
+    if (isPeak && centerVal > 0) {
+      peaks.push(i);
+    }
+  }
+  return peaks;
+}
+function computeBandwidth(values, peakBin, cqt, minBandwidthHz) {
+  const peakMag = values[peakBin] ?? 0;
+  const threshold = peakMag * 0.707;
+  let lowBin = peakBin;
+  while (lowBin > 0 && (values[lowBin - 1] ?? 0) >= threshold) {
+    lowBin--;
+  }
+  let highBin = peakBin;
+  while (highBin < values.length - 1 && (values[highBin + 1] ?? 0) >= threshold) {
+    highBin++;
+  }
+  if (minBandwidthHz > 0) {
+    const maxExpansions = values.length;
+    for (let i = 0; i < maxExpansions; i++) {
+      const lowHzTmp = cqtBinToHz(lowBin, cqt.config);
+      const highHzTmp = cqtBinToHz(highBin, cqt.config);
+      if (highHzTmp - lowHzTmp >= minBandwidthHz) break;
+      const canExpandLow = lowBin > 0;
+      const canExpandHigh = highBin < values.length - 1;
+      if (!canExpandLow && !canExpandHigh) break;
+      if (canExpandLow && canExpandHigh) {
+        lowBin--;
+        highBin++;
+      } else if (canExpandLow) {
+        lowBin--;
+      } else {
+        highBin++;
+      }
+    }
+  }
+  const lowHz = cqtBinToHz(lowBin, cqt.config);
+  const highHz = cqtBinToHz(highBin, cqt.config);
+  const bandwidthOctaves = Math.log2(highHz / lowHz);
+  return { lowBin, highBin, lowHz, highHz, bandwidthOctaves };
+}
+function computeTemporalVariance(cqt, lowBin, highBin) {
+  const nFrames = cqt.magnitudes.length;
+  const bandEnergies = new Float32Array(nFrames);
+  for (let frame = 0; frame < nFrames; frame++) {
+    const frameMags = cqt.magnitudes[frame];
+    if (!frameMags) continue;
+    let energy = 0;
+    for (let bin = lowBin; bin <= highBin; bin++) {
+      const mag = frameMags[bin] ?? 0;
+      energy += mag * mag;
+    }
+    bandEnergies[frame] = energy;
+  }
+  let sum = 0;
+  for (let i = 0; i < nFrames; i++) {
+    sum += bandEnergies[i] ?? 0;
+  }
+  const mean = sum / nFrames;
   let variance = 0;
   for (let i = 0; i < nFrames; i++) {
     const diff = (bandEnergies[i] ?? 0) - mean;
@@ -1138,7 +2068,7 @@ function detectSpectralPeaks(cqt, config) {
   const peakIndices = findLocalMaxima(avgSpectrum, Math.max(3, minBinDistance / 2));
   const peaks = [];
   for (const binIndex of peakIndices) {
-    const bw = computeBandwidth(avgSpectrum, binIndex, cqt);
+    const bw = computeBandwidth(avgSpectrum, binIndex, cqt, config.minBandwidthHz);
     peaks.push({
       binIndex,
       centerHz: cqtBinToHz(binIndex, cqt.config),
@@ -1230,6 +2160,8 @@ function createBandFromCandidate(candidate, duration) {
   return {
     id: generateBandId2(),
     label: `Region ${Math.round(candidate.peak.centerHz)} Hz`,
+    sourceId: "mixdown",
+    // Proposals default to mixdown; user assigns sourceId on promotion
     enabled: true,
     timeScope: { kind: "global" },
     frequencyShape: [
@@ -1334,6 +2266,479 @@ async function generateBandProposals(audio, duration, options = {}) {
   };
 }
 
+// src/dsp/customSignalReduction.ts
+function logCompress2(x) {
+  return Math.log1p(Math.max(0, x));
+}
+function movingAverage2(values, windowFrames) {
+  if (windowFrames <= 1) return values;
+  const n = values.length;
+  const out = new Float32Array(n);
+  const half = Math.floor(windowFrames / 2);
+  const prefix = new Float64Array(n + 1);
+  prefix[0] = 0;
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = (prefix[i] ?? 0) + (values[i] ?? 0);
+  }
+  for (let i = 0; i < n; i++) {
+    const start = Math.max(0, i - half);
+    const end = Math.min(n, i + half + 1);
+    const sum = (prefix[end] ?? 0) - (prefix[start] ?? 0);
+    const count = Math.max(1, end - start);
+    out[i] = sum / count;
+  }
+  return out;
+}
+function computeValueRange(values) {
+  if (values.length === 0) {
+    return { min: 0, max: 0 };
+  }
+  let min = values[0] ?? 0;
+  let max = values[0] ?? 0;
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  return { min, max };
+}
+function getBinRange(numBins, options) {
+  const low = Math.max(0, options?.lowBin ?? 0);
+  const high = Math.min(numBins, options?.highBin ?? numBins);
+  return { low, high };
+}
+function reduceMean(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    let sum = 0;
+    const count = high - low;
+    for (let k = low; k < high; k++) {
+      sum += frame[k] ?? 0;
+    }
+    values[t] = count > 0 ? sum / count : 0;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceMax(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    let max = -Infinity;
+    for (let k = low; k < high; k++) {
+      const v = frame[k] ?? 0;
+      if (v > max) max = v;
+    }
+    values[t] = max === -Infinity ? 0 : max;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceSum(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    let sum = 0;
+    for (let k = low; k < high; k++) {
+      sum += frame[k] ?? 0;
+    }
+    values[t] = sum;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceVariance(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    const count = high - low;
+    if (count <= 1) {
+      values[t] = 0;
+      continue;
+    }
+    let sum = 0;
+    for (let k = low; k < high; k++) {
+      sum += frame[k] ?? 0;
+    }
+    const mean = sum / count;
+    let variance = 0;
+    for (let k = low; k < high; k++) {
+      const d = (frame[k] ?? 0) - mean;
+      variance += d * d;
+    }
+    values[t] = variance / count;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceAmplitude(input, options) {
+  return reduceSum(input, options);
+}
+function reduceSpectralFlux(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  const normalized = options?.spectralFlux?.normalized ?? true;
+  if (nFrames === 0) {
+    return {
+      times: input.times,
+      values,
+      valueRange: { min: 0, max: 0 }
+    };
+  }
+  values[0] = 0;
+  let prevNorm = null;
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      prevNorm = null;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    let curNorm;
+    if (normalized) {
+      let sum = 0;
+      for (let k = low; k < high; k++) {
+        sum += frame[k] ?? 0;
+      }
+      if (sum <= 0) {
+        values[t] = 0;
+        prevNorm = null;
+        continue;
+      }
+      const inv = 1 / sum;
+      curNorm = new Float32Array(high - low);
+      for (let k = low; k < high; k++) {
+        curNorm[k - low] = (frame[k] ?? 0) * inv;
+      }
+    } else {
+      curNorm = new Float32Array(high - low);
+      for (let k = low; k < high; k++) {
+        curNorm[k - low] = frame[k] ?? 0;
+      }
+    }
+    if (!prevNorm || prevNorm.length !== curNorm.length) {
+      values[t] = 0;
+      prevNorm = curNorm;
+      continue;
+    }
+    let flux = 0;
+    for (let k = 0; k < curNorm.length; k++) {
+      flux += Math.abs((curNorm[k] ?? 0) - (prevNorm[k] ?? 0));
+    }
+    values[t] = flux;
+    prevNorm = curNorm;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceSpectralCentroid(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const frame = input.data[t];
+    if (!frame || frame.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(frame.length, options?.binRange);
+    let num = 0;
+    let den = 0;
+    for (let k = low; k < high; k++) {
+      const m = frame[k] ?? 0;
+      if (m > 0) {
+        num += k * m;
+        den += m;
+      }
+    }
+    values[t] = den > 0 ? num / den : 0;
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduceOnsetStrength(input, options) {
+  const nFrames = input.data.length;
+  const values = new Float32Array(nFrames);
+  const useLog = options?.onsetStrength?.useLog ?? true;
+  const smoothMs = options?.onsetStrength?.smoothMs ?? 10;
+  const diffMethod = options?.onsetStrength?.diffMethod ?? "rectified";
+  if (nFrames === 0) {
+    return {
+      times: input.times,
+      values,
+      valueRange: { min: 0, max: 0 }
+    };
+  }
+  values[0] = 0;
+  for (let t = 1; t < nFrames; t++) {
+    const cur = input.data[t];
+    const prev = input.data[t - 1];
+    if (!cur || !prev || cur.length === 0 || prev.length === 0) {
+      values[t] = 0;
+      continue;
+    }
+    const { low, high } = getBinRange(cur.length, options?.binRange);
+    let sum = 0;
+    let binsWithData = 0;
+    for (let k = low; k < high; k++) {
+      let a = cur[k] ?? 0;
+      let b = prev[k] ?? 0;
+      if (a > 0 || b > 0) {
+        binsWithData++;
+        if (useLog) {
+          a = logCompress2(a);
+          b = logCompress2(b);
+        }
+        const d = a - b;
+        sum += diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+      }
+    }
+    values[t] = binsWithData > 0 ? sum / binsWithData : 0;
+  }
+  if (smoothMs > 0 && nFrames >= 2) {
+    const dt = (input.times[1] ?? 0) - (input.times[0] ?? 0);
+    if (dt > 0) {
+      const windowFrames = Math.max(1, Math.round(smoothMs / 1e3 / dt));
+      const smoothed = movingAverage2(values, windowFrames | 1);
+      return {
+        times: input.times,
+        values: smoothed,
+        valueRange: computeValueRange(smoothed)
+      };
+    }
+  }
+  return {
+    times: input.times,
+    values,
+    valueRange: computeValueRange(values)
+  };
+}
+function reduce2DToSignal(input, algorithm, options) {
+  switch (algorithm) {
+    case "mean":
+      return reduceMean(input, options);
+    case "max":
+      return reduceMax(input, options);
+    case "sum":
+      return reduceSum(input, options);
+    case "variance":
+      return reduceVariance(input, options);
+    case "amplitude":
+      return reduceAmplitude(input, options);
+    case "spectralFlux":
+      return reduceSpectralFlux(input, options);
+    case "spectralCentroid":
+      return reduceSpectralCentroid(input, options);
+    case "onsetStrength":
+      return reduceOnsetStrength(input, options);
+    default:
+      const _exhaustive = algorithm;
+      throw new Error(`Unknown reduction algorithm: ${_exhaustive}`);
+  }
+}
+function getReductionAlgorithmLabel(algorithm) {
+  switch (algorithm) {
+    case "mean":
+      return "Mean";
+    case "max":
+      return "Maximum";
+    case "sum":
+      return "Sum";
+    case "variance":
+      return "Variance";
+    case "amplitude":
+      return "Amplitude Envelope";
+    case "spectralFlux":
+      return "Spectral Flux";
+    case "spectralCentroid":
+      return "Spectral Centroid";
+    case "onsetStrength":
+      return "Onset Strength";
+    default:
+      return String(algorithm);
+  }
+}
+function getReductionAlgorithmDescription(algorithm) {
+  switch (algorithm) {
+    case "mean":
+      return "Average value across all bins per frame";
+    case "max":
+      return "Maximum value across all bins per frame";
+    case "sum":
+      return "Sum of all bin values per frame";
+    case "variance":
+      return "Variance of bin values per frame";
+    case "amplitude":
+      return "Sum of magnitudes (energy envelope)";
+    case "spectralFlux":
+      return "Change between consecutive frames";
+    case "spectralCentroid":
+      return "Weighted center frequency";
+    case "onsetStrength":
+      return "Temporal derivative for onset detection";
+    default:
+      return "";
+  }
+}
+function applyPolarity(values, mode) {
+  if (mode === "signed") {
+    return values;
+  }
+  const result = new Float32Array(values.length);
+  for (let i = 0; i < values.length; i++) {
+    result[i] = Math.abs(values[i] ?? 0);
+  }
+  return result;
+}
+function getStabilizationWindowFrames(mode, frameTime) {
+  const smoothingTimes = {
+    none: 0,
+    light: 0.01,
+    // 10ms
+    medium: 0.03,
+    // 30ms
+    heavy: 0.1
+    // 100ms
+  };
+  const smoothMs = smoothingTimes[mode] * 1e3;
+  if (smoothMs <= 0 || frameTime <= 0) return 1;
+  return Math.max(1, Math.round(smoothMs / 1e3 / frameTime)) | 1;
+}
+function applyAttackRelease(values, times, attackTimeSec, releaseTimeSec) {
+  const n = values.length;
+  if (n === 0) return values;
+  const out = new Float32Array(n);
+  out[0] = values[0] ?? 0;
+  for (let i = 1; i < n; i++) {
+    const dt = (times[i] ?? 0) - (times[i - 1] ?? 0);
+    if (dt <= 0) {
+      out[i] = values[i] ?? 0;
+      continue;
+    }
+    const current = values[i] ?? 0;
+    const prev = out[i - 1] ?? 0;
+    if (current > prev) {
+      if (attackTimeSec > 0) {
+        const alpha = 1 - Math.exp(-dt / attackTimeSec);
+        out[i] = prev + alpha * (current - prev);
+      } else {
+        out[i] = current;
+      }
+    } else {
+      if (releaseTimeSec > 0) {
+        const alpha = 1 - Math.exp(-dt / releaseTimeSec);
+        out[i] = prev + alpha * (current - prev);
+      } else {
+        out[i] = current;
+      }
+    }
+  }
+  return out;
+}
+function stabilizeSignal(values, times, options) {
+  if (values.length === 0) return values;
+  let result = values;
+  if (options.mode !== "none" && times.length >= 2) {
+    const dt = (times[1] ?? 0) - (times[0] ?? 0);
+    if (dt > 0) {
+      const windowFrames = getStabilizationWindowFrames(options.mode, dt);
+      if (windowFrames > 1) {
+        result = movingAverage2(result, windowFrames);
+      }
+    }
+  }
+  if (options.envelopeMode === "attackRelease") {
+    const attackSec = options.attackTimeSec ?? 0.01;
+    const releaseSec = options.releaseTimeSec ?? 0.1;
+    result = applyAttackRelease(result, times, attackSec, releaseSec);
+  }
+  return result;
+}
+function computePercentiles(values, percentiles) {
+  if (values.length === 0) {
+    return Object.fromEntries(percentiles.map((p) => [p, 0]));
+  }
+  const sorted = Float32Array.from(values).sort((a, b) => a - b);
+  const n = sorted.length;
+  const result = {};
+  for (const p of percentiles) {
+    const clamped = Math.max(0, Math.min(100, p));
+    const index = clamped / 100 * (n - 1);
+    const lower = Math.floor(index);
+    const upper = Math.min(lower + 1, n - 1);
+    const frac = index - lower;
+    result[p] = (sorted[lower] ?? 0) * (1 - frac) + (sorted[upper] ?? 0) * frac;
+  }
+  return result;
+}
+function computeLocalStats(values, times, startTime, endTime) {
+  const indices = [];
+  for (let i = 0; i < times.length; i++) {
+    const t = times[i] ?? 0;
+    if (t >= startTime && t <= endTime) {
+      indices.push(i);
+    }
+  }
+  if (indices.length === 0) {
+    return { min: 0, max: 0, p5: 0, p95: 0 };
+  }
+  const viewportValues = new Float32Array(indices.length);
+  for (let i = 0; i < indices.length; i++) {
+    viewportValues[i] = values[indices[i] ?? 0] ?? 0;
+  }
+  const range = computeValueRange(viewportValues);
+  const percentiles = computePercentiles(viewportValues, [5, 95]);
+  return {
+    min: range.min,
+    max: range.max,
+    p5: percentiles[5] ?? 0,
+    p95: percentiles[95] ?? 0
+  };
+}
+
 // src/util/normalise.ts
 function normaliseForWaveform(data, options = {}) {
   const center = options.center ?? false;
@@ -1598,7 +3003,7 @@ function similarityFingerprintV1(a, b, weights = {}) {
 }
 
 // src/search/searchTrackV1.ts
-function nowMs() {
+function nowMs3() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function clamp01(x) {
@@ -1607,7 +3012,7 @@ function clamp01(x) {
   return x;
 }
 async function searchTrackV1(params) {
-  const tStart = nowMs();
+  const tStart = nowMs3();
   const options = params.options ?? {};
   const hopSec = Math.max(5e-3, options.hopSec ?? 0.03);
   const threshold = clamp01(options.threshold ?? 0.75);
@@ -1615,7 +3020,7 @@ async function searchTrackV1(params) {
   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 tFp0 = nowMs3();
   const queryFp = fingerprintV1({
     t0: qt0,
     t1: qt1,
@@ -1624,8 +3029,8 @@ async function searchTrackV1(params) {
     mfcc: params.mfcc,
     peakPick: options.queryPeakPick
   });
-  const fingerprintMs = nowMs() - tFp0;
-  const scanStartMs = nowMs();
+  const fingerprintMs = nowMs3() - tFp0;
+  const scanStartMs = nowMs3();
   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
@@ -1665,7 +3070,7 @@ async function searchTrackV1(params) {
     sim[w] = clamp01(score);
     scannedWindows++;
   }
-  const scanMs = nowMs() - scanStartMs;
+  const scanMs = nowMs3() - scanStartMs;
   const events = peakPick(times, sim, {
     threshold,
     minIntervalSec: minSpacingSec,
@@ -1681,7 +3086,7 @@ async function searchTrackV1(params) {
       windowEndSec
     };
   });
-  const totalMs = nowMs() - tStart;
+  const totalMs = nowMs3() - tStart;
   return {
     times,
     similarity: sim,
@@ -1915,7 +3320,7 @@ function scoreWithModelV1(model, x) {
 }
 
 // src/search/searchTrackV1Guided.ts
-function nowMs2() {
+function nowMs4() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function clamp013(x) {
@@ -2082,7 +3487,7 @@ var SlidingMoments = class {
   }
 };
 async function searchTrackV1Guided(params) {
-  const tStart = nowMs2();
+  const tStart = nowMs4();
   const options = params.options ?? {};
   const hopSec = Math.max(5e-3, options.hopSec ?? 0.03);
   const threshold = clamp013(options.threshold ?? 0.75);
@@ -2101,7 +3506,7 @@ async function searchTrackV1Guided(params) {
     positives: modelDecision.positives.length,
     negatives: modelDecision.negatives.length
   } : { kind: "baseline", positives: 0, negatives: 0 };
-  const tPrep0 = nowMs2();
+  const tPrep0 = nowMs4();
   const timesFrames = params.mel.times;
   const nFrames = timesFrames.length;
   const trackDuration = Math.max(
@@ -2112,7 +3517,7 @@ async function searchTrackV1Guided(params) {
   const times = new Float32Array(nWindows);
   const scores = new Float32Array(nWindows);
   if (nWindows === 0) {
-    const totalMs2 = nowMs2() - tStart;
+    const totalMs2 = nowMs4() - tStart;
     return {
       times,
       scores,
@@ -2201,7 +3606,7 @@ async function searchTrackV1Guided(params) {
   }
   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 fingerprintMs = nowMs4() - tPrep0;
   const addMelFrame = (frame, sum, sumSq) => {
     const row = melBands[frame];
     const s = melScale[frame] ?? 1;
@@ -2387,7 +3792,7 @@ async function searchTrackV1Guided(params) {
   };
   let skippedWindows = 0;
   let scannedWindows = 0;
-  const scanStartMs = nowMs2();
+  const scanStartMs = nowMs4();
   let curveKind = "similarity";
   let modelExplain = baselineExplain;
   let modelMs = 0;
@@ -2410,7 +3815,7 @@ async function searchTrackV1Guided(params) {
   if (modelDecision.kind === "baseline") {
     runBaselineSimilarityScan();
   } else {
-    const tModel0 = nowMs2();
+    const tModel0 = nowMs4();
     curveKind = "confidence";
     try {
       const dim = layout.dim;
@@ -2475,10 +3880,10 @@ async function searchTrackV1Guided(params) {
       zInvStd = null;
       runBaselineSimilarityScan();
     } finally {
-      modelMs = nowMs2() - tModel0;
+      modelMs = nowMs4() - tModel0;
     }
   }
-  const scanMs = nowMs2() - scanStartMs;
+  const scanMs = nowMs4() - scanStartMs;
   const events = peakPick(times, scores, {
     threshold,
     minIntervalSec: minSpacingSec,
@@ -2505,7 +3910,7 @@ async function searchTrackV1Guided(params) {
       };
     }
   }
-  const totalMs = nowMs2() - tStart;
+  const totalMs = nowMs4() - tStart;
   return {
     times,
     scores,
@@ -2531,6 +3936,6 @@ function helloMir(name = "world") {
   return `Hello, ${name} from @octoseq/mir v${MIR_VERSION}`;
 }
 
-export { MIR_VERSION, MirGPU, addBandToStructure, allFrequencyBoundsAt, applyBandMaskToSpectrogram, bandAmplitudeEnvelope, bandOnsetStrength, bandSpectralFlux, bandsActiveAt, binToHz, clampDb, computeBandMaskAtTime, computeBeatPosition, computeBeatPositionFromStructure, computeFrameAmplitude, computeFrameEnergy, computePhaseHypotheses, createBandStructure, createConstantBand, createMusicalTimeStructure, createSectionedBand, createSegmentFromGrid, createStandardBands, findBandById, findSegmentAtTime, fingerprintToVectorV1, fingerprintV1, frequencyBoundsAt, generateBandId, generateBandProposals, generateBeatTimes, generateSegmentBeatTimes, generateSegmentId, getBandMirFunctionLabel, helloMir, hzToBin, keyframesFromBand, mergeAdjacentSegments, minMax, moveKeyframeTime, normaliseForWaveform, removeBandFromStructure, removeKeyframe, runBandMirBatch, searchTrackV1, searchTrackV1Guided, segmentsFromKeyframes, similarityFingerprintV1, sortBands, sortFrequencySegments, sortSegments, spectrogramToDb, splitBandSegmentAt, splitSegment, touchStructure, updateBandInStructure, updateKeyframe, validateBandStructure, validateFrequencyBand, validateFrequencySegments, validateSegments };
+export { DEFAULT_PEAK_PICKING_PARAMS, MIR_VERSION, MirGPU, addBandToStructure, allFrequencyBoundsAt, applyBandMaskToCqt, applyBandMaskToSpectrogram, applyHysteresisGate, applyPolarity, bandAmplitudeEnvelope, bandBeatCandidates, bandCqtBassPitchMotion, bandCqtHarmonicEnergy, bandCqtTonalStability, bandOnsetPeaks, bandOnsetStrength, bandSpectralCentroid, bandSpectralFlux, bandsActiveAt, binToHz, clampDb, computeAdaptiveThreshold, computeBandMaskAtTime, computeBeatPosition, computeBeatPositionFromStructure, computeFrameAmplitude, computeFrameEnergy, computeLocalStats, computePercentiles, computePhaseHypotheses, createBandStructure, createConstantBand, createMusicalTimeStructure, createSectionedBand, createSegmentFromGrid, createStandardBands, findBandById, findSegmentAtTime, fingerprintToVectorV1, fingerprintV1, frequencyBoundsAt, generateBandId, generateBandProposals, generateBeatTimes, generateSegmentBeatTimes, generateSegmentId, getBandCqtFunctionLabel, getBandEventFunctionLabel, getBandMirFunctionLabel, getReductionAlgorithmDescription, getReductionAlgorithmLabel, helloMir, hzToBin, keyframesFromBand, mergeAdjacentSegments, minMax, moveKeyframeTime, normaliseForWaveform, pickPeaks, pickPeaksAdaptive, reduce2DToSignal, removeBandFromStructure, removeKeyframe, runBandCqtBatch, runBandEventsBatch, runBandMirBatch, searchTrackV1, searchTrackV1Guided, segmentsFromKeyframes, similarityFingerprintV1, sortBands, sortFrequencySegments, sortSegments, spectrogramToDb, splitBandSegmentAt, splitSegment, stabilizeSignal, touchStructure, updateBandInStructure, updateKeyframe, validateBandStructure, validateFrequencyBand, validateFrequencySegments, validateSegments };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map