@octoseq/mir 0.1.0-main.4ecb074 → 0.1.0-main.5fdb072

package/dist/index.js

@@ -1,36 +1,3499 @@
-import { peakPick } from './chunk-DUWYCAVG.js';
-export { delta, deltaDelta, hpss, melSpectrogram, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, runMir, spectralCentroid, spectralFlux, spectrogram } from './chunk-DUWYCAVG.js';
+import { peakPick, hzToCqtBin, cqtBinToHz, withCqtDefaults, cqtSpectrogram, harmonicEnergy, bassPitchMotion, tonalStability, getNumBins } from './chunk-HF3QHCRK.js';
+export { CQT_DEFAULTS, amplitudeEnvelope, applyActivityGating, bassPitchMotion, beatSalienceFromMel, buildActivityMask, computeActivityFromAudio, computeActivityFromMel, computeActivityFromSpectrogram, computeAllCqtSignals, computeCqt, computeCqtSignal, computeFrameEnergyFromMel, computeFrameEnergyFromSpectrogram, computeSilenceGating, cqtBinToHz, cqtSpectrogram, delta, deltaDelta, detectBeatCandidates, estimateNoiseFloor, featureIndexToHz, generateTempoHypotheses, getCqtBinFrequencies, getNumBins, getNumOctaves, harmonicEnergy, hpss, hzToCqtBin, hzToFeatureIndex, hzToMel, interpolateActivity, melSpectrogram, melToHz, mfcc, onsetEnvelopeFromMel, onsetEnvelopeFromMelGpu, onsetEnvelopeFromSpectrogram, peakPick, pitchConfidence, pitchF0, runMir, spectralCentroid, spectralFlux, spectrogram, tonalStability, withBinGateDefaults, withCqtDefaults, withSilenceGateDefaults } from './chunk-HF3QHCRK.js';
+
+// src/gpu/bufferPool.ts
+var DEFAULT_OPTIONS = {
+  maxBuffersPerUsage: 32,
+  bufferTTLMs: 6e4,
+  enableAutoCleanup: true,
+  cleanupIntervalMs: 3e4
+};
+function makePoolKey(size, usage) {
+  return `${size}-${usage}`;
+}
+var BufferPool = class {
+  device;
+  options;
+  // Available buffers indexed by size+usage key
+  availableBuffers = /* @__PURE__ */ new Map();
+  // Currently in-use buffers (for tracking and stats)
+  activeBuffers = /* @__PURE__ */ new Set();
+  // Cleanup interval handle
+  cleanupInterval = null;
+  constructor(device, options = {}) {
+    this.device = device;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    if (this.options.enableAutoCleanup) {
+      this.startAutoCleanup();
+    }
+  }
+  /**
+   * Acquire a buffer from the pool or create a new one if none available.
+   *
+   * @param size - Byte size of the buffer
+   * @param usage - Buffer usage flags (e.g. GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST)
+   * @returns A GPUBuffer ready for use
+   */
+  acquire(size, usage) {
+    const key = makePoolKey(size, usage);
+    const pool = this.availableBuffers.get(key);
+    if (pool && pool.length > 0) {
+      const entry = pool.pop();
+      this.activeBuffers.add(entry.buffer);
+      return entry.buffer;
+    }
+    const buffer = this.device.createBuffer({ size, usage });
+    this.activeBuffers.add(buffer);
+    return buffer;
+  }
+  /**
+   * Release a buffer back to the pool for reuse.
+   *
+   * @param buffer - The buffer to release
+   * @param size - Original size of the buffer
+   * @param usage - Original usage flags of the buffer
+   */
+  release(buffer, size, usage) {
+    if (!this.activeBuffers.has(buffer)) {
+      console.warn("@octoseq/mir: Attempting to release buffer not tracked by pool");
+      return;
+    }
+    this.activeBuffers.delete(buffer);
+    const key = makePoolKey(size, usage);
+    let pool = this.availableBuffers.get(key);
+    if (!pool) {
+      pool = [];
+      this.availableBuffers.set(key, pool);
+    }
+    if (pool.length >= this.options.maxBuffersPerUsage) {
+      buffer.destroy();
+      return;
+    }
+    pool.push({
+      buffer,
+      size,
+      usage,
+      lastUsed: performance.now()
+    });
+  }
+  /**
+   * Clean up old unused buffers that exceed the TTL.
+   */
+  cleanup() {
+    const now = performance.now();
+    const ttl = this.options.bufferTTLMs;
+    for (const [key, pool] of this.availableBuffers.entries()) {
+      const remaining = [];
+      for (const entry of pool) {
+        if (now - entry.lastUsed > ttl) {
+          entry.buffer.destroy();
+        } else {
+          remaining.push(entry);
+        }
+      }
+      if (remaining.length === 0) {
+        this.availableBuffers.delete(key);
+      } else {
+        this.availableBuffers.set(key, remaining);
+      }
+    }
+  }
+  /**
+   * Destroy all pooled buffers and clear the pool.
+   */
+  clear() {
+    for (const pool of this.availableBuffers.values()) {
+      for (const entry of pool) {
+        entry.buffer.destroy();
+      }
+    }
+    this.availableBuffers.clear();
+  }
+  /**
+   * Get statistics about the buffer pool.
+   */
+  getStats() {
+    let totalBuffers = this.activeBuffers.size;
+    let totalMemoryBytes = 0;
+    const poolsByUsage = /* @__PURE__ */ new Map();
+    for (const pool of this.availableBuffers.values()) {
+      totalBuffers += pool.length;
+      for (const entry of pool) {
+        totalMemoryBytes += entry.size;
+        const count = poolsByUsage.get(entry.usage) || 0;
+        poolsByUsage.set(entry.usage, count + 1);
+      }
+    }
+    return {
+      totalBuffers,
+      activeBuffers: this.activeBuffers.size,
+      availableBuffers: totalBuffers - this.activeBuffers.size,
+      poolsByUsage,
+      totalMemoryBytes
+    };
+  }
+  /**
+   * Start automatic cleanup of old buffers.
+   */
+  startAutoCleanup() {
+    if (this.cleanupInterval !== null) {
+      return;
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, this.options.cleanupIntervalMs);
+  }
+  /**
+   * Stop automatic cleanup.
+   */
+  stopAutoCleanup() {
+    if (this.cleanupInterval !== null) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  /**
+   * Dispose of the buffer pool and destroy all buffers.
+   */
+  dispose() {
+    this.stopAutoCleanup();
+    this.clear();
+  }
+};
 
 // src/gpu/context.ts
 var MirGPU = class _MirGPU {
   device;
   queue;
-  constructor(device) {
+  bufferPool;
+  constructor(device, bufferPoolOptions) {
     this.device = device;
     this.queue = device.queue;
+    this.bufferPool = new BufferPool(device, bufferPoolOptions);
+  }
+  static async create(bufferPoolOptions) {
+    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, bufferPoolOptions);
+  }
+  /**
+   * Get statistics about buffer pool usage.
+   */
+  getBufferPoolStats() {
+    return this.bufferPool.getStats();
+  }
+  /**
+   * Manually trigger buffer pool cleanup (normally runs automatically).
+   */
+  cleanupBufferPool() {
+    this.bufferPool.cleanup();
+  }
+  /**
+   * Dispose of the GPU context and clean up all resources.
+   */
+  dispose() {
+    this.bufferPool.dispose();
+  }
+};
+
+// src/dsp/phaseAlignment.ts
+var DEFAULT_CONFIG = {
+  phaseResolution: 16,
+  matchTolerance: 0.05,
+  // 50ms
+  topK: 3,
+  offsetPenaltyWeight: 0.2
+};
+function computePhaseHypotheses(bpm, candidates, audioDuration, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const period = 60 / bpm;
+  if (candidates.length === 0 || audioDuration <= 0 || bpm <= 0) {
+    return [];
+  }
+  const phases = [];
+  for (let i = 0; i < cfg.phaseResolution; i++) {
+    const phaseOffset = i / cfg.phaseResolution * period;
+    const result = scorePhase(phaseOffset, period, candidates, audioDuration, cfg.matchTolerance);
+    phases.push({
+      index: i,
+      phaseOffset,
+      score: result.score,
+      matchCount: result.matchCount,
+      avgOffsetError: result.avgOffsetError
+    });
+  }
+  const maxScore = Math.max(...phases.map((p) => p.score), 1e-9);
+  for (const phase of phases) {
+    const penalty = phase.avgOffsetError / cfg.matchTolerance * cfg.offsetPenaltyWeight;
+    phase.score = phase.score / maxScore * (1 - Math.min(1, penalty));
+  }
+  phases.sort((a, b) => b.score - a.score);
+  return phases.slice(0, cfg.topK);
+}
+function scorePhase(phaseOffset, period, candidates, audioDuration, tolerance) {
+  let score = 0;
+  let matchCount = 0;
+  let totalOffsetError = 0;
+  for (const candidate of candidates) {
+    const beatsFromStart = (candidate.time - phaseOffset) / period;
+    const nearestBeatIndex = Math.round(beatsFromStart);
+    const nearestBeatTime = phaseOffset + nearestBeatIndex * period;
+    if (nearestBeatTime < 0 || nearestBeatTime > audioDuration) continue;
+    const offset = Math.abs(candidate.time - nearestBeatTime);
+    if (offset <= tolerance) {
+      const weight = Math.exp(-offset * offset / (2 * tolerance * tolerance));
+      score += candidate.strength * weight;
+      matchCount++;
+      totalOffsetError += offset;
+    }
+  }
+  const avgOffsetError = matchCount > 0 ? totalOffsetError / matchCount : 0;
+  return { score, matchCount, avgOffsetError };
+}
+function generateBeatTimes(bpm, phaseOffset, userNudge, audioDuration) {
+  if (bpm <= 0 || audioDuration <= 0) {
+    return [];
+  }
+  const period = 60 / bpm;
+  const effectivePhase = phaseOffset + userNudge;
+  const beats = [];
+  const firstBeatIndex = Math.ceil(-effectivePhase / period);
+  let time = effectivePhase + firstBeatIndex * period;
+  while (time <= audioDuration) {
+    if (time >= 0) {
+      beats.push(time);
+    }
+    time += period;
+  }
+  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) {
+    if (time >= segment.startTime && time < segment.endTime) {
+      return segment;
+    }
+  }
+  return null;
+}
+function computeBeatPosition(time, segments) {
+  const segment = findSegmentAtTime(time, segments);
+  if (!segment) {
+    return null;
+  }
+  const period = 60 / segment.bpm;
+  const beatsFromStart = (time - segment.phaseOffset) / period;
+  const beatIndex = Math.floor(beatsFromStart);
+  const beatPhase = beatsFromStart - beatIndex;
+  return {
+    segmentId: segment.id,
+    beatIndex,
+    beatPhase,
+    beatPosition: beatsFromStart,
+    bpm: segment.bpm
+  };
+}
+function computeBeatPositionFromStructure(time, structure) {
+  if (!structure || structure.segments.length === 0) {
+    return null;
+  }
+  return computeBeatPosition(time, structure.segments);
+}
+function generateSegmentId() {
+  return `seg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createSegmentFromGrid(grid, startTime, endTime) {
+  const effectivePhaseOffset = grid.phaseOffset + grid.userNudge;
+  return {
+    id: generateSegmentId(),
+    bpm: grid.bpm,
+    phaseOffset: effectivePhaseOffset,
+    startTime,
+    endTime,
+    confidence: grid.confidence,
+    provenance: {
+      source: "promoted_from_hypothesis",
+      sourceHypothesisId: grid.sourceHypothesisId,
+      promotedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      userNudge: grid.userNudge
+    }
+  };
+}
+function createMusicalTimeStructure() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    segments: [],
+    createdAt: now,
+    modifiedAt: now
+  };
+}
+function validateSegments(segments) {
+  const errors = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg) continue;
+    if (seg.startTime >= seg.endTime) {
+      errors.push(`Segment ${seg.id}: startTime (${seg.startTime}) >= endTime (${seg.endTime})`);
+    }
+    if (seg.bpm <= 0) {
+      errors.push(`Segment ${seg.id}: bpm (${seg.bpm}) must be positive`);
+    }
+    if (i < segments.length - 1) {
+      const next = segments[i + 1];
+      if (!next) continue;
+      if (seg.startTime >= next.startTime) {
+        errors.push(`Segment ${seg.id} not ordered before ${next.id}`);
+      }
+      if (seg.endTime > next.startTime) {
+        errors.push(`Segment ${seg.id} overlaps with ${next.id}`);
+      }
+    }
+  }
+  return errors;
+}
+function sortSegments(segments) {
+  return [...segments].sort((a, b) => a.startTime - b.startTime);
+}
+function splitSegment(segment, splitTime) {
+  if (splitTime <= segment.startTime || splitTime >= segment.endTime) {
+    throw new Error(
+      `Split time ${splitTime} must be within segment bounds [${segment.startTime}, ${segment.endTime})`
+    );
+  }
+  const beforeSegment = {
+    ...segment,
+    id: generateSegmentId(),
+    endTime: splitTime
+  };
+  const afterSegment = {
+    ...segment,
+    id: generateSegmentId(),
+    startTime: splitTime
+    // phaseOffset stays the same - beat grid continues seamlessly
+  };
+  return [beforeSegment, afterSegment];
+}
+function generateSegmentBeatTimes(segment) {
+  const period = 60 / segment.bpm;
+  const times = [];
+  const beatsBeforeStart = Math.ceil((segment.startTime - segment.phaseOffset) / period);
+  let time = segment.phaseOffset + beatsBeforeStart * period;
+  while (time < segment.endTime) {
+    if (time >= segment.startTime) {
+      times.push(time);
+    }
+    time += period;
+  }
+  return times;
+}
+
+// src/dsp/frequencyBand.ts
+function generateBandId() {
+  return `band-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function validateFrequencySegments(segments) {
+  const errors = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg) continue;
+    if (seg.lowHzStart < 0 || seg.highHzStart < 0) {
+      errors.push(`Segment ${i}: start frequencies must be non-negative`);
+    }
+    if (seg.lowHzStart >= seg.highHzStart) {
+      errors.push(
+        `Segment ${i}: lowHzStart (${seg.lowHzStart}) must be < highHzStart (${seg.highHzStart})`
+      );
+    }
+    if (seg.lowHzEnd < 0 || seg.highHzEnd < 0) {
+      errors.push(`Segment ${i}: end frequencies must be non-negative`);
+    }
+    if (seg.lowHzEnd >= seg.highHzEnd) {
+      errors.push(
+        `Segment ${i}: lowHzEnd (${seg.lowHzEnd}) must be < highHzEnd (${seg.highHzEnd})`
+      );
+    }
+    if (seg.startTime >= seg.endTime) {
+      errors.push(
+        `Segment ${i}: startTime (${seg.startTime}) must be < endTime (${seg.endTime})`
+      );
+    }
+    if (i < segments.length - 1) {
+      const next = segments[i + 1];
+      if (!next) continue;
+      if (seg.endTime > next.startTime) {
+        errors.push(`Segment ${i} overlaps with segment ${i + 1}`);
+      }
+      if (seg.startTime >= next.startTime) {
+        errors.push(`Segment ${i} not ordered before segment ${i + 1}`);
+      }
+    }
+  }
+  return errors;
+}
+function validateFrequencyBand(band) {
+  const errors = [];
+  if (!band.id || band.id.trim() === "") {
+    errors.push("Band must have a non-empty id");
+  }
+  if (!band.label || band.label.trim() === "") {
+    errors.push("Band must have a non-empty label");
+  }
+  if (band.frequencyShape.length === 0) {
+    errors.push(`Band "${band.label}": must have at least one frequency segment`);
+  }
+  const segmentErrors = validateFrequencySegments(band.frequencyShape);
+  errors.push(...segmentErrors.map((e) => `Band "${band.label}": ${e}`));
+  if (band.timeScope.kind === "sectioned" && band.frequencyShape.length > 0) {
+    const { startTime, endTime } = band.timeScope;
+    const first = band.frequencyShape[0];
+    const last = band.frequencyShape[band.frequencyShape.length - 1];
+    if (first && first.startTime > startTime) {
+      errors.push(
+        `Band "${band.label}": segments don't cover scope start (first segment starts at ${first.startTime}, scope starts at ${startTime})`
+      );
+    }
+    if (last && last.endTime < endTime) {
+      errors.push(
+        `Band "${band.label}": segments don't cover scope end (last segment ends at ${last.endTime}, scope ends at ${endTime})`
+      );
+    }
+  }
+  return errors;
+}
+function validateBandStructure(structure) {
+  const errors = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const band of structure.bands) {
+    if (ids.has(band.id)) {
+      errors.push(`Duplicate band ID: ${band.id}`);
+    }
+    ids.add(band.id);
+  }
+  for (const band of structure.bands) {
+    errors.push(...validateFrequencyBand(band));
+  }
+  return errors;
+}
+function createBandStructure() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 2,
+    bands: [],
+    createdAt: now,
+    modifiedAt: now
+  };
+}
+function createConstantBand(label, lowHz, highHz, duration, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: options?.id ?? generateBandId(),
+    label,
+    sourceId: options?.sourceId ?? "mixdown",
+    enabled: options?.enabled ?? true,
+    timeScope: { kind: "global" },
+    frequencyShape: [
+      {
+        startTime: 0,
+        endTime: duration,
+        lowHzStart: lowHz,
+        highHzStart: highHz,
+        lowHzEnd: lowHz,
+        highHzEnd: highHz
+      }
+    ],
+    sortOrder: options?.sortOrder ?? 0,
+    provenance: {
+      source: "manual",
+      createdAt: now
+    }
+  };
+}
+function createSectionedBand(label, lowHz, highHz, startTime, endTime, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: options?.id ?? generateBandId(),
+    label,
+    sourceId: options?.sourceId ?? "mixdown",
+    enabled: options?.enabled ?? true,
+    timeScope: { kind: "sectioned", startTime, endTime },
+    frequencyShape: [
+      {
+        startTime,
+        endTime,
+        lowHzStart: lowHz,
+        highHzStart: highHz,
+        lowHzEnd: lowHz,
+        highHzEnd: highHz
+      }
+    ],
+    sortOrder: options?.sortOrder ?? 0,
+    provenance: {
+      source: "manual",
+      createdAt: now
+    }
+  };
+}
+function createStandardBands(duration, sourceId = "mixdown") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const bands = [
+    { label: "Sub Bass", lowHz: 20, highHz: 60 },
+    { label: "Bass", lowHz: 60, highHz: 250 },
+    { label: "Low Mids", lowHz: 250, highHz: 500 },
+    { label: "Mids", lowHz: 500, highHz: 2e3 },
+    { label: "High Mids", lowHz: 2e3, highHz: 4e3 },
+    { label: "Highs", lowHz: 4e3, highHz: 2e4 }
+  ];
+  return bands.map((b, index) => ({
+    id: generateBandId(),
+    label: b.label,
+    sourceId,
+    enabled: true,
+    timeScope: { kind: "global" },
+    frequencyShape: [
+      {
+        startTime: 0,
+        endTime: duration,
+        lowHzStart: b.lowHz,
+        highHzStart: b.highHz,
+        lowHzEnd: b.lowHz,
+        highHzEnd: b.highHz
+      }
+    ],
+    sortOrder: index,
+    provenance: {
+      source: "preset",
+      createdAt: now,
+      presetName: "Standard 6-Band"
+    }
+  }));
+}
+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;
+  });
+}
+function frequencyBoundsAt(band, time) {
+  if (!band.enabled) return null;
+  if (band.timeScope.kind === "sectioned") {
+    if (time < band.timeScope.startTime || time >= band.timeScope.endTime) {
+      return null;
+    }
+  }
+  for (const seg of band.frequencyShape) {
+    if (time >= seg.startTime && time < seg.endTime) {
+      const t = (time - seg.startTime) / (seg.endTime - seg.startTime);
+      return {
+        bandId: band.id,
+        lowHz: seg.lowHzStart + (seg.lowHzEnd - seg.lowHzStart) * t,
+        highHz: seg.highHzStart + (seg.highHzEnd - seg.highHzStart) * t,
+        enabled: band.enabled
+      };
+    }
+  }
+  const last = band.frequencyShape[band.frequencyShape.length - 1];
+  if (last && Math.abs(time - last.endTime) < 1e-3) {
+    return {
+      bandId: band.id,
+      lowHz: last.lowHzEnd,
+      highHz: last.highHzEnd,
+      enabled: band.enabled
+    };
+  }
+  return null;
+}
+function allFrequencyBoundsAt(structure, time) {
+  if (!structure) return [];
+  const bounds = [];
+  for (const band of structure.bands) {
+    const b = frequencyBoundsAt(band, time);
+    if (b) bounds.push(b);
+  }
+  bounds.sort((a, b) => {
+    const bandA = structure.bands.find((band) => band.id === a.bandId);
+    const bandB = structure.bands.find((band) => band.id === b.bandId);
+    return (bandA?.sortOrder ?? 0) - (bandB?.sortOrder ?? 0);
+  });
+  return bounds;
+}
+function findBandById(structure, id) {
+  if (!structure) return null;
+  return structure.bands.find((b) => b.id === id) ?? null;
+}
+function sortBands(bands) {
+  return [...bands].sort((a, b) => a.sortOrder - b.sortOrder);
+}
+function sortFrequencySegments(segments) {
+  return [...segments].sort((a, b) => a.startTime - b.startTime);
+}
+function touchStructure(structure) {
+  return {
+    ...structure,
+    modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function addBandToStructure(structure, band) {
+  return {
+    ...structure,
+    bands: sortBands([...structure.bands, band]),
+    modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function removeBandFromStructure(structure, bandId) {
+  return {
+    ...structure,
+    bands: structure.bands.filter((b) => b.id !== bandId),
+    modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function updateBandInStructure(structure, bandId, updates) {
+  return {
+    ...structure,
+    bands: sortBands(
+      structure.bands.map((b) => b.id === bandId ? { ...b, ...updates } : b)
+    ),
+    modifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function keyframesFromBand(band) {
+  const keyframes = [];
+  const segments = sortFrequencySegments(band.frequencyShape);
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg) continue;
+    keyframes.push({
+      time: seg.startTime,
+      lowHz: seg.lowHzStart,
+      highHz: seg.highHzStart,
+      segmentIndex: i,
+      edge: "start"
+    });
+    const nextSeg = segments[i + 1];
+    const isShared = nextSeg && Math.abs(nextSeg.startTime - seg.endTime) < 1e-3;
+    if (!isShared) {
+      keyframes.push({
+        time: seg.endTime,
+        lowHz: seg.lowHzEnd,
+        highHz: seg.highHzEnd,
+        segmentIndex: i,
+        edge: "end"
+      });
+    }
+  }
+  return keyframes;
+}
+function segmentsFromKeyframes(keyframes) {
+  if (keyframes.length < 2) return [];
+  const sorted = [...keyframes].sort((a, b) => a.time - b.time);
+  const segments = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const curr = sorted[i];
+    const next = sorted[i + 1];
+    if (!curr || !next) continue;
+    segments.push({
+      startTime: curr.time,
+      endTime: next.time,
+      lowHzStart: curr.lowHz,
+      highHzStart: curr.highHz,
+      lowHzEnd: next.lowHz,
+      highHzEnd: next.highHz
+    });
+  }
+  return segments;
+}
+function splitBandSegmentAt(band, time) {
+  const segments = sortFrequencySegments(band.frequencyShape);
+  const segmentIndex = segments.findIndex(
+    (seg2) => time > seg2.startTime && time < seg2.endTime
+  );
+  if (segmentIndex === -1) {
+    return band;
+  }
+  const seg = segments[segmentIndex];
+  if (!seg) return band;
+  const t = (time - seg.startTime) / (seg.endTime - seg.startTime);
+  const lowHz = seg.lowHzStart + (seg.lowHzEnd - seg.lowHzStart) * t;
+  const highHz = seg.highHzStart + (seg.highHzEnd - seg.highHzStart) * t;
+  const firstHalf = {
+    startTime: seg.startTime,
+    endTime: time,
+    lowHzStart: seg.lowHzStart,
+    highHzStart: seg.highHzStart,
+    lowHzEnd: lowHz,
+    highHzEnd: highHz
+  };
+  const secondHalf = {
+    startTime: time,
+    endTime: seg.endTime,
+    lowHzStart: lowHz,
+    highHzStart: highHz,
+    lowHzEnd: seg.lowHzEnd,
+    highHzEnd: seg.highHzEnd
+  };
+  const newSegments = [
+    ...segments.slice(0, segmentIndex),
+    firstHalf,
+    secondHalf,
+    ...segments.slice(segmentIndex + 1)
+  ];
+  return {
+    ...band,
+    frequencyShape: newSegments
+  };
+}
+function mergeAdjacentSegments(band, tolerance = 0.1) {
+  const segments = sortFrequencySegments(band.frequencyShape);
+  if (segments.length < 2) return band;
+  const merged = [];
+  let current = segments[0];
+  if (!current) return band;
+  for (let i = 1; i < segments.length; i++) {
+    const next = segments[i];
+    if (!next) continue;
+    const timeMatches = Math.abs(current.endTime - next.startTime) < 1e-3;
+    const lowMatches = Math.abs(current.lowHzEnd - next.lowHzStart) < tolerance;
+    const highMatches = Math.abs(current.highHzEnd - next.highHzStart) < tolerance;
+    if (timeMatches && lowMatches && highMatches) {
+      current = {
+        startTime: current.startTime,
+        endTime: next.endTime,
+        lowHzStart: current.lowHzStart,
+        highHzStart: current.highHzStart,
+        lowHzEnd: next.lowHzEnd,
+        highHzEnd: next.highHzEnd
+      };
+    } else {
+      merged.push(current);
+      current = next;
+    }
+  }
+  merged.push(current);
+  return {
+    ...band,
+    frequencyShape: merged
+  };
+}
+function removeKeyframe(band, time) {
+  const segments = sortFrequencySegments(band.frequencyShape);
+  if (segments.length < 2) return band;
+  const endingIndex = segments.findIndex(
+    (seg) => Math.abs(seg.endTime - time) < 1e-3
+  );
+  const startingIndex = segments.findIndex(
+    (seg) => Math.abs(seg.startTime - time) < 1e-3
+  );
+  if (endingIndex === -1 || startingIndex === -1) return band;
+  if (endingIndex !== startingIndex - 1) return band;
+  const endingSeg = segments[endingIndex];
+  const startingSeg = segments[startingIndex];
+  if (!endingSeg || !startingSeg) return band;
+  const merged = {
+    startTime: endingSeg.startTime,
+    endTime: startingSeg.endTime,
+    lowHzStart: endingSeg.lowHzStart,
+    highHzStart: endingSeg.highHzStart,
+    lowHzEnd: startingSeg.lowHzEnd,
+    highHzEnd: startingSeg.highHzEnd
+  };
+  const newSegments = [
+    ...segments.slice(0, endingIndex),
+    merged,
+    ...segments.slice(startingIndex + 1)
+  ];
+  return {
+    ...band,
+    frequencyShape: newSegments
+  };
+}
+function updateKeyframe(band, time, lowHz, highHz) {
+  const segments = band.frequencyShape.map((seg) => {
+    const isStart = Math.abs(seg.startTime - time) < 1e-3;
+    const isEnd = Math.abs(seg.endTime - time) < 1e-3;
+    if (!isStart && !isEnd) return seg;
+    const newSeg = { ...seg };
+    if (isStart) {
+      if (lowHz !== void 0) newSeg.lowHzStart = lowHz;
+      if (highHz !== void 0) newSeg.highHzStart = highHz;
+    }
+    if (isEnd) {
+      if (lowHz !== void 0) newSeg.lowHzEnd = lowHz;
+      if (highHz !== void 0) newSeg.highHzEnd = highHz;
+    }
+    return newSeg;
+  });
+  return {
+    ...band,
+    frequencyShape: segments
+  };
+}
+function moveKeyframeTime(band, oldTime, newTime) {
+  const segments = sortFrequencySegments(band.frequencyShape);
+  const endingIndex = segments.findIndex(
+    (seg) => Math.abs(seg.endTime - oldTime) < 1e-3
+  );
+  const startingIndex = segments.findIndex(
+    (seg) => Math.abs(seg.startTime - oldTime) < 1e-3
+  );
+  if (endingIndex === -1 || startingIndex === -1) return band;
+  if (endingIndex !== startingIndex - 1) return band;
+  const endingSeg = segments[endingIndex];
+  const startingSeg = segments[startingIndex];
+  if (!endingSeg || !startingSeg) return band;
+  if (newTime <= endingSeg.startTime || newTime >= startingSeg.endTime) {
+    return band;
+  }
+  const newSegments = segments.map((seg, i) => {
+    if (i === endingIndex) {
+      return { ...seg, endTime: newTime };
+    }
+    if (i === startingIndex) {
+      return { ...seg, startTime: newTime };
+    }
+    return seg;
+  });
+  return {
+    ...band,
+    frequencyShape: newSegments
+  };
+}
+
+// src/dsp/bandMask.ts
+function binToHz(bin, sampleRate, fftSize) {
+  return bin * (sampleRate / fftSize);
+}
+function hzToBin(hz, sampleRate, fftSize) {
+  return hz / (sampleRate / fftSize);
+}
+function computeBandMaskAtTime(band, time, sampleRate, fftSize, options) {
+  const bounds = frequencyBoundsAt(band, time);
+  if (!bounds) return null;
+  const nBins = (fftSize >>> 1) + 1;
+  const mask = new Float32Array(nBins);
+  const edgeSmoothHz = options?.edgeSmoothHz ?? 0;
+  for (let k = 0; k < nBins; k++) {
+    const hz = binToHz(k, sampleRate, fftSize);
+    if (hz < bounds.lowHz || hz > bounds.highHz) {
+      mask[k] = 0;
+    } else if (edgeSmoothHz <= 0) {
+      mask[k] = 1;
+    } else {
+      const distFromLow = hz - bounds.lowHz;
+      const distFromHigh = bounds.highHz - hz;
+      let gain = 1;
+      if (distFromLow < edgeSmoothHz) {
+        gain *= 0.5 * (1 - Math.cos(Math.PI * distFromLow / edgeSmoothHz));
+      }
+      if (distFromHigh < edgeSmoothHz) {
+        gain *= 0.5 * (1 - Math.cos(Math.PI * distFromHigh / edgeSmoothHz));
+      }
+      mask[k] = gain;
+    }
+  }
+  return mask;
+}
+function applyBandMaskToSpectrogram(spec, band, options) {
+  const nFrames = spec.times.length;
+  const nBins = (spec.fftSize >>> 1) + 1;
+  const maskedMagnitudes = new Array(nFrames);
+  const energyRetained = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const time = spec.times[t] ?? 0;
+    const srcMags = spec.magnitudes[t];
+    if (!srcMags) {
+      maskedMagnitudes[t] = new Float32Array(nBins);
+      energyRetained[t] = 0;
+      continue;
+    }
+    const mask = computeBandMaskAtTime(
+      band,
+      time,
+      spec.sampleRate,
+      spec.fftSize,
+      options
+    );
+    if (!mask) {
+      maskedMagnitudes[t] = new Float32Array(nBins);
+      energyRetained[t] = 0;
+      continue;
+    }
+    const masked = new Float32Array(nBins);
+    let originalEnergy = 0;
+    let maskedEnergy = 0;
+    for (let k = 0; k < nBins; k++) {
+      const mag = srcMags[k] ?? 0;
+      const maskedMag = mag * (mask[k] ?? 0);
+      masked[k] = maskedMag;
+      originalEnergy += mag * mag;
+      maskedEnergy += maskedMag * maskedMag;
+    }
+    maskedMagnitudes[t] = masked;
+    energyRetained[t] = originalEnergy > 0 ? maskedEnergy / originalEnergy : 0;
+  }
+  return {
+    sampleRate: spec.sampleRate,
+    fftSize: spec.fftSize,
+    hopSize: spec.hopSize,
+    times: spec.times,
+    magnitudes: maskedMagnitudes,
+    bandId: band.id,
+    energyRetainedPerFrame: energyRetained
+  };
+}
+function computeFrameEnergy(magnitudes) {
+  let energy = 0;
+  for (let k = 0; k < magnitudes.length; k++) {
+    const mag = magnitudes[k] ?? 0;
+    energy += mag * mag;
+  }
+  return energy;
+}
+function computeFrameAmplitude(magnitudes) {
+  let sum = 0;
+  for (let k = 0; k < magnitudes.length; k++) {
+    sum += magnitudes[k] ?? 0;
+  }
+  return sum;
+}
+
+// src/dsp/bandMir.ts
+function computeDiagnostics(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 meanEnergyRetained = totalFrames > 0 ? sum / totalFrames : 0;
+  const warnings = [];
+  if (meanEnergyRetained < 0.01) {
+    warnings.push("Band contains very little energy - check frequency range");
+  }
+  if (emptyCount > totalFrames * 0.5) {
+    warnings.push("More than half of frames are empty - band may not be active for this audio");
+  }
+  return {
+    meanEnergyRetained,
+    weakFrameCount: weakCount,
+    emptyFrameCount: emptyCount,
+    totalFrames,
+    warnings
+  };
+}
+function createMeta(startMs) {
+  const endMs = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const timings = {
+    totalMs: endMs - startMs,
+    cpuMs: endMs - startMs,
+    gpuMs: 0
+  };
+  return {
+    backend: "cpu",
+    usedGpu: false,
+    timings
+  };
+}
+function movingAverage(values, windowFrames) {
+  if (windowFrames <= 1) return values;
+  const n = values.length;
+  const out = new Float32Array(n);
+  const half = Math.floor(windowFrames / 2);
+  const prefix = new Float64Array(n + 1);
+  prefix[0] = 0;
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = (prefix[i] ?? 0) + (values[i] ?? 0);
+  }
+  for (let i = 0; i < n; i++) {
+    const start = Math.max(0, i - half);
+    const end = Math.min(n, i + half + 1);
+    const sum = (prefix[end] ?? 0) - (prefix[start] ?? 0);
+    const count = Math.max(1, end - start);
+    out[i] = sum / count;
+  }
+  return out;
+}
+function logCompress(x) {
+  return Math.log1p(Math.max(0, x));
+}
+function bandAmplitudeEnvelope(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 values = new Float32Array(nFrames);
+  for (let t = 0; t < nFrames; t++) {
+    const mags = masked.magnitudes[t];
+    if (mags) {
+      values[t] = computeFrameAmplitude(mags);
+    }
+  }
+  return {
+    kind: "bandMir1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandAmplitudeEnvelope",
+    times: masked.times,
+    values,
+    meta: createMeta(startMs),
+    diagnostics: computeDiagnostics(masked.energyRetainedPerFrame)
+  };
+}
+function bandOnsetStrength(spec, band, options) {
+  const startMs = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const useLog = options?.onset?.useLog ?? false;
+  const smoothMs = options?.onset?.smoothMs ?? 30;
+  const diffMethod = options?.onset?.diffMethod ?? "rectified";
+  const masked = applyBandMaskToSpectrogram(spec, band, {
+    edgeSmoothHz: options?.edgeSmoothHz
+  });
+  const nFrames = masked.times.length;
+  const nBins = (masked.fftSize >>> 1) + 1;
+  const out = new Float32Array(nFrames);
+  out[0] = 0;
+  for (let t = 1; t < nFrames; t++) {
+    const cur = masked.magnitudes[t];
+    const prev = masked.magnitudes[t - 1];
+    if (!cur || !prev) {
+      out[t] = 0;
+      continue;
+    }
+    let sum = 0;
+    let binsWithData = 0;
+    for (let k = 0; k < nBins; k++) {
+      let a = cur[k] ?? 0;
+      let b = prev[k] ?? 0;
+      if (a > 0 || b > 0) {
+        binsWithData++;
+        if (useLog) {
+          a = logCompress(a);
+          b = logCompress(b);
+        }
+        const d = a - b;
+        sum += diffMethod === "abs" ? Math.abs(d) : Math.max(0, d);
+      }
+    }
+    out[t] = binsWithData > 0 ? sum / binsWithData : 0;
+  }
+  const smoothMs_ = smoothMs;
+  if (smoothMs_ > 0 && nFrames >= 2) {
+    const dt = (masked.times[1] ?? 0) - (masked.times[0] ?? 0);
+    const windowFrames = Math.max(1, Math.round(smoothMs_ / 1e3 / Math.max(1e-9, dt)));
+    return {
+      kind: "bandMir1d",
+      bandId: band.id,
+      bandLabel: band.label,
+      fn: "bandOnsetStrength",
+      times: masked.times,
+      values: movingAverage(out, windowFrames | 1),
+      meta: createMeta(startMs),
+      diagnostics: computeDiagnostics(masked.energyRetainedPerFrame)
+    };
+  }
+  return {
+    kind: "bandMir1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandOnsetStrength",
+    times: masked.times,
+    values: out,
+    meta: createMeta(startMs),
+    diagnostics: computeDiagnostics(masked.energyRetainedPerFrame)
+  };
+}
+function bandSpectralFlux(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 out = new Float32Array(nFrames);
+  let prev = null;
+  for (let t = 0; t < nFrames; t++) {
+    const mags = masked.magnitudes[t];
+    if (!mags) {
+      out[t] = 0;
+      prev = null;
+      continue;
+    }
+    let sum = 0;
+    for (let k = 0; k < nBins; k++) sum += mags[k] ?? 0;
+    if (sum <= 0) {
+      out[t] = 0;
+      prev = null;
+      continue;
+    }
+    const cur = new Float32Array(nBins);
+    const inv = 1 / sum;
+    for (let k = 0; k < nBins; k++) cur[k] = (mags[k] ?? 0) * inv;
+    if (!prev) {
+      out[t] = 0;
+      prev = cur;
+      continue;
+    }
+    let flux = 0;
+    for (let k = 0; k < nBins; k++) {
+      const d = (cur[k] ?? 0) - (prev[k] ?? 0);
+      flux += Math.abs(d);
+    }
+    out[t] = flux;
+    prev = cur;
+  }
+  return {
+    kind: "bandMir1d",
+    bandId: band.id,
+    bandLabel: band.label,
+    fn: "bandSpectralFlux",
+    times: masked.times,
+    values: out,
+    meta: createMeta(startMs),
+    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();
+  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 "bandAmplitudeEnvelope":
+          result = bandAmplitudeEnvelope(spec, band, options);
+          break;
+        case "bandOnsetStrength":
+          result = bandOnsetStrength(spec, band, options);
+          break;
+        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}`);
+      }
+      bandResults.push(result);
+    }
+    results.set(band.id, bandResults);
+  }
+  const endMs = typeof performance !== "undefined" ? performance.now() : Date.now();
+  return {
+    results,
+    totalTimingMs: endMs - startMs
+  };
+}
+function getBandMirFunctionLabel(fn) {
+  switch (fn) {
+    case "bandAmplitudeEnvelope":
+      return "Amplitude Envelope";
+    case "bandOnsetStrength":
+      return "Onset Strength";
+    case "bandSpectralFlux":
+      return "Spectral Flux";
+    case "bandSpectralCentroid":
+      return "Spectral Centroid";
+    default:
+      return fn;
+  }
+}
+
+// src/dsp/bandEvents.ts
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function createMeta2(startMs) {
+  const endMs = nowMs();
+  const timings = {
+    totalMs: endMs - startMs,
+    cpuMs: endMs - startMs,
+    gpuMs: 0
+  };
+  return {
+    backend: "cpu",
+    usedGpu: false,
+    timings
+  };
+}
+function computeEventDiagnostics(events, durationSec) {
+  const eventCount2 = events.length;
+  const eventsPerSecond = durationSec > 0 ? eventCount2 / durationSec : 0;
+  const warnings = [];
+  if (durationSec > 1 && eventCount2 === 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");
+  }
+  return {
+    eventCount: eventCount2,
+    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;
+  }
+  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)
+  };
+}
+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 (bandEventResults.length > 0) {
+      results.set(bandId, bandEventResults);
+    }
+  }
+  const endMs = nowMs();
+  return {
+    results,
+    totalTimingMs: endMs - startMs
+  };
+}
+function getBandEventFunctionLabel(fn) {
+  switch (fn) {
+    case "bandOnsetPeaks":
+      return "Onset Peaks";
+    case "bandBeatCandidates":
+      return "Beat Candidates";
+    default:
+      return fn;
+  }
+}
+
+// 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 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 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 };
+    }
+  }
+  const first = band.frequencyShape[0];
+  if (first) {
+    return { lowHz: first.lowHzStart, highHz: first.highHzStart };
+  }
+  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;
+    variance += diff * diff;
+  }
+  variance /= nFrames;
+  return mean > 0 ? variance / (mean * mean) : 0;
+}
+function detectSpectralPeaks(cqt, config) {
+  const avgSpectrum = computeAverageCqtSpectrum(cqt);
+  const minBinDistance = Math.ceil(config.minSeparationOctaves * cqt.binsPerOctave);
+  const peakIndices = findLocalMaxima(avgSpectrum, Math.max(3, minBinDistance / 2));
+  const peaks = [];
+  for (const binIndex of peakIndices) {
+    const bw = computeBandwidth(avgSpectrum, binIndex, cqt, config.minBandwidthHz);
+    peaks.push({
+      binIndex,
+      centerHz: cqtBinToHz(binIndex, cqt.config),
+      magnitude: avgSpectrum[binIndex] ?? 0,
+      bandwidth: bw.bandwidthOctaves,
+      lowHz: bw.lowHz,
+      highHz: bw.highHz
+    });
+  }
+  peaks.sort((a, b) => b.magnitude - a.magnitude);
+  return peaks;
+}
+function scorePeak(peak, cqt, avgSpectrum, cqtSignals) {
+  const lowBin = Math.max(0, Math.floor(peak.lowHz / (cqt.config.fMin * Math.pow(2, 1 / cqt.binsPerOctave))));
+  const highBin = Math.min(
+    getNumBins(cqt.config) - 1,
+    Math.ceil(peak.highHz / (cqt.config.fMin * Math.pow(2, 1 / cqt.binsPerOctave)))
+  );
+  const temporalVariance = computeTemporalVariance(cqt, lowBin, highBin);
+  let bandEnergy = 0;
+  let totalEnergy = 0;
+  for (let bin = 0; bin < avgSpectrum.length; bin++) {
+    const mag = avgSpectrum[bin] ?? 0;
+    totalEnergy += mag * mag;
+    if (bin >= lowBin && bin <= highBin) {
+      bandEnergy += mag * mag;
+    }
+  }
+  const energyConcentration = totalEnergy > 0 ? bandEnergy / totalEnergy : 0;
+  const isBassRange = peak.centerHz < 300;
+  const isLowMidRange = peak.centerHz >= 300 && peak.centerHz < 1e3;
+  let avgHarmonicEnergy = 0;
+  let avgBassPitchMotion = 0;
+  let avgTonalStability = 0;
+  const nFrames = cqtSignals.harmonicEnergy.length;
+  for (let i = 0; i < nFrames; i++) {
+    avgHarmonicEnergy += cqtSignals.harmonicEnergy[i] ?? 0;
+    avgBassPitchMotion += cqtSignals.bassPitchMotion[i] ?? 0;
+    avgTonalStability += cqtSignals.tonalStability[i] ?? 0;
+  }
+  avgHarmonicEnergy /= nFrames;
+  avgBassPitchMotion /= nFrames;
+  avgTonalStability /= nFrames;
+  let source;
+  let reason;
+  let salience;
+  if (isBassRange && avgBassPitchMotion > 0.4) {
+    source = "cqt_bass_motion";
+    reason = "Significant bass pitch motion detected";
+    salience = 0.3 + energyConcentration * 0.3 + avgBassPitchMotion * 0.4;
+  } else if (avgHarmonicEnergy > 0.5 && avgTonalStability > 0.5) {
+    source = "cqt_harmonic";
+    reason = "Strong harmonic structure with stable tonality";
+    salience = 0.3 + avgHarmonicEnergy * 0.35 + avgTonalStability * 0.35;
+  } else if (temporalVariance > 0.5) {
+    source = "onset_band";
+    reason = "Distinct transient activity pattern";
+    salience = 0.3 + energyConcentration * 0.3 + Math.min(1, temporalVariance) * 0.4;
+  } else if (energyConcentration > 0.1) {
+    source = "energy_cluster";
+    reason = "Concentrated spectral energy";
+    salience = 0.2 + energyConcentration * 0.5 + (1 - Math.min(1, peak.bandwidth)) * 0.3;
+  } else {
+    source = "spectral_peak";
+    reason = "Persistent spectral peak";
+    salience = 0.2 + energyConcentration * 0.4 + (1 - Math.min(1, peak.bandwidth * 2)) * 0.4;
+  }
+  if (isBassRange) {
+    reason += " (bass region)";
+  } else if (isLowMidRange) {
+    reason += " (low-mid region)";
+  } else if (peak.centerHz > 4e3) {
+    reason += " (high frequency region)";
+  }
+  return {
+    peak,
+    salience: Math.min(1, Math.max(0, salience)),
+    source,
+    reason
+  };
+}
+function createBandFromCandidate(candidate, duration) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const provenance = {
+    source: "manual",
+    // Will be treated as imported when promoted
+    createdAt: now
+  };
+  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: [
+      {
+        startTime: 0,
+        endTime: duration,
+        lowHzStart: candidate.peak.lowHz,
+        highHzStart: candidate.peak.highHz,
+        lowHzEnd: candidate.peak.lowHz,
+        highHzEnd: candidate.peak.highHz
+      }
+    ],
+    sortOrder: 0,
+    provenance
+  };
+}
+function filterOverlappingCandidates(candidates, minSeparationOctaves) {
+  const filtered = [];
+  for (const candidate of candidates) {
+    let hasOverlap = false;
+    for (const existing of filtered) {
+      const octaveDiff = Math.abs(
+        Math.log2(candidate.peak.centerHz / existing.peak.centerHz)
+      );
+      if (octaveDiff < minSeparationOctaves) {
+        hasOverlap = true;
+        break;
+      }
+    }
+    if (!hasOverlap) {
+      filtered.push(candidate);
+    }
+  }
+  return filtered;
+}
+async function generateBandProposals(audio, duration, options = {}) {
+  const startTime = performance.now();
+  const config = {
+    ...PROPOSAL_DEFAULTS,
+    ...options.config
+  };
+  const cqtConfig = withCqtDefaults({
+    binsPerOctave: 24,
+    fMin: 32.7,
+    fMax: Math.min(8372, audio.sampleRate / 2)
+    // Cap at Nyquist
+  });
+  const cqt = await cqtSpectrogram(audio, cqtConfig, {
+    isCancelled: options.isCancelled
+  });
+  if (options.isCancelled?.()) {
+    throw new Error("@octoseq/mir: cancelled");
+  }
+  const harmonicResult = harmonicEnergy(cqt);
+  const bassMotionResult = bassPitchMotion(cqt);
+  const tonalResult = tonalStability(cqt);
+  const cqtSignals = {
+    harmonicEnergy: harmonicResult.values,
+    bassPitchMotion: bassMotionResult.values,
+    tonalStability: tonalResult.values
+  };
+  const peaks = detectSpectralPeaks(cqt, config);
+  const avgSpectrum = computeAverageCqtSpectrum(cqt);
+  const candidates = [];
+  for (const peak of peaks) {
+    if (options.isCancelled?.()) {
+      throw new Error("@octoseq/mir: cancelled");
+    }
+    const candidate = scorePeak(peak, cqt, avgSpectrum, cqtSignals);
+    if (candidate.salience >= config.minSalience) {
+      candidates.push(candidate);
+    }
+  }
+  candidates.sort((a, b) => b.salience - a.salience);
+  const filtered = filterOverlappingCandidates(candidates, config.minSeparationOctaves);
+  const finalCandidates = filtered.slice(0, config.maxProposals);
+  const proposals = finalCandidates.map((candidate, index) => {
+    const band = createBandFromCandidate(candidate, duration);
+    band.sortOrder = index;
+    return {
+      id: generateProposalId(),
+      band,
+      salience: candidate.salience,
+      reason: candidate.reason,
+      source: candidate.source,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  });
+  const endTime = performance.now();
+  const meta = {
+    backend: "cpu",
+    usedGpu: false,
+    timings: {
+      totalMs: endTime - startTime,
+      cpuMs: endTime - startTime
+    }
+  };
+  return {
+    kind: "bandProposals",
+    proposals,
+    meta
+  };
+}
+
+// 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;
   }
-  static async create() {
-    if (typeof navigator === "undefined") {
-      throw new Error(
-        "@octoseq/mir: WebGPU is only available in the browser (navigator is undefined)."
-      );
+  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 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 { low, high } = getBinRange(frame.length, options?.binRange);
+    let sum = 0;
+    for (let k = low; k < high; k++) {
+      sum += frame[k] ?? 0;
     }
-    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."
-      );
+    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 device = await adapter.requestDevice();
-    return new _MirGPU(device);
+    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/dsp/eventToSignal.ts
+function generateGaussianEnvelope(centerSample, widthSamples, numSamples) {
+  const envelope = new Float32Array(numSamples);
+  const sigma = widthSamples / 4;
+  const twoSigmaSq = 2 * sigma * sigma;
+  const startSample = Math.max(0, Math.floor(centerSample - widthSamples));
+  const endSample = Math.min(numSamples, Math.ceil(centerSample + widthSamples));
+  for (let i = startSample; i < endSample; i++) {
+    const diff = i - centerSample;
+    envelope[i] = Math.exp(-(diff * diff) / twoSigmaSq);
+  }
+  return envelope;
+}
+function generateAttackDecayEnvelope(startSample, attackSamples, decaySamples, numSamples) {
+  const envelope = new Float32Array(numSamples);
+  const attackEnd = Math.min(numSamples, startSample + attackSamples);
+  for (let i = startSample; i < attackEnd; i++) {
+    if (i >= 0) {
+      const t = (i - startSample) / attackSamples;
+      envelope[i] = t;
+    }
+  }
+  const decayStart = startSample + attackSamples;
+  const decayEnd = Math.min(numSamples, decayStart + decaySamples);
+  for (let i = decayStart; i < decayEnd; i++) {
+    if (i >= 0) {
+      const t = (i - decayStart) / decaySamples;
+      envelope[i] = 1 - t;
+    }
+  }
+  return envelope;
+}
+function generateGateEnvelope(startSample, durationSamples, numSamples) {
+  const envelope = new Float32Array(numSamples);
+  const endSample = Math.min(numSamples, startSample + durationSamples);
+  for (let i = Math.max(0, startSample); i < endSample; i++) {
+    envelope[i] = 1;
+  }
+  return envelope;
+}
+function eventCount(events, windowSpec, options) {
+  const { sampleRate, duration, normalize = false } = options;
+  const numSamples = Math.ceil(duration * sampleRate);
+  const values = new Float32Array(numSamples);
+  const times = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    times[i] = i / sampleRate;
+  }
+  const windowSamples = windowSpec.kind === "seconds" ? Math.ceil(windowSpec.windowSize * sampleRate) : windowSpec.windowSize;
+  const halfWindow = Math.floor(windowSamples / 2);
+  const sortedEvents = [...events].sort((a, b) => a.time - b.time);
+  for (let i = 0; i < numSamples; i++) {
+    const windowStart = (i - halfWindow) / sampleRate;
+    const windowEnd = (i + halfWindow) / sampleRate;
+    let count = 0;
+    for (const event of sortedEvents) {
+      if (event.time >= windowStart && event.time < windowEnd) {
+        count++;
+      }
+      if (event.time >= windowEnd) break;
+    }
+    values[i] = count;
+  }
+  let min = 0;
+  let max = 0;
+  if (values.length > 0) {
+    min = values[0];
+    max = values[0];
+    for (let i = 1; i < values.length; i++) {
+      const v = values[i];
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  if (normalize && max > min) {
+    const range = max - min;
+    for (let i = 0; i < values.length; i++) {
+      values[i] = (values[i] - min) / range;
+    }
+  }
+  return { values, times, rawRange: { min, max } };
+}
+function eventDensity(events, windowSpec, options) {
+  const result = eventCount(events, windowSpec, { ...options, normalize: false });
+  const windowSeconds = windowSpec.kind === "seconds" ? windowSpec.windowSize : windowSpec.windowSize / options.sampleRate;
+  for (let i = 0; i < result.values.length; i++) {
+    result.values[i] = result.values[i] / windowSeconds;
+  }
+  let min = 0;
+  let max = 0;
+  if (result.values.length > 0) {
+    min = result.values[0];
+    max = result.values[0];
+    for (let i = 1; i < result.values.length; i++) {
+      const v = result.values[i];
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  if (options.normalize && max > min) {
+    const range = max - min;
+    for (let i = 0; i < result.values.length; i++) {
+      result.values[i] = (result.values[i] - min) / range;
+    }
+  }
+  return { ...result, rawRange: { min, max } };
+}
+function weightedSum(events, windowSpec, options) {
+  const { sampleRate, duration, normalize = false } = options;
+  const numSamples = Math.ceil(duration * sampleRate);
+  const values = new Float32Array(numSamples);
+  const times = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    times[i] = i / sampleRate;
+  }
+  const windowSamples = windowSpec.kind === "seconds" ? Math.ceil(windowSpec.windowSize * sampleRate) : windowSpec.windowSize;
+  const halfWindow = Math.floor(windowSamples / 2);
+  const sortedEvents = [...events].sort((a, b) => a.time - b.time);
+  for (let i = 0; i < numSamples; i++) {
+    const windowStart = (i - halfWindow) / sampleRate;
+    const windowEnd = (i + halfWindow) / sampleRate;
+    let sum = 0;
+    for (const event of sortedEvents) {
+      if (event.time >= windowStart && event.time < windowEnd) {
+        sum += event.weight ?? 1;
+      }
+      if (event.time >= windowEnd) break;
+    }
+    values[i] = sum;
+  }
+  let min = 0;
+  let max = 0;
+  if (values.length > 0) {
+    min = values[0];
+    max = values[0];
+    for (let i = 1; i < values.length; i++) {
+      const v = values[i];
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  if (normalize && max > min) {
+    const range = max - min;
+    for (let i = 0; i < values.length; i++) {
+      values[i] = (values[i] - min) / range;
+    }
+  }
+  return { values, times, rawRange: { min, max } };
+}
+function weightedMean(events, windowSpec, options) {
+  const { sampleRate, duration, normalize = false } = options;
+  const numSamples = Math.ceil(duration * sampleRate);
+  const values = new Float32Array(numSamples);
+  const times = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    times[i] = i / sampleRate;
+  }
+  const windowSamples = windowSpec.kind === "seconds" ? Math.ceil(windowSpec.windowSize * sampleRate) : windowSpec.windowSize;
+  const halfWindow = Math.floor(windowSamples / 2);
+  const sortedEvents = [...events].sort((a, b) => a.time - b.time);
+  for (let i = 0; i < numSamples; i++) {
+    const windowStart = (i - halfWindow) / sampleRate;
+    const windowEnd = (i + halfWindow) / sampleRate;
+    let sum = 0;
+    let count = 0;
+    for (const event of sortedEvents) {
+      if (event.time >= windowStart && event.time < windowEnd) {
+        sum += event.weight ?? 1;
+        count++;
+      }
+      if (event.time >= windowEnd) break;
+    }
+    values[i] = count > 0 ? sum / count : 0;
+  }
+  let min = 0;
+  let max = 0;
+  if (values.length > 0) {
+    min = values[0];
+    max = values[0];
+    for (let i = 1; i < values.length; i++) {
+      const v = values[i];
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  if (normalize && max > min) {
+    const range = max - min;
+    for (let i = 0; i < values.length; i++) {
+      values[i] = (values[i] - min) / range;
+    }
+  }
+  return { values, times, rawRange: { min, max } };
+}
+function eventEnvelope(events, shape, options) {
+  const { sampleRate, duration, normalize = false } = options;
+  const numSamples = Math.ceil(duration * sampleRate);
+  const values = new Float32Array(numSamples);
+  const times = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    times[i] = i / sampleRate;
+  }
+  for (const event of events) {
+    const eventSample = Math.floor(event.time * sampleRate);
+    const weight = event.weight ?? 1;
+    let envelope;
+    switch (shape.kind) {
+      case "impulse":
+        if (eventSample >= 0 && eventSample < numSamples) {
+          values[eventSample] = values[eventSample] + weight;
+        }
+        continue;
+      case "gaussian":
+        const widthSamples = shape.widthMs / 1e3 * sampleRate;
+        envelope = generateGaussianEnvelope(eventSample, widthSamples, numSamples);
+        break;
+      case "attackDecay":
+        const attackSamples = shape.attackMs / 1e3 * sampleRate;
+        const decaySamples = shape.decayMs / 1e3 * sampleRate;
+        envelope = generateAttackDecayEnvelope(eventSample, attackSamples, decaySamples, numSamples);
+        break;
+      case "gate":
+        const durationSamples = event.duration ? event.duration * sampleRate : sampleRate * 0.1;
+        envelope = generateGateEnvelope(eventSample, durationSamples, numSamples);
+        break;
+      default:
+        continue;
+    }
+    for (let i = 0; i < numSamples; i++) {
+      values[i] = values[i] + envelope[i] * weight;
+    }
+  }
+  let min = 0;
+  let max = 0;
+  if (values.length > 0) {
+    min = values[0];
+    max = values[0];
+    for (let i = 1; i < values.length; i++) {
+      const v = values[i];
+      if (v < min) min = v;
+      if (v > max) max = v;
+    }
+  }
+  if (normalize && max > min) {
+    const range = max - min;
+    for (let i = 0; i < values.length; i++) {
+      values[i] = (values[i] - min) / range;
+    }
+  }
+  return { values, times, rawRange: { min, max } };
+}
+function eventsToSignal(events, params, options) {
+  const defaultWindow = { kind: "seconds", windowSize: 0.5 };
+  const defaultShape = { kind: "attackDecay", attackMs: 5, decayMs: 100 };
+  switch (params.reducer) {
+    case "eventCount":
+      return eventCount(events, params.window ?? defaultWindow, options);
+    case "eventDensity":
+      return eventDensity(events, params.window ?? defaultWindow, options);
+    case "weightedSum":
+      return weightedSum(events, params.window ?? defaultWindow, options);
+    case "weightedMean":
+      return weightedMean(events, params.window ?? defaultWindow, options);
+    case "envelope":
+      return eventEnvelope(events, params.envelopeShape ?? defaultShape, options);
+    default:
+      throw new Error(`Unknown event reducer: ${params.reducer}`);
+  }
+}
+
+// src/dsp/signalTransforms.ts
+function smoothMovingAverage(values, windowMs, sampleRate) {
+  const windowSamples = Math.max(1, Math.round(windowMs / 1e3 * sampleRate)) | 1;
+  if (windowSamples <= 1) return values;
+  const n = values.length;
+  const result = new Float32Array(n);
+  const halfWindow = Math.floor(windowSamples / 2);
+  for (let i = 0; i < n; i++) {
+    const start = Math.max(0, i - halfWindow);
+    const end = Math.min(n, i + halfWindow + 1);
+    let sum = 0;
+    for (let j = start; j < end; j++) {
+      sum += values[j];
+    }
+    result[i] = sum / (end - start);
+  }
+  return result;
+}
+function smoothExponential(values, timeConstantMs, sampleRate) {
+  const n = values.length;
+  if (n === 0) return values;
+  const result = new Float32Array(n);
+  const dt = 1 / sampleRate;
+  const alpha = 1 - Math.exp(-dt / (timeConstantMs / 1e3));
+  result[0] = values[0];
+  for (let i = 1; i < n; i++) {
+    result[i] = result[i - 1] + alpha * (values[i] - result[i - 1]);
+  }
+  return result;
+}
+function smoothGaussian(values, windowMs, sampleRate) {
+  const windowSamples = Math.max(1, Math.round(windowMs / 1e3 * sampleRate));
+  if (windowSamples <= 1) return values;
+  const n = values.length;
+  const result = new Float32Array(n);
+  const sigma = windowSamples / 4;
+  const halfWindow = Math.floor(windowSamples / 2);
+  const kernel = new Float32Array(windowSamples);
+  let kernelSum = 0;
+  for (let i = 0; i < windowSamples; i++) {
+    const x = i - halfWindow;
+    kernel[i] = Math.exp(-(x * x) / (2 * sigma * sigma));
+    kernelSum += kernel[i];
+  }
+  for (let i = 0; i < windowSamples; i++) {
+    kernel[i] = kernel[i] / kernelSum;
+  }
+  for (let i = 0; i < n; i++) {
+    let sum = 0;
+    let weightSum = 0;
+    for (let j = 0; j < windowSamples; j++) {
+      const idx = i - halfWindow + j;
+      if (idx >= 0 && idx < n) {
+        sum += values[idx] * kernel[j];
+        weightSum += kernel[j];
+      }
+    }
+    result[i] = weightSum > 0 ? sum / weightSum : values[i];
+  }
+  return result;
+}
+function normalizeMinMax2(values, targetMin = 0, targetMax = 1) {
+  const n = values.length;
+  if (n === 0) return values;
+  let min = values[0];
+  let max = values[0];
+  for (let i = 1; i < n; i++) {
+    const v = values[i];
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  if (max === min) {
+    const result2 = new Float32Array(n);
+    result2.fill((targetMin + targetMax) / 2);
+    return result2;
+  }
+  const result = new Float32Array(n);
+  const sourceRange = max - min;
+  const targetRange = targetMax - targetMin;
+  for (let i = 0; i < n; i++) {
+    result[i] = targetMin + (values[i] - min) / sourceRange * targetRange;
+  }
+  return result;
+}
+function normalizeRobust(values, percentileLow = 5, percentileHigh = 95, targetMin = 0, targetMax = 1) {
+  const n = values.length;
+  if (n === 0) return values;
+  const sorted = Array.from(values).sort((a, b) => a - b);
+  const lowIdx = Math.floor(percentileLow / 100 * (n - 1));
+  const highIdx = Math.floor(percentileHigh / 100 * (n - 1));
+  const pLow = sorted[lowIdx];
+  const pHigh = sorted[highIdx];
+  if (pHigh === pLow) {
+    const result2 = new Float32Array(n);
+    result2.fill((targetMin + targetMax) / 2);
+    return result2;
+  }
+  const result = new Float32Array(n);
+  const sourceRange = pHigh - pLow;
+  const targetRange = targetMax - targetMin;
+  for (let i = 0; i < n; i++) {
+    const normalized = (values[i] - pLow) / sourceRange;
+    const clamped = Math.max(0, Math.min(1, normalized));
+    result[i] = targetMin + clamped * targetRange;
+  }
+  return result;
+}
+function normalizeZScore(values) {
+  const n = values.length;
+  if (n === 0) return values;
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    sum += values[i];
+  }
+  const mean = sum / n;
+  let variance = 0;
+  for (let i = 0; i < n; i++) {
+    const diff = values[i] - mean;
+    variance += diff * diff;
+  }
+  const stdDev = Math.sqrt(variance / n);
+  if (stdDev === 0) {
+    const result2 = new Float32Array(n);
+    result2.fill(0);
+    return result2;
+  }
+  const result = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = (values[i] - mean) / stdDev;
+  }
+  return result;
+}
+function applyScale(values, scale, offset) {
+  const n = values.length;
+  const result = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = values[i] * scale + offset;
+  }
+  return result;
+}
+function applyPolarityTransform(values, mode) {
+  if (mode === "signed") {
+    return values;
+  }
+  const n = values.length;
+  const result = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = Math.abs(values[i]);
+  }
+  return result;
+}
+function applyClamp(values, min, max) {
+  const n = values.length;
+  const result = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    let v = values[i];
+    if (min !== void 0 && v < min) v = min;
+    if (max !== void 0 && v > max) v = max;
+    result[i] = v;
+  }
+  return result;
+}
+function applyRemap(values, inputMin, inputMax, outputMin, outputMax, curve = "linear") {
+  const n = values.length;
+  const result = new Float32Array(n);
+  const inputRange = inputMax - inputMin;
+  const outputRange = outputMax - outputMin;
+  if (inputRange === 0) {
+    result.fill((outputMin + outputMax) / 2);
+    return result;
+  }
+  for (let i = 0; i < n; i++) {
+    let t = (values[i] - inputMin) / inputRange;
+    t = Math.max(0, Math.min(1, t));
+    switch (curve) {
+      case "easeIn":
+        t = t * t;
+        break;
+      case "easeOut":
+        t = 1 - (1 - t) * (1 - t);
+        break;
+      case "ease":
+        t = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+        break;
+    }
+    result[i] = outputMin + t * outputRange;
+  }
+  return result;
+}
+function applyTransformStep(values, step, context) {
+  switch (step.kind) {
+    case "smooth":
+      switch (step.method) {
+        case "movingAverage":
+          return smoothMovingAverage(values, step.windowMs, context.sampleRate);
+        case "exponential":
+          return smoothExponential(values, step.timeConstantMs, context.sampleRate);
+        case "gaussian":
+          return smoothGaussian(values, step.windowMs, context.sampleRate);
+        default:
+          return values;
+      }
+    case "normalize":
+      switch (step.method) {
+        case "minMax":
+          return normalizeMinMax2(values, step.targetMin, step.targetMax);
+        case "robust":
+          return normalizeRobust(
+            values,
+            step.percentileLow,
+            step.percentileHigh,
+            step.targetMin,
+            step.targetMax
+          );
+        case "zScore":
+          return normalizeZScore(values);
+        default:
+          return values;
+      }
+    case "scale":
+      return applyScale(values, step.scale, step.offset);
+    case "polarity":
+      return applyPolarityTransform(values, step.mode);
+    case "clamp":
+      return applyClamp(values, step.min, step.max);
+    case "remap":
+      return applyRemap(
+        values,
+        step.inputMin,
+        step.inputMax,
+        step.outputMin,
+        step.outputMax,
+        step.curve
+      );
+    default:
+      return values;
+  }
+}
+function applyTransformChain(values, chain, context) {
+  let result = values;
+  for (const step of chain) {
+    result = applyTransformStep(result, step, context);
+  }
+  return result;
+}
+function getTransformLabel(step) {
+  switch (step.kind) {
+    case "smooth":
+      switch (step.method) {
+        case "movingAverage":
+          return `Smooth (${step.windowMs}ms avg)`;
+        case "exponential":
+          return `Smooth (${step.timeConstantMs}ms exp)`;
+        case "gaussian":
+          return `Smooth (${step.windowMs}ms gauss)`;
+        default:
+          return "Smooth";
+      }
+    case "normalize":
+      switch (step.method) {
+        case "minMax":
+          return `Normalize (${step.targetMin ?? 0}-${step.targetMax ?? 1})`;
+        case "robust":
+          return `Normalize (robust ${step.percentileLow ?? 5}-${step.percentileHigh ?? 95}%)`;
+        case "zScore":
+          return "Normalize (z-score)";
+        default:
+          return "Normalize";
+      }
+    case "scale":
+      return step.offset !== 0 ? `Scale (\xD7${step.scale} + ${step.offset})` : `Scale (\xD7${step.scale})`;
+    case "polarity":
+      return step.mode === "magnitude" ? "Magnitude" : "Signed";
+    case "clamp":
+      if (step.min !== void 0 && step.max !== void 0) {
+        return `Clamp (${step.min}-${step.max})`;
+      } else if (step.min !== void 0) {
+        return `Clamp (\u2265${step.min})`;
+      } else if (step.max !== void 0) {
+        return `Clamp (\u2264${step.max})`;
+      }
+      return "Clamp";
+    case "remap":
+      return `Remap (${step.inputMin}-${step.inputMax} \u2192 ${step.outputMin}-${step.outputMax})`;
+    default:
+      return "Unknown";
+  }
+}
+function createDefaultTransform(kind) {
+  switch (kind) {
+    case "smooth":
+      return { kind: "smooth", method: "movingAverage", windowMs: 10 };
+    case "normalize":
+      return { kind: "normalize", method: "minMax", targetMin: 0, targetMax: 1 };
+    case "scale":
+      return { kind: "scale", scale: 1, offset: 0 };
+    case "polarity":
+      return { kind: "polarity", mode: "signed" };
+    case "clamp":
+      return { kind: "clamp", min: 0, max: 1 };
+    case "remap":
+      return { kind: "remap", inputMin: 0, inputMax: 1, outputMin: 0, outputMax: 1 };
+    default:
+      return null;
+  }
+}
 
 // src/util/normalise.ts
 function normaliseForWaveform(data, options = {}) {
@@ -96,6 +3559,28 @@ function clampDb(db2d, minDb, maxDb) {
   return out;
 }
 
+// src/dsp/resample.ts
+function resample(samples, fromRate, toRate) {
+  if (fromRate === toRate) {
+    return samples;
+  }
+  const ratio = fromRate / toRate;
+  const newLength = Math.floor(samples.length / ratio);
+  if (newLength <= 0) {
+    return new Float32Array(0);
+  }
+  const result = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i++) {
+    const srcIndex = i * ratio;
+    const srcIndexFloor = Math.floor(srcIndex);
+    const frac = srcIndex - srcIndexFloor;
+    const a = samples[srcIndexFloor] ?? 0;
+    const b = samples[srcIndexFloor + 1] ?? a;
+    result[i] = a + frac * (b - a);
+  }
+  return result;
+}
+
 // src/util/stats.ts
 function minMax(values) {
   const n = values.length >>> 0;
@@ -296,7 +3781,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) {
@@ -305,7 +3790,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);
@@ -313,7 +3798,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,
@@ -322,8 +3807,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
@@ -363,7 +3848,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,
@@ -379,7 +3864,7 @@ async function searchTrackV1(params) {
       windowEndSec
     };
   });
-  const totalMs = nowMs() - tStart;
+  const totalMs = nowMs3() - tStart;
   return {
     times,
     similarity: sim,
@@ -613,7 +4098,7 @@ function scoreWithModelV1(model, x) {
 }
 
 // src/search/searchTrackV1Guided.ts
-function nowMs2() {
+function nowMs4() {
   return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 function clamp013(x) {
@@ -780,7 +4265,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);
@@ -799,7 +4284,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(
@@ -810,7 +4295,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,
@@ -899,7 +4384,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;
@@ -1085,7 +4570,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;
@@ -1108,7 +4593,7 @@ async function searchTrackV1Guided(params) {
   if (modelDecision.kind === "baseline") {
     runBaselineSimilarityScan();
   } else {
-    const tModel0 = nowMs2();
+    const tModel0 = nowMs4();
     curveKind = "confidence";
     try {
       const dim = layout.dim;
@@ -1173,10 +4658,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,
@@ -1203,7 +4688,7 @@ async function searchTrackV1Guided(params) {
       };
     }
   }
-  const totalMs = nowMs2() - tStart;
+  const totalMs = nowMs4() - tStart;
   return {
     times,
     scores,
@@ -1229,6 +4714,6 @@ 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 };
+export { DEFAULT_PEAK_PICKING_PARAMS, MIR_VERSION, MirGPU, addBandToStructure, allFrequencyBoundsAt, applyBandMaskToCqt, applyBandMaskToSpectrogram, applyHysteresisGate, applyPolarity, applyTransformChain, applyTransformStep, bandAmplitudeEnvelope, bandBeatCandidates, bandCqtBassPitchMotion, bandCqtHarmonicEnergy, bandCqtTonalStability, bandOnsetPeaks, bandOnsetStrength, bandSpectralCentroid, bandSpectralFlux, bandsActiveAt, binToHz, clampDb, computeAdaptiveThreshold, computeBandMaskAtTime, computeBeatPosition, computeBeatPositionFromStructure, computeFrameAmplitude, computeFrameEnergy, computeLocalStats, computePercentiles, computePhaseHypotheses, createBandStructure, createConstantBand, createDefaultTransform, createMusicalTimeStructure, createSectionedBand, createSegmentFromGrid, createStandardBands, eventCount, eventDensity, eventEnvelope, eventsToSignal, findBandById, findSegmentAtTime, fingerprintToVectorV1, fingerprintV1, frequencyBoundsAt, generateBandId, generateBandProposals, generateBeatTimes, generateSegmentBeatTimes, generateSegmentId, getBandCqtFunctionLabel, getBandEventFunctionLabel, getBandMirFunctionLabel, getReductionAlgorithmDescription, getReductionAlgorithmLabel, getTransformLabel, helloMir, hzToBin, keyframesFromBand, mergeAdjacentSegments, minMax, moveKeyframeTime, normaliseForWaveform, pickPeaks, pickPeaksAdaptive, reduce2DToSignal, removeBandFromStructure, removeKeyframe, resample, runBandCqtBatch, runBandEventsBatch, runBandMirBatch, searchTrackV1, searchTrackV1Guided, segmentsFromKeyframes, similarityFingerprintV1, sortBands, sortFrequencySegments, sortSegments, spectrogramToDb, splitBandSegmentAt, splitSegment, stabilizeSignal, touchStructure, updateBandInStructure, updateKeyframe, validateBandStructure, validateFrequencyBand, validateFrequencySegments, validateSegments, weightedMean, weightedSum };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map