@viji-dev/core 0.3.25 → 0.3.27

package/dist/{index-C6fMmKQj.js → index-9YDi9UBP.js}

@@ -578,7 +578,7 @@ class IFrameManager {
 }
 function WorkerWrapper(options) {
   return new Worker(
-    "" + new URL("assets/viji.worker-Zg128woJ.js", import.meta.url).href,
+    "" + new URL("assets/viji.worker-jTmB7qoQ.js", import.meta.url).href,
     {
       type: "module",
       name: options?.name
@@ -1076,75 +1076,6 @@ class EnvelopeFollower {
     };
   }
 }
-class AutoGain {
-  recentPeaks = [];
-  gain = 1;
-  targetLevel = 0.7;
-  noiseFloor = 0.01;
-  // -40dB noise floor
-  windowSize;
-  minGain = 0.5;
-  maxGain = 4;
-  gainSmoothingFactor = 0.01;
-  /**
-   * Create auto-gain processor
-   * @param windowSizeMs - Window size in milliseconds for peak tracking (default 3000ms)
-   * @param sampleRate - Sample rate in Hz (default 60 for 60fps)
-   */
-  constructor(windowSizeMs = 3e3, sampleRate = 60) {
-    this.windowSize = Math.floor(windowSizeMs / 1e3 * sampleRate);
-  }
-  /**
-   * Process input value and return normalized output
-   * @param input - Input value (0-1)
-   * @returns Normalized value (0-1)
-   */
-  process(input) {
-    if (input < this.noiseFloor) {
-      return 0;
-    }
-    this.recentPeaks.push(input);
-    if (this.recentPeaks.length > this.windowSize) {
-      this.recentPeaks.shift();
-    }
-    if (this.recentPeaks.length > 10) {
-      const sorted = [...this.recentPeaks].sort((a, b) => b - a);
-      const percentileIndex = Math.floor(sorted.length * 0.05);
-      const currentPeak = sorted[percentileIndex];
-      if (currentPeak > this.noiseFloor) {
-        const targetGain = this.targetLevel / currentPeak;
-        const clampedTarget = Math.max(this.minGain, Math.min(this.maxGain, targetGain));
-        this.gain += (clampedTarget - this.gain) * this.gainSmoothingFactor;
-      }
-    }
-    return Math.max(0, Math.min(1, input * this.gain));
-  }
-  /**
-   * Get current gain value
-   */
-  getGain() {
-    return this.gain;
-  }
-  /**
-   * Set target level (0-1)
-   */
-  setTargetLevel(level) {
-    this.targetLevel = Math.max(0.1, Math.min(1, level));
-  }
-  /**
-   * Set noise floor threshold (0-1)
-   */
-  setNoiseFloor(threshold) {
-    this.noiseFloor = Math.max(0, Math.min(0.1, threshold));
-  }
-  /**
-   * Reset auto-gain state
-   */
-  reset() {
-    this.recentPeaks = [];
-    this.gain = 1;
-  }
-}
 const BAND_CONFIGS = {
   low: {
     minThreshold: 2e-3,
@@ -1801,7 +1732,7 @@ class EssentiaOnsetDetection {
     this.initPromise = (async () => {
       try {
         const essentiaModule = await import("./essentia.js-core.es-DnrJE0uR.js");
-        const wasmModule = await import("./essentia-wasm.web-Dq7KVAx1.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-DtvIO6D8.js").then((n) => n.e);
         const EssentiaClass = essentiaModule.Essentia || essentiaModule.default?.Essentia || essentiaModule.default;
         let WASMModule = wasmModule.default || wasmModule.EssentiaWASM || wasmModule.default?.EssentiaWASM;
         if (!WASMModule) {
@@ -11883,129 +11814,574 @@ Rejection rate: ${(rejections / duration * 60).toFixed(1)} per minute
     return this.events.length;
   }
 }
-function FFT(size) {
-  this.size = size | 0;
-  if (this.size <= 1 || (this.size & this.size - 1) !== 0)
-    throw new Error("FFT size must be a power of two and bigger than 1");
-  this._csize = size << 1;
-  var table = new Array(this.size * 2);
-  for (var i = 0; i < table.length; i += 2) {
-    const angle = Math.PI * i / this.size;
-    table[i] = Math.cos(angle);
-    table[i + 1] = -Math.sin(angle);
-  }
-  this.table = table;
-  var power = 0;
-  for (var t = 1; this.size > t; t <<= 1)
-    power++;
-  this._width = power % 2 === 0 ? power - 1 : power;
-  this._bitrev = new Array(1 << this._width);
-  for (var j = 0; j < this._bitrev.length; j++) {
-    this._bitrev[j] = 0;
-    for (var shift = 0; shift < this._width; shift += 2) {
-      var revShift = this._width - shift - 2;
-      this._bitrev[j] |= (j >>> shift & 3) << revShift;
-    }
-  }
-  this._out = null;
-  this._data = null;
-  this._inv = 0;
+const INSTRUMENTS = ["kick", "snare", "hat"];
+const SAMPLE_RATE = 60;
+const TAP_TIMEOUT_MS = 5e3;
+const MAX_CYCLE_LENGTH = 8;
+const FUZZY_TOLERANCE = 0.18;
+const MIN_REPETITIONS = 3;
+const MAX_TAP_INTERVAL_MS = 3e3;
+const MIN_TAP_INTERVAL_MS = 100;
+const MAX_TAP_HISTORY = 64;
+const MIN_EMA_ALPHA = 0.05;
+const PATTERN_SAME_TOLERANCE = 0.15;
+function createInstrumentState() {
+  return {
+    mode: "auto",
+    muted: false,
+    mutedAt: 0,
+    tapIOIs: [],
+    lastTapTime: 0,
+    pattern: null,
+    refinementIndex: 0,
+    refinementCounts: [],
+    replayLastEventTime: 0,
+    replayIndex: 0,
+    pendingTapEvents: [],
+    envelope: new EnvelopeFollower(0, 300, SAMPLE_RATE),
+    envelopeSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE)
+  };
 }
-var fft = FFT;
-FFT.prototype.fromComplexArray = function fromComplexArray(complex, storage) {
-  var res = storage || new Array(complex.length >>> 1);
-  for (var i = 0; i < complex.length; i += 2)
-    res[i >>> 1] = complex[i];
-  return res;
-};
-FFT.prototype.createComplexArray = function createComplexArray() {
-  const res = new Array(this._csize);
-  for (var i = 0; i < res.length; i++)
-    res[i] = 0;
-  return res;
-};
-FFT.prototype.toComplexArray = function toComplexArray(input, storage) {
-  var res = storage || this.createComplexArray();
-  for (var i = 0; i < res.length; i += 2) {
-    res[i] = input[i >>> 1];
-    res[i + 1] = 0;
-  }
-  return res;
-};
-FFT.prototype.completeSpectrum = function completeSpectrum(spectrum) {
-  var size = this._csize;
-  var half = size >>> 1;
-  for (var i = 2; i < half; i += 2) {
-    spectrum[size - i] = spectrum[i];
-    spectrum[size - i + 1] = -spectrum[i + 1];
-  }
-};
-FFT.prototype.transform = function transform(out, data) {
-  if (out === data)
-    throw new Error("Input and output buffers must be different");
-  this._out = out;
-  this._data = data;
-  this._inv = 0;
-  this._transform4();
-  this._out = null;
-  this._data = null;
-};
-FFT.prototype.realTransform = function realTransform(out, data) {
-  if (out === data)
-    throw new Error("Input and output buffers must be different");
-  this._out = out;
-  this._data = data;
-  this._inv = 0;
-  this._realTransform4();
-  this._out = null;
-  this._data = null;
-};
-FFT.prototype.inverseTransform = function inverseTransform(out, data) {
-  if (out === data)
-    throw new Error("Input and output buffers must be different");
-  this._out = out;
-  this._data = data;
-  this._inv = 1;
-  this._transform4();
-  for (var i = 0; i < out.length; i++)
-    out[i] /= this.size;
-  this._out = null;
-  this._data = null;
-};
-FFT.prototype._transform4 = function _transform4() {
-  var out = this._out;
-  var size = this._csize;
-  var width = this._width;
-  var step2 = 1 << width;
-  var len = size / step2 << 1;
-  var outOff;
-  var t;
-  var bitrev = this._bitrev;
-  if (len === 4) {
-    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
-      const off = bitrev[t];
-      this._singleTransform2(outOff, off, step2);
+class OnsetTapManager {
+  state = {
+    kick: createInstrumentState(),
+    snare: createInstrumentState(),
+    hat: createInstrumentState()
+  };
+  tap(instrument) {
+    const s = this.state[instrument];
+    const now = performance.now();
+    if (s.muted) {
+      s.muted = false;
+      s.mutedAt = 0;
     }
-  } else {
-    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
-      const off = bitrev[t];
-      this._singleTransform4(outOff, off, step2);
+    let ioi = -1;
+    if (s.lastTapTime > 0) {
+      ioi = now - s.lastTapTime;
+      if (ioi < MIN_TAP_INTERVAL_MS) return;
+      if (ioi > MAX_TAP_INTERVAL_MS) {
+        s.tapIOIs = [];
+        ioi = -1;
+      } else {
+        s.tapIOIs.push(ioi);
+        if (s.tapIOIs.length > MAX_TAP_HISTORY) s.tapIOIs.shift();
+      }
+    }
+    s.lastTapTime = now;
+    s.pendingTapEvents.push(now);
+    if (s.mode === "auto") {
+      s.mode = "tapping";
+      if (ioi > 0) {
+        const pattern = this.tryRecognizePattern(instrument);
+        if (pattern) this.applyPattern(instrument, pattern);
+      }
+    } else if (s.mode === "tapping") {
+      if (ioi > 0) {
+        const pattern = this.tryRecognizePattern(instrument);
+        if (pattern) this.applyPattern(instrument, pattern);
+      }
+    } else if (s.mode === "pattern") {
+      if (ioi > 0) {
+        this.handlePatternTap(instrument, ioi, now);
+      }
     }
   }
-  var inv = this._inv ? -1 : 1;
-  var table = this.table;
-  for (step2 >>= 2; step2 >= 2; step2 >>= 2) {
-    len = size / step2 << 1;
-    var quarterLen = len >>> 2;
-    for (outOff = 0; outOff < size; outOff += len) {
-      var limit = outOff + quarterLen;
-      for (var i = outOff, k = 0; i < limit; i += 2, k += step2) {
-        const A = i;
-        const B = A + quarterLen;
-        const C = B + quarterLen;
-        const D = C + quarterLen;
-        const Ar = out[A];
-        const Ai = out[A + 1];
+  clear(instrument) {
+    const s = this.state[instrument];
+    s.mode = "auto";
+    s.muted = false;
+    s.mutedAt = 0;
+    s.tapIOIs = [];
+    s.lastTapTime = 0;
+    s.pattern = null;
+    s.refinementIndex = 0;
+    s.refinementCounts = [];
+    s.replayLastEventTime = 0;
+    s.replayIndex = 0;
+    s.pendingTapEvents = [];
+    s.envelope.reset();
+    s.envelopeSmoothed.reset();
+  }
+  getMode(instrument) {
+    return this.state[instrument].mode;
+  }
+  getPatternInfo(instrument) {
+    const s = this.state[instrument];
+    if (!s.pattern) return null;
+    return {
+      length: s.pattern.length,
+      intervals: [...s.pattern],
+      confidence: 1
+    };
+  }
+  setMuted(instrument, muted) {
+    const s = this.state[instrument];
+    if (s.muted === muted) return;
+    const now = performance.now();
+    if (muted) {
+      s.muted = true;
+      s.mutedAt = now;
+    } else {
+      const pauseDuration = now - s.mutedAt;
+      s.muted = false;
+      s.mutedAt = 0;
+      if (s.mode === "tapping" && s.lastTapTime > 0) {
+        s.lastTapTime += pauseDuration;
+      }
+    }
+  }
+  isMuted(instrument) {
+    return this.state[instrument].muted;
+  }
+  /**
+   * Post-process a beat state produced by BeatStateManager.
+   * For instruments in auto mode, values pass through unchanged.
+   * For tapping/pattern instruments, auto events are suppressed and
+   * tap/pattern events + envelopes are injected instead.
+   */
+  processFrame(beatState, now, dtMs) {
+    const result = { ...beatState, events: [...beatState.events] };
+    const newEvents = [];
+    for (const inst of INSTRUMENTS) {
+      const s = this.state[inst];
+      if (s.muted) {
+        result.events = result.events.filter((e) => e.type !== inst);
+        s.pendingTapEvents = [];
+        if (s.mode === "pattern" && s.pattern && s.replayLastEventTime > 0) {
+          for (let i = 0; i < 3; i++) {
+            const interval = s.pattern[s.replayIndex % s.pattern.length];
+            if (now - s.replayLastEventTime >= interval) {
+              s.replayLastEventTime += interval;
+              s.replayIndex = (s.replayIndex + 1) % s.pattern.length;
+            } else {
+              break;
+            }
+          }
+        }
+        s.envelope.process(0, dtMs);
+        s.envelopeSmoothed.process(0, dtMs);
+        const envKey2 = inst;
+        const smoothKey2 = `${inst}Smoothed`;
+        result[envKey2] = s.envelope.getValue();
+        result[smoothKey2] = s.envelopeSmoothed.getValue();
+        continue;
+      }
+      if (s.mode === "auto") {
+        s.envelope.process(0, dtMs);
+        s.envelopeSmoothed.process(0, dtMs);
+        continue;
+      }
+      result.events = result.events.filter((e) => e.type !== inst);
+      if (s.mode === "tapping") {
+        if (now - s.lastTapTime > TAP_TIMEOUT_MS) {
+          s.tapIOIs = [];
+          s.pendingTapEvents = [];
+          if (s.pattern) {
+            s.mode = "pattern";
+            s.replayLastEventTime = now;
+            s.replayIndex = 0;
+          } else {
+            s.mode = "auto";
+          }
+          continue;
+        }
+        while (s.pendingTapEvents.length > 0) {
+          const tapTime = s.pendingTapEvents.shift();
+          newEvents.push(this.createTapEvent(inst, tapTime, result.bpm));
+          s.envelope.trigger(1);
+          s.envelopeSmoothed.trigger(1);
+          s.replayLastEventTime = tapTime;
+          s.replayIndex = 0;
+        }
+      }
+      if (s.mode === "pattern") {
+        while (s.pendingTapEvents.length > 0) {
+          const tapTime = s.pendingTapEvents.shift();
+          newEvents.push(this.createTapEvent(inst, tapTime, result.bpm));
+          s.envelope.trigger(1);
+          s.envelopeSmoothed.trigger(1);
+        }
+        const isUserActive = now - s.lastTapTime < 500;
+        if (!isUserActive && s.pattern) {
+          const scheduled = this.checkPatternReplay(s, inst, now, result.bpm);
+          for (const ev of scheduled) {
+            newEvents.push(ev);
+            s.envelope.trigger(1);
+            s.envelopeSmoothed.trigger(1);
+          }
+        }
+      }
+      s.envelope.process(0, dtMs);
+      s.envelopeSmoothed.process(0, dtMs);
+      const envKey = inst;
+      const smoothKey = `${inst}Smoothed`;
+      result[envKey] = s.envelope.getValue();
+      result[smoothKey] = s.envelopeSmoothed.getValue();
+    }
+    result.events.push(...newEvents);
+    const anyMax = Math.max(
+      result.kick,
+      result.snare,
+      result.hat
+    );
+    const anySmoothedMax = Math.max(
+      result.kickSmoothed,
+      result.snareSmoothed,
+      result.hatSmoothed
+    );
+    if (anyMax > result.any) result.any = anyMax;
+    if (anySmoothedMax > result.anySmoothed) result.anySmoothed = anySmoothedMax;
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Handle a tap that arrives while already in pattern mode.
+   * Matching taps refine the pattern via EMA and re-anchor phase.
+   * Non-matching taps trigger new pattern detection on the full IOI history.
+   */
+  handlePatternTap(instrument, ioi, now) {
+    const s = this.state[instrument];
+    if (!s.pattern) return;
+    const matchedPos = this.findMatchingPosition(s, ioi);
+    if (matchedPos >= 0) {
+      s.refinementCounts[matchedPos] = (s.refinementCounts[matchedPos] || 0) + 1;
+      const alpha = Math.max(MIN_EMA_ALPHA, 1 / s.refinementCounts[matchedPos]);
+      s.pattern[matchedPos] = (1 - alpha) * s.pattern[matchedPos] + alpha * ioi;
+      s.refinementIndex = (matchedPos + 1) % s.pattern.length;
+      s.replayLastEventTime = now;
+      s.replayIndex = s.refinementIndex;
+    } else {
+      const currentPattern = [...s.pattern];
+      const newPattern = this.tryRecognizePattern(instrument);
+      if (newPattern && !this.isPatternSame(newPattern, currentPattern)) {
+        this.applyPattern(instrument, newPattern);
+      }
+    }
+  }
+  /**
+   * Find which pattern position the given IOI matches.
+   * Tries the expected refinementIndex first, then scans all positions.
+   * Returns the matched position index, or -1 if no match.
+   */
+  findMatchingPosition(s, ioi) {
+    if (!s.pattern) return -1;
+    const expectedPos = s.refinementIndex % s.pattern.length;
+    const expectedInterval = s.pattern[expectedPos];
+    if (Math.abs(ioi - expectedInterval) / expectedInterval <= FUZZY_TOLERANCE) {
+      return expectedPos;
+    }
+    let bestPos = -1;
+    let bestDeviation = Infinity;
+    for (let i = 0; i < s.pattern.length; i++) {
+      if (i === expectedPos) continue;
+      const deviation = Math.abs(ioi - s.pattern[i]) / s.pattern[i];
+      if (deviation <= FUZZY_TOLERANCE && deviation < bestDeviation) {
+        bestDeviation = deviation;
+        bestPos = i;
+      }
+    }
+    return bestPos;
+  }
+  /**
+   * Compare two patterns for equivalence.
+   * Same length and each interval within PATTERN_SAME_TOLERANCE → same.
+   */
+  isPatternSame(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (Math.abs(a[i] - b[i]) / Math.max(a[i], b[i]) > PATTERN_SAME_TOLERANCE) return false;
+    }
+    return true;
+  }
+  /**
+   * Pattern recognition: find the shortest repeating IOI cycle
+   * that has been tapped at least MIN_REPETITIONS times.
+   * Returns the recognized pattern as float intervals, or null.
+   * Does NOT mutate state — caller decides what to do with the result.
+   */
+  tryRecognizePattern(instrument) {
+    const s = this.state[instrument];
+    const iois = s.tapIOIs;
+    if (iois.length < MIN_REPETITIONS) return null;
+    const maxL = Math.min(MAX_CYCLE_LENGTH, Math.floor(iois.length / MIN_REPETITIONS));
+    for (let L = 1; L <= maxL; L++) {
+      const needed = MIN_REPETITIONS * L;
+      if (iois.length < needed) continue;
+      const tolerance = L <= 2 ? FUZZY_TOLERANCE : FUZZY_TOLERANCE * (2 / L);
+      const recent = iois.slice(-needed);
+      const groups = [];
+      for (let g = 0; g < MIN_REPETITIONS; g++) {
+        groups.push(recent.slice(g * L, (g + 1) * L));
+      }
+      const avgGroup = groups[0].map((_, i) => {
+        let sum = 0;
+        for (const grp of groups) sum += grp[i];
+        return sum / groups.length;
+      });
+      let allMatch = true;
+      for (const grp of groups) {
+        for (let i = 0; i < L; i++) {
+          const deviation = Math.abs(grp[i] - avgGroup[i]) / avgGroup[i];
+          if (deviation > tolerance) {
+            allMatch = false;
+            break;
+          }
+        }
+        if (!allMatch) break;
+      }
+      if (allMatch) {
+        return avgGroup;
+      }
+    }
+    return null;
+  }
+  /**
+   * Apply a recognized pattern to the instrument state.
+   * Sets pattern, mode, and initializes replay anchor.
+   */
+  applyPattern(instrument, pattern) {
+    const s = this.state[instrument];
+    s.pattern = pattern;
+    s.mode = "pattern";
+    s.refinementIndex = 0;
+    s.refinementCounts = new Array(pattern.length).fill(MIN_REPETITIONS);
+    if (s.replayLastEventTime === 0 || s.replayLastEventTime < s.lastTapTime) {
+      s.replayLastEventTime = s.lastTapTime;
+      s.replayIndex = 0;
+    }
+  }
+  createTapEvent(instrument, time, bpm) {
+    return {
+      type: instrument,
+      time,
+      strength: 0.85,
+      isPredicted: false,
+      bpm
+    };
+  }
+  checkPatternReplay(s, instrument, now, bpm) {
+    if (!s.pattern || s.pattern.length === 0) return [];
+    const events = [];
+    const maxEventsPerFrame = 3;
+    for (let safety = 0; safety < maxEventsPerFrame; safety++) {
+      const expectedInterval = s.pattern[s.replayIndex % s.pattern.length];
+      const elapsed = now - s.replayLastEventTime;
+      if (elapsed >= expectedInterval) {
+        s.replayLastEventTime += expectedInterval;
+        s.replayIndex = (s.replayIndex + 1) % s.pattern.length;
+        events.push({
+          type: instrument,
+          time: s.replayLastEventTime,
+          strength: 0.8,
+          isPredicted: true,
+          bpm
+        });
+      } else {
+        break;
+      }
+    }
+    return events;
+  }
+  reset() {
+    for (const inst of INSTRUMENTS) {
+      this.clear(inst);
+    }
+  }
+}
+class AutoGain {
+  recentPeaks = [];
+  gain = 1;
+  targetLevel = 0.7;
+  noiseFloor = 0.01;
+  // -40dB noise floor
+  windowSize;
+  minGain = 0.5;
+  maxGain = 4;
+  gainSmoothingFactor = 0.01;
+  /**
+   * Create auto-gain processor
+   * @param windowSizeMs - Window size in milliseconds for peak tracking (default 3000ms)
+   * @param sampleRate - Sample rate in Hz (default 60 for 60fps)
+   */
+  constructor(windowSizeMs = 3e3, sampleRate = 60) {
+    this.windowSize = Math.floor(windowSizeMs / 1e3 * sampleRate);
+  }
+  /**
+   * Process input value and return normalized output
+   * @param input - Input value (0-1)
+   * @returns Normalized value (0-1)
+   */
+  process(input) {
+    if (input < this.noiseFloor) {
+      return 0;
+    }
+    this.recentPeaks.push(input);
+    if (this.recentPeaks.length > this.windowSize) {
+      this.recentPeaks.shift();
+    }
+    if (this.recentPeaks.length > 10) {
+      const sorted = [...this.recentPeaks].sort((a, b) => b - a);
+      const percentileIndex = Math.floor(sorted.length * 0.05);
+      const currentPeak = sorted[percentileIndex];
+      if (currentPeak > this.noiseFloor) {
+        const targetGain = this.targetLevel / currentPeak;
+        const clampedTarget = Math.max(this.minGain, Math.min(this.maxGain, targetGain));
+        this.gain += (clampedTarget - this.gain) * this.gainSmoothingFactor;
+      }
+    }
+    return Math.max(0, Math.min(1, input * this.gain));
+  }
+  /**
+   * Get current gain value
+   */
+  getGain() {
+    return this.gain;
+  }
+  /**
+   * Set target level (0-1)
+   */
+  setTargetLevel(level) {
+    this.targetLevel = Math.max(0.1, Math.min(1, level));
+  }
+  /**
+   * Set noise floor threshold (0-1)
+   */
+  setNoiseFloor(threshold) {
+    this.noiseFloor = Math.max(0, Math.min(0.1, threshold));
+  }
+  /**
+   * Reset auto-gain state
+   */
+  reset() {
+    this.recentPeaks = [];
+    this.gain = 1;
+  }
+}
+function FFT(size) {
+  this.size = size | 0;
+  if (this.size <= 1 || (this.size & this.size - 1) !== 0)
+    throw new Error("FFT size must be a power of two and bigger than 1");
+  this._csize = size << 1;
+  var table = new Array(this.size * 2);
+  for (var i = 0; i < table.length; i += 2) {
+    const angle = Math.PI * i / this.size;
+    table[i] = Math.cos(angle);
+    table[i + 1] = -Math.sin(angle);
+  }
+  this.table = table;
+  var power = 0;
+  for (var t = 1; this.size > t; t <<= 1)
+    power++;
+  this._width = power % 2 === 0 ? power - 1 : power;
+  this._bitrev = new Array(1 << this._width);
+  for (var j = 0; j < this._bitrev.length; j++) {
+    this._bitrev[j] = 0;
+    for (var shift = 0; shift < this._width; shift += 2) {
+      var revShift = this._width - shift - 2;
+      this._bitrev[j] |= (j >>> shift & 3) << revShift;
+    }
+  }
+  this._out = null;
+  this._data = null;
+  this._inv = 0;
+}
+var fft = FFT;
+FFT.prototype.fromComplexArray = function fromComplexArray(complex, storage) {
+  var res = storage || new Array(complex.length >>> 1);
+  for (var i = 0; i < complex.length; i += 2)
+    res[i >>> 1] = complex[i];
+  return res;
+};
+FFT.prototype.createComplexArray = function createComplexArray() {
+  const res = new Array(this._csize);
+  for (var i = 0; i < res.length; i++)
+    res[i] = 0;
+  return res;
+};
+FFT.prototype.toComplexArray = function toComplexArray(input, storage) {
+  var res = storage || this.createComplexArray();
+  for (var i = 0; i < res.length; i += 2) {
+    res[i] = input[i >>> 1];
+    res[i + 1] = 0;
+  }
+  return res;
+};
+FFT.prototype.completeSpectrum = function completeSpectrum(spectrum) {
+  var size = this._csize;
+  var half = size >>> 1;
+  for (var i = 2; i < half; i += 2) {
+    spectrum[size - i] = spectrum[i];
+    spectrum[size - i + 1] = -spectrum[i + 1];
+  }
+};
+FFT.prototype.transform = function transform(out, data) {
+  if (out === data)
+    throw new Error("Input and output buffers must be different");
+  this._out = out;
+  this._data = data;
+  this._inv = 0;
+  this._transform4();
+  this._out = null;
+  this._data = null;
+};
+FFT.prototype.realTransform = function realTransform(out, data) {
+  if (out === data)
+    throw new Error("Input and output buffers must be different");
+  this._out = out;
+  this._data = data;
+  this._inv = 0;
+  this._realTransform4();
+  this._out = null;
+  this._data = null;
+};
+FFT.prototype.inverseTransform = function inverseTransform(out, data) {
+  if (out === data)
+    throw new Error("Input and output buffers must be different");
+  this._out = out;
+  this._data = data;
+  this._inv = 1;
+  this._transform4();
+  for (var i = 0; i < out.length; i++)
+    out[i] /= this.size;
+  this._out = null;
+  this._data = null;
+};
+FFT.prototype._transform4 = function _transform4() {
+  var out = this._out;
+  var size = this._csize;
+  var width = this._width;
+  var step2 = 1 << width;
+  var len = size / step2 << 1;
+  var outOff;
+  var t;
+  var bitrev = this._bitrev;
+  if (len === 4) {
+    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
+      const off = bitrev[t];
+      this._singleTransform2(outOff, off, step2);
+    }
+  } else {
+    for (outOff = 0, t = 0; outOff < size; outOff += len, t++) {
+      const off = bitrev[t];
+      this._singleTransform4(outOff, off, step2);
+    }
+  }
+  var inv = this._inv ? -1 : 1;
+  var table = this.table;
+  for (step2 >>= 2; step2 >= 2; step2 >>= 2) {
+    len = size / step2 << 1;
+    var quarterLen = len >>> 2;
+    for (outOff = 0; outOff < size; outOff += len) {
+      var limit = outOff + quarterLen;
+      for (var i = outOff, k = 0; i < limit; i += 2, k += step2) {
+        const A = i;
+        const B = A + quarterLen;
+        const C = B + quarterLen;
+        const D = C + quarterLen;
+        const Ar = out[A];
+        const Ai = out[A + 1];
         const Br = out[B];
         const Bi = out[B + 1];
         const Cr = out[C];
@@ -12174,488 +12550,264 @@ FFT.prototype._realTransform4 = function _realTransform4() {
         var T3i = inv * (MBi - MDi);
         var FAr = T0r + T2r;
         var FAi = T0i + T2i;
-        var FBr = T1r + T3i;
-        var FBi = T1i - T3r;
-        out[A] = FAr;
-        out[A + 1] = FAi;
-        out[B] = FBr;
-        out[B + 1] = FBi;
-        if (i === 0) {
-          var FCr = T0r - T2r;
-          var FCi = T0i - T2i;
-          out[C] = FCr;
-          out[C + 1] = FCi;
-          continue;
-        }
-        if (i === hquarterLen)
-          continue;
-        var ST0r = T1r;
-        var ST0i = -T1i;
-        var ST1r = T0r;
-        var ST1i = -T0i;
-        var ST2r = -inv * T3i;
-        var ST2i = -inv * T3r;
-        var ST3r = -inv * T2i;
-        var ST3i = -inv * T2r;
-        var SFAr = ST0r + ST2r;
-        var SFAi = ST0i + ST2i;
-        var SFBr = ST1r + ST3i;
-        var SFBi = ST1i - ST3r;
-        var SA = outOff + quarterLen - i;
-        var SB = outOff + halfLen - i;
-        out[SA] = SFAr;
-        out[SA + 1] = SFAi;
-        out[SB] = SFBr;
-        out[SB + 1] = SFBi;
-      }
-    }
-  }
-};
-FFT.prototype._singleRealTransform2 = function _singleRealTransform2(outOff, off, step2) {
-  const out = this._out;
-  const data = this._data;
-  const evenR = data[off];
-  const oddR = data[off + step2];
-  const leftR = evenR + oddR;
-  const rightR = evenR - oddR;
-  out[outOff] = leftR;
-  out[outOff + 1] = 0;
-  out[outOff + 2] = rightR;
-  out[outOff + 3] = 0;
-};
-FFT.prototype._singleRealTransform4 = function _singleRealTransform4(outOff, off, step2) {
-  const out = this._out;
-  const data = this._data;
-  const inv = this._inv ? -1 : 1;
-  const step22 = step2 * 2;
-  const step3 = step2 * 3;
-  const Ar = data[off];
-  const Br = data[off + step2];
-  const Cr = data[off + step22];
-  const Dr = data[off + step3];
-  const T0r = Ar + Cr;
-  const T1r = Ar - Cr;
-  const T2r = Br + Dr;
-  const T3r = inv * (Br - Dr);
-  const FAr = T0r + T2r;
-  const FBr = T1r;
-  const FBi = -T3r;
-  const FCr = T0r - T2r;
-  const FDr = T1r;
-  const FDi = T3r;
-  out[outOff] = FAr;
-  out[outOff + 1] = 0;
-  out[outOff + 2] = FBr;
-  out[outOff + 3] = FBi;
-  out[outOff + 4] = FCr;
-  out[outOff + 5] = 0;
-  out[outOff + 6] = FDr;
-  out[outOff + 7] = FDi;
-};
-const FFT$1 = /* @__PURE__ */ getDefaultExportFromCjs(fft);
-const INSTRUMENTS = ["kick", "snare", "hat"];
-const SAMPLE_RATE = 60;
-const TAP_TIMEOUT_MS = 5e3;
-const MAX_CYCLE_LENGTH = 8;
-const FUZZY_TOLERANCE = 0.18;
-const MIN_REPETITIONS = 3;
-const MAX_TAP_INTERVAL_MS = 3e3;
-const MIN_TAP_INTERVAL_MS = 100;
-const MAX_TAP_HISTORY = 64;
-const MIN_EMA_ALPHA = 0.05;
-const PATTERN_SAME_TOLERANCE = 0.15;
-function createInstrumentState() {
-  return {
-    mode: "auto",
-    muted: false,
-    mutedAt: 0,
-    tapIOIs: [],
-    lastTapTime: 0,
-    pattern: null,
-    refinementIndex: 0,
-    refinementCounts: [],
-    replayLastEventTime: 0,
-    replayIndex: 0,
-    pendingTapEvents: [],
-    envelope: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    envelopeSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE)
-  };
-}
-class OnsetTapManager {
-  state = {
-    kick: createInstrumentState(),
-    snare: createInstrumentState(),
-    hat: createInstrumentState()
-  };
-  tap(instrument) {
-    const s = this.state[instrument];
-    const now = performance.now();
-    if (s.muted) {
-      s.muted = false;
-      s.mutedAt = 0;
-    }
-    let ioi = -1;
-    if (s.lastTapTime > 0) {
-      ioi = now - s.lastTapTime;
-      if (ioi < MIN_TAP_INTERVAL_MS) return;
-      if (ioi > MAX_TAP_INTERVAL_MS) {
-        s.tapIOIs = [];
-        ioi = -1;
-      } else {
-        s.tapIOIs.push(ioi);
-        if (s.tapIOIs.length > MAX_TAP_HISTORY) s.tapIOIs.shift();
-      }
-    }
-    s.lastTapTime = now;
-    s.pendingTapEvents.push(now);
-    if (s.mode === "auto") {
-      s.mode = "tapping";
-      if (ioi > 0) {
-        const pattern = this.tryRecognizePattern(instrument);
-        if (pattern) this.applyPattern(instrument, pattern);
-      }
-    } else if (s.mode === "tapping") {
-      if (ioi > 0) {
-        const pattern = this.tryRecognizePattern(instrument);
-        if (pattern) this.applyPattern(instrument, pattern);
-      }
-    } else if (s.mode === "pattern") {
-      if (ioi > 0) {
-        this.handlePatternTap(instrument, ioi, now);
-      }
-    }
-  }
-  clear(instrument) {
-    const s = this.state[instrument];
-    s.mode = "auto";
-    s.muted = false;
-    s.mutedAt = 0;
-    s.tapIOIs = [];
-    s.lastTapTime = 0;
-    s.pattern = null;
-    s.refinementIndex = 0;
-    s.refinementCounts = [];
-    s.replayLastEventTime = 0;
-    s.replayIndex = 0;
-    s.pendingTapEvents = [];
-    s.envelope.reset();
-    s.envelopeSmoothed.reset();
-  }
-  getMode(instrument) {
-    return this.state[instrument].mode;
-  }
-  getPatternInfo(instrument) {
-    const s = this.state[instrument];
-    if (!s.pattern) return null;
-    return {
-      length: s.pattern.length,
-      intervals: [...s.pattern],
-      confidence: 1
-    };
-  }
-  setMuted(instrument, muted) {
-    const s = this.state[instrument];
-    if (s.muted === muted) return;
-    const now = performance.now();
-    if (muted) {
-      s.muted = true;
-      s.mutedAt = now;
-    } else {
-      const pauseDuration = now - s.mutedAt;
-      s.muted = false;
-      s.mutedAt = 0;
-      if (s.mode === "tapping" && s.lastTapTime > 0) {
-        s.lastTapTime += pauseDuration;
-      }
-    }
-  }
-  isMuted(instrument) {
-    return this.state[instrument].muted;
-  }
-  /**
-   * Post-process a beat state produced by BeatStateManager.
-   * For instruments in auto mode, values pass through unchanged.
-   * For tapping/pattern instruments, auto events are suppressed and
-   * tap/pattern events + envelopes are injected instead.
-   */
-  processFrame(beatState, now, dtMs) {
-    const result = { ...beatState, events: [...beatState.events] };
-    const newEvents = [];
-    for (const inst of INSTRUMENTS) {
-      const s = this.state[inst];
-      if (s.muted) {
-        result.events = result.events.filter((e) => e.type !== inst);
-        s.pendingTapEvents = [];
-        if (s.mode === "pattern" && s.pattern && s.replayLastEventTime > 0) {
-          for (let i = 0; i < 3; i++) {
-            const interval = s.pattern[s.replayIndex % s.pattern.length];
-            if (now - s.replayLastEventTime >= interval) {
-              s.replayLastEventTime += interval;
-              s.replayIndex = (s.replayIndex + 1) % s.pattern.length;
-            } else {
-              break;
-            }
-          }
-        }
-        s.envelope.process(0, dtMs);
-        s.envelopeSmoothed.process(0, dtMs);
-        const envKey2 = inst;
-        const smoothKey2 = `${inst}Smoothed`;
-        result[envKey2] = s.envelope.getValue();
-        result[smoothKey2] = s.envelopeSmoothed.getValue();
-        continue;
-      }
-      if (s.mode === "auto") {
-        s.envelope.process(0, dtMs);
-        s.envelopeSmoothed.process(0, dtMs);
-        continue;
-      }
-      result.events = result.events.filter((e) => e.type !== inst);
-      if (s.mode === "tapping") {
-        if (now - s.lastTapTime > TAP_TIMEOUT_MS) {
-          s.tapIOIs = [];
-          s.pendingTapEvents = [];
-          if (s.pattern) {
-            s.mode = "pattern";
-            s.replayLastEventTime = now;
-            s.replayIndex = 0;
-          } else {
-            s.mode = "auto";
-          }
+        var FBr = T1r + T3i;
+        var FBi = T1i - T3r;
+        out[A] = FAr;
+        out[A + 1] = FAi;
+        out[B] = FBr;
+        out[B + 1] = FBi;
+        if (i === 0) {
+          var FCr = T0r - T2r;
+          var FCi = T0i - T2i;
+          out[C] = FCr;
+          out[C + 1] = FCi;
           continue;
         }
-        while (s.pendingTapEvents.length > 0) {
-          const tapTime = s.pendingTapEvents.shift();
-          newEvents.push(this.createTapEvent(inst, tapTime, result.bpm));
-          s.envelope.trigger(1);
-          s.envelopeSmoothed.trigger(1);
-          s.replayLastEventTime = tapTime;
-          s.replayIndex = 0;
-        }
-      }
-      if (s.mode === "pattern") {
-        while (s.pendingTapEvents.length > 0) {
-          const tapTime = s.pendingTapEvents.shift();
-          newEvents.push(this.createTapEvent(inst, tapTime, result.bpm));
-          s.envelope.trigger(1);
-          s.envelopeSmoothed.trigger(1);
-        }
-        const isUserActive = now - s.lastTapTime < 500;
-        if (!isUserActive && s.pattern) {
-          const scheduled = this.checkPatternReplay(s, inst, now, result.bpm);
-          for (const ev of scheduled) {
-            newEvents.push(ev);
-            s.envelope.trigger(1);
-            s.envelopeSmoothed.trigger(1);
-          }
-        }
+        if (i === hquarterLen)
+          continue;
+        var ST0r = T1r;
+        var ST0i = -T1i;
+        var ST1r = T0r;
+        var ST1i = -T0i;
+        var ST2r = -inv * T3i;
+        var ST2i = -inv * T3r;
+        var ST3r = -inv * T2i;
+        var ST3i = -inv * T2r;
+        var SFAr = ST0r + ST2r;
+        var SFAi = ST0i + ST2i;
+        var SFBr = ST1r + ST3i;
+        var SFBi = ST1i - ST3r;
+        var SA = outOff + quarterLen - i;
+        var SB = outOff + halfLen - i;
+        out[SA] = SFAr;
+        out[SA + 1] = SFAi;
+        out[SB] = SFBr;
+        out[SB + 1] = SFBi;
       }
-      s.envelope.process(0, dtMs);
-      s.envelopeSmoothed.process(0, dtMs);
-      const envKey = inst;
-      const smoothKey = `${inst}Smoothed`;
-      result[envKey] = s.envelope.getValue();
-      result[smoothKey] = s.envelopeSmoothed.getValue();
     }
-    result.events.push(...newEvents);
-    const anyMax = Math.max(
-      result.kick,
-      result.snare,
-      result.hat
-    );
-    const anySmoothedMax = Math.max(
-      result.kickSmoothed,
-      result.snareSmoothed,
-      result.hatSmoothed
-    );
-    if (anyMax > result.any) result.any = anyMax;
-    if (anySmoothedMax > result.anySmoothed) result.anySmoothed = anySmoothedMax;
-    return result;
   }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Handle a tap that arrives while already in pattern mode.
-   * Matching taps refine the pattern via EMA and re-anchor phase.
-   * Non-matching taps trigger new pattern detection on the full IOI history.
-   */
-  handlePatternTap(instrument, ioi, now) {
-    const s = this.state[instrument];
-    if (!s.pattern) return;
-    const matchedPos = this.findMatchingPosition(s, ioi);
-    if (matchedPos >= 0) {
-      s.refinementCounts[matchedPos] = (s.refinementCounts[matchedPos] || 0) + 1;
-      const alpha = Math.max(MIN_EMA_ALPHA, 1 / s.refinementCounts[matchedPos]);
-      s.pattern[matchedPos] = (1 - alpha) * s.pattern[matchedPos] + alpha * ioi;
-      s.refinementIndex = (matchedPos + 1) % s.pattern.length;
-      s.replayLastEventTime = now;
-      s.replayIndex = s.refinementIndex;
-    } else {
-      const currentPattern = [...s.pattern];
-      const newPattern = this.tryRecognizePattern(instrument);
-      if (newPattern && !this.isPatternSame(newPattern, currentPattern)) {
-        this.applyPattern(instrument, newPattern);
-      }
-    }
+};
+FFT.prototype._singleRealTransform2 = function _singleRealTransform2(outOff, off, step2) {
+  const out = this._out;
+  const data = this._data;
+  const evenR = data[off];
+  const oddR = data[off + step2];
+  const leftR = evenR + oddR;
+  const rightR = evenR - oddR;
+  out[outOff] = leftR;
+  out[outOff + 1] = 0;
+  out[outOff + 2] = rightR;
+  out[outOff + 3] = 0;
+};
+FFT.prototype._singleRealTransform4 = function _singleRealTransform4(outOff, off, step2) {
+  const out = this._out;
+  const data = this._data;
+  const inv = this._inv ? -1 : 1;
+  const step22 = step2 * 2;
+  const step3 = step2 * 3;
+  const Ar = data[off];
+  const Br = data[off + step2];
+  const Cr = data[off + step22];
+  const Dr = data[off + step3];
+  const T0r = Ar + Cr;
+  const T1r = Ar - Cr;
+  const T2r = Br + Dr;
+  const T3r = inv * (Br - Dr);
+  const FAr = T0r + T2r;
+  const FBr = T1r;
+  const FBi = -T3r;
+  const FCr = T0r - T2r;
+  const FDr = T1r;
+  const FDi = T3r;
+  out[outOff] = FAr;
+  out[outOff + 1] = 0;
+  out[outOff + 2] = FBr;
+  out[outOff + 3] = FBi;
+  out[outOff + 4] = FCr;
+  out[outOff + 5] = 0;
+  out[outOff + 6] = FDr;
+  out[outOff + 7] = FDi;
+};
+const FFT$1 = /* @__PURE__ */ getDefaultExportFromCjs(fft);
+class AudioChannel {
+  // Identity
+  streamIndex;
+  // Web Audio nodes (owned per-channel, connected to shared AudioContext)
+  mediaStreamSource = null;
+  analyser = null;
+  workletNode = null;
+  analysisMode = "analyser";
+  workletReady = false;
+  currentStream = null;
+  // FFT resources
+  fftSize;
+  fftEngine = null;
+  fftInput = null;
+  fftOutput = null;
+  hannWindow = null;
+  frequencyData = null;
+  fftMagnitude = null;
+  fftMagnitudeDb = null;
+  fftPhase = null;
+  timeDomainData = null;
+  // Auto-gain normalization
+  volumeAutoGain;
+  bandAutoGain;
+  // Envelope followers for band/volume smoothing
+  envelopeFollowers;
+  // Per-channel noise floor tracking
+  bandNoiseFloor = {
+    low: 1e-4,
+    lowMid: 1e-4,
+    mid: 1e-4,
+    highMid: 1e-4,
+    high: 1e-4
+  };
+  // Analysis state
+  audioState = {
+    isConnected: false,
+    volume: { current: 0, peak: 0, smoothed: 0 },
+    bands: {
+      low: 0,
+      lowMid: 0,
+      mid: 0,
+      highMid: 0,
+      high: 0,
+      lowSmoothed: 0,
+      lowMidSmoothed: 0,
+      midSmoothed: 0,
+      highMidSmoothed: 0,
+      highSmoothed: 0
+    },
+    spectral: { brightness: 0, flatness: 0 }
+  };
+  // Waveform data for transfer to worker
+  lastWaveformFrame = null;
+  // Analysis loop state
+  isAnalysisRunning = false;
+  workletFrameCount = 0;
+  lastFrameTime = 0;
+  lastAnalysisTimestamp = 0;
+  lastDtMs = 0;
+  analysisTicks = 0;
+  currentSampleRate = 44100;
+  constructor(streamIndex, fftSize) {
+    this.streamIndex = streamIndex;
+    this.fftSize = fftSize;
+    this.volumeAutoGain = new AutoGain(3e3, 60);
+    this.bandAutoGain = {
+      low: new AutoGain(3e3, 60),
+      lowMid: new AutoGain(3e3, 60),
+      mid: new AutoGain(3e3, 60),
+      highMid: new AutoGain(3e3, 60),
+      high: new AutoGain(3e3, 60)
+    };
+    const sampleRate = 60;
+    this.envelopeFollowers = {
+      volumeSmoothed: new EnvelopeFollower(50, 200, sampleRate),
+      lowSmoothed: new EnvelopeFollower(20, 150, sampleRate),
+      lowMidSmoothed: new EnvelopeFollower(20, 150, sampleRate),
+      midSmoothed: new EnvelopeFollower(20, 150, sampleRate),
+      highMidSmoothed: new EnvelopeFollower(20, 150, sampleRate),
+      highSmoothed: new EnvelopeFollower(20, 150, sampleRate)
+    };
+    this.refreshFFTResources();
   }
-  /**
-   * Find which pattern position the given IOI matches.
-   * Tries the expected refinementIndex first, then scans all positions.
-   * Returns the matched position index, or -1 if no match.
-   */
-  findMatchingPosition(s, ioi) {
-    if (!s.pattern) return -1;
-    const expectedPos = s.refinementIndex % s.pattern.length;
-    const expectedInterval = s.pattern[expectedPos];
-    if (Math.abs(ioi - expectedInterval) / expectedInterval <= FUZZY_TOLERANCE) {
-      return expectedPos;
-    }
-    let bestPos = -1;
-    let bestDeviation = Infinity;
-    for (let i = 0; i < s.pattern.length; i++) {
-      if (i === expectedPos) continue;
-      const deviation = Math.abs(ioi - s.pattern[i]) / s.pattern[i];
-      if (deviation <= FUZZY_TOLERANCE && deviation < bestDeviation) {
-        bestDeviation = deviation;
-        bestPos = i;
-      }
-    }
-    return bestPos;
+  static create(streamIndex, fftSize = 2048) {
+    return new AudioChannel(streamIndex, fftSize);
   }
-  /**
-   * Compare two patterns for equivalence.
-   * Same length and each interval within PATTERN_SAME_TOLERANCE → same.
-   */
-  isPatternSame(a, b) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (Math.abs(a[i] - b[i]) / Math.max(a[i], b[i]) > PATTERN_SAME_TOLERANCE) return false;
+  refreshFFTResources() {
+    const binCount = this.fftSize / 2;
+    this.frequencyData = new Uint8Array(binCount);
+    this.fftMagnitude = new Float32Array(binCount);
+    this.fftMagnitudeDb = new Float32Array(binCount);
+    this.fftPhase = new Float32Array(binCount);
+    this.timeDomainData = new Float32Array(this.fftSize);
+    this.fftEngine = new FFT$1(this.fftSize);
+    this.fftInput = new Float32Array(this.fftSize * 2);
+    this.fftOutput = new Float32Array(this.fftSize * 2);
+    this.hannWindow = new Float32Array(this.fftSize);
+    const twoPi = Math.PI * 2;
+    for (let i = 0; i < this.fftSize; i++) {
+      this.hannWindow[i] = 0.5 * (1 - Math.cos(twoPi * i / (this.fftSize - 1)));
     }
-    return true;
+    this.analysisTicks = 0;
+    this.workletFrameCount = 0;
   }
-  /**
-   * Pattern recognition: find the shortest repeating IOI cycle
-   * that has been tapped at least MIN_REPETITIONS times.
-   * Returns the recognized pattern as float intervals, or null.
-   * Does NOT mutate state — caller decides what to do with the result.
-   */
-  tryRecognizePattern(instrument) {
-    const s = this.state[instrument];
-    const iois = s.tapIOIs;
-    if (iois.length < MIN_REPETITIONS) return null;
-    const maxL = Math.min(MAX_CYCLE_LENGTH, Math.floor(iois.length / MIN_REPETITIONS));
-    for (let L = 1; L <= maxL; L++) {
-      const needed = MIN_REPETITIONS * L;
-      if (iois.length < needed) continue;
-      const tolerance = L <= 2 ? FUZZY_TOLERANCE : FUZZY_TOLERANCE * (2 / L);
-      const recent = iois.slice(-needed);
-      const groups = [];
-      for (let g = 0; g < MIN_REPETITIONS; g++) {
-        groups.push(recent.slice(g * L, (g + 1) * L));
-      }
-      const avgGroup = groups[0].map((_, i) => {
-        let sum = 0;
-        for (const grp of groups) sum += grp[i];
-        return sum / groups.length;
-      });
-      let allMatch = true;
-      for (const grp of groups) {
-        for (let i = 0; i < L; i++) {
-          const deviation = Math.abs(grp[i] - avgGroup[i]) / avgGroup[i];
-          if (deviation > tolerance) {
-            allMatch = false;
-            break;
-          }
-        }
-        if (!allMatch) break;
-      }
-      if (allMatch) {
-        return avgGroup;
-      }
+  resetValues() {
+    this.audioState.volume.current = 0;
+    this.audioState.volume.peak = 0;
+    this.audioState.volume.smoothed = 0;
+    this.audioState.bands.low = 0;
+    this.audioState.bands.lowMid = 0;
+    this.audioState.bands.mid = 0;
+    this.audioState.bands.highMid = 0;
+    this.audioState.bands.high = 0;
+    this.audioState.bands.lowSmoothed = 0;
+    this.audioState.bands.lowMidSmoothed = 0;
+    this.audioState.bands.midSmoothed = 0;
+    this.audioState.bands.highMidSmoothed = 0;
+    this.audioState.bands.highSmoothed = 0;
+    this.audioState.spectral.brightness = 0;
+    this.audioState.spectral.flatness = 0;
+  }
+  disconnectNodes() {
+    if (this.mediaStreamSource) {
+      this.mediaStreamSource.disconnect();
+      this.mediaStreamSource = null;
     }
-    return null;
-  }
-  /**
-   * Apply a recognized pattern to the instrument state.
-   * Sets pattern, mode, and initializes replay anchor.
-   */
-  applyPattern(instrument, pattern) {
-    const s = this.state[instrument];
-    s.pattern = pattern;
-    s.mode = "pattern";
-    s.refinementIndex = 0;
-    s.refinementCounts = new Array(pattern.length).fill(MIN_REPETITIONS);
-    if (s.replayLastEventTime === 0 || s.replayLastEventTime < s.lastTapTime) {
-      s.replayLastEventTime = s.lastTapTime;
-      s.replayIndex = 0;
+    if (this.analyser) {
+      this.analyser.disconnect();
+      this.analyser = null;
     }
-  }
-  createTapEvent(instrument, time, bpm) {
-    return {
-      type: instrument,
-      time,
-      strength: 0.85,
-      isPredicted: false,
-      bpm
-    };
-  }
-  checkPatternReplay(s, instrument, now, bpm) {
-    if (!s.pattern || s.pattern.length === 0) return [];
-    const events = [];
-    const maxEventsPerFrame = 3;
-    for (let safety = 0; safety < maxEventsPerFrame; safety++) {
-      const expectedInterval = s.pattern[s.replayIndex % s.pattern.length];
-      const elapsed = now - s.replayLastEventTime;
-      if (elapsed >= expectedInterval) {
-        s.replayLastEventTime += expectedInterval;
-        s.replayIndex = (s.replayIndex + 1) % s.pattern.length;
-        events.push({
-          type: instrument,
-          time: s.replayLastEventTime,
-          strength: 0.8,
-          isPredicted: true,
-          bpm
-        });
-      } else {
-        break;
+    if (this.workletNode) {
+      try {
+        this.workletNode.port.onmessage = null;
+        this.workletNode.disconnect();
+      } catch (_) {
       }
+      this.workletNode = null;
     }
-    return events;
+    this.workletReady = false;
+    this.analysisMode = "analyser";
   }
-  reset() {
-    for (const inst of INSTRUMENTS) {
-      this.clear(inst);
-    }
+  destroy() {
+    this.disconnectNodes();
+    this.frequencyData = null;
+    this.timeDomainData = null;
+    this.fftMagnitude = null;
+    this.fftMagnitudeDb = null;
+    this.fftPhase = null;
+    this.fftEngine = null;
+    this.fftInput = null;
+    this.fftOutput = null;
+    this.hannWindow = null;
+    this.lastWaveformFrame = null;
+    this.currentStream = null;
+    this.isAnalysisRunning = false;
+    this.audioState.isConnected = false;
+    this.resetValues();
   }
 }
 class AudioSystem {
-  // Audio context and analysis nodes
+  // Shared AudioContext (one for all channels)
   audioContext = null;
-  analyser = null;
-  mediaStreamSource = null;
-  currentStream = null;
-  analysisMode = "analyser";
-  workletNode = null;
-  workletReady = false;
   workletRegistered = false;
-  currentSampleRate = 44100;
-  bandNoiseFloor = {
-    low: 1e-4,
-    lowMid: 1e-4,
-    mid: 1e-4,
-    highMid: 1e-4,
-    high: 1e-4
-  };
+  // Main audio channel (index 0, full analysis with beat detection)
+  mainChannel;
+  // Additional audio channels (lightweight analysis, no beat detection)
+  additionalChannels = /* @__PURE__ */ new Map();
+  // Shared analysis timer (one interval for all analyser-mode channels)
+  analysisInterval = null;
+  analysisIntervalMs = 8;
+  // Staleness timer (shared across all channels)
+  stalenessTimer = null;
+  static STALENESS_THRESHOLD_MS = 500;
+  // Beat-specific state (main channel only)
   /** Tracks the last non-zero BPM chosen for output to avoid dropping to 0 */
   lastNonZeroBpm = 120;
   /** Tracks which source provided the current BPM (pll | tempo | carry | default) */
   lastBpmSource = "default";
-  workletFrameCount = 0;
-  lastFrameTime = 0;
-  stalenessTimer = null;
-  static STALENESS_THRESHOLD_MS = 500;
-  analysisTicks = 0;
   lastPhaseLogTime = 0;
   onsetLogBuffer = [];
   // Debug logging control
@@ -12671,10 +12823,7 @@ class AudioSystem {
   stateManager;
   // Previous frame's kick detection (for PLL sync with 1-frame lag)
   lastKickDetected = false;
-  // Auto-gain normalization
-  volumeAutoGain;
-  bandAutoGain;
-  /** Raw band snapshot before auto-gain (for debug) */
+  /** Raw band snapshot before auto-gain (for debug, main channel only) */
   rawBandsPreGain = {
     low: 0,
     lowMid: 0,
@@ -12682,16 +12831,13 @@ class AudioSystem {
     highMid: 0,
     high: 0
   };
-  /** Last dt used in analysis loop (ms) */
-  lastDtMs = 0;
-  /** Flag to track if we've logged detection method (to avoid spam) */
   bandNames = ["low", "lowMid", "mid", "highMid", "high"];
   essentiaBandHistories = /* @__PURE__ */ new Map();
   essentiaHistoryWindowMs = 5e3;
   // Per-instrument onset tap manager
   onsetTapManager;
-  // Envelope followers for smooth energy curves
-  envelopeFollowers;
+  // Beat-specific envelope followers (main channel only, managed by BeatStateManager)
+  beatEnvelopeFollowers;
   // Feature enable flags
   beatDetectionEnabled = true;
   onsetDetectionEnabled = true;
@@ -12747,80 +12893,94 @@ class AudioSystem {
     return clone;
   }
   /**
-   * Handle frames pushed from AudioWorklet
+   * Handle frames pushed from AudioWorklet for main channel
+   */
+  handleMainWorkletFrame(frame, sampleRate, timestampMs) {
+    if (!this.mainChannel.isAnalysisRunning) return;
+    this.mainChannel.workletFrameCount++;
+    this.analyzeMainFrame(frame, sampleRate || this.mainChannel.currentSampleRate, timestampMs || performance.now());
+  }
+  /**
+   * Handle frames pushed from AudioWorklet for an additional channel
    */
-  handleWorkletFrame(frame, sampleRate, timestampMs) {
-    if (!this.isAnalysisRunning) return;
-    this.workletFrameCount++;
-    this.analyzeFrame(frame, sampleRate || this.currentSampleRate, timestampMs || performance.now());
+  handleAdditionalWorkletFrame(channel, frame, sampleRate, timestampMs) {
+    if (!channel.isAnalysisRunning) return;
+    channel.workletFrameCount++;
+    this.analyzeAdditionalFrame(channel, frame, sampleRate || channel.currentSampleRate, timestampMs || performance.now());
   }
   /**
-   * Unified analysis pipeline (worklet and analyser paths)
+   * Common analysis pipeline for any channel (FFT, volume, bands, auto-gain, spectral, smoothing).
+   * Returns raw band energies (pre-auto-gain) for optional beat processing by the caller.
    */
-  analyzeFrame(frame, sampleRate, timestampMs) {
-    if (!frame || frame.length === 0) return;
-    this.lastFrameTime = performance.now();
-    if (this.workletFrameCount === 1) {
-      this.debugLog("[AudioSystem] First frame received", { sampleRate, mode: this.analysisMode });
+  analyzeChannelFrame(ch, frame, sampleRate, timestampMs) {
+    if (!frame || frame.length === 0) return null;
+    ch.lastFrameTime = performance.now();
+    ch.analysisTicks++;
+    if (ch.workletFrameCount === 1) {
+      this.debugLog(`[AudioSystem] First frame received for channel ${ch.streamIndex}`, { sampleRate, mode: ch.analysisMode });
     }
-    const dtMs = this.lastAnalysisTimestamp > 0 ? timestampMs - this.lastAnalysisTimestamp : 1e3 / 60;
-    this.lastAnalysisTimestamp = timestampMs;
-    this.lastDtMs = dtMs;
-    this.currentSampleRate = sampleRate;
+    const dtMs = ch.lastAnalysisTimestamp > 0 ? timestampMs - ch.lastAnalysisTimestamp : 1e3 / 60;
+    ch.lastAnalysisTimestamp = timestampMs;
+    ch.lastDtMs = dtMs;
+    ch.currentSampleRate = sampleRate;
     const { rms, peak } = this.calculateVolumeMetrics(frame);
-    this.audioState.volume.current = rms;
-    this.audioState.volume.peak = peak;
-    this.lastWaveformFrame = frame;
-    const fftResult = this.computeFFT(frame);
-    if (!fftResult) {
-      if (this.debugMode && (this.analysisTicks === 1 || this.analysisTicks % 240 === 0)) {
-        this.debugLog("[AudioSystem][analyzeFrame] computeFFT returned null at tick", this.analysisTicks);
-      }
-      return;
-    }
-    const { magnitudes, magnitudesDb, phases, frequencyData, maxMagnitude } = fftResult;
-    this.frequencyData = frequencyData;
-    this.fftMagnitude = magnitudes;
-    this.fftMagnitudeDb = magnitudesDb;
-    this.fftPhase = phases;
-    const bandEnergies = this.calculateFrequencyBandsFromMagnitude(magnitudes, sampleRate, maxMagnitude);
-    const isSilent = maxMagnitude <= 1e-7 || this.audioState.volume.current <= 1e-6;
+    ch.audioState.volume.current = rms;
+    ch.audioState.volume.peak = peak;
+    ch.lastWaveformFrame = frame;
+    const fftResult = this.computeChannelFFT(ch, frame);
+    if (!fftResult) return null;
+    const { magnitudes, maxMagnitude } = fftResult;
+    const bandEnergies = this.calculateChannelBands(ch, magnitudes, sampleRate, maxMagnitude);
+    const isSilent = maxMagnitude <= 1e-7 || ch.audioState.volume.current <= 1e-6;
     if (isSilent) {
-      this.audioState.bands = {
-        ...this.audioState.bands,
+      ch.audioState.bands = {
+        ...ch.audioState.bands,
         low: 0,
         lowMid: 0,
         mid: 0,
         highMid: 0,
         high: 0
       };
-      this.rawBandsPreGain = { low: 0, lowMid: 0, mid: 0, highMid: 0, high: 0 };
-      this.audioState.spectral = { brightness: 0, flatness: 0 };
-      const decayed = this.stateManager.processEnvelopeDecay(dtMs);
-      this.audioState.beat.kick = decayed.kick;
-      this.audioState.beat.snare = decayed.snare;
-      this.audioState.beat.hat = decayed.hat;
-      this.audioState.beat.any = decayed.any;
-      this.audioState.beat.kickSmoothed = decayed.kickSmoothed;
-      this.audioState.beat.snareSmoothed = decayed.snareSmoothed;
-      this.audioState.beat.hatSmoothed = decayed.hatSmoothed;
-      this.audioState.beat.anySmoothed = decayed.anySmoothed;
-      this.audioState.beat.events = [];
-      this.updateSmoothBands(dtMs);
-      this.sendAnalysisResultsToWorker();
-      return;
+      ch.audioState.spectral = { brightness: 0, flatness: 0 };
+      this.updateChannelSmoothBands(ch, dtMs);
+      return null;
     }
-    this.rawBandsPreGain = { ...bandEnergies };
     if (this.autoGainEnabled) {
-      this.applyAutoGain();
+      this.applyChannelAutoGain(ch);
+    }
+    this.calculateChannelSpectral(ch, magnitudes, sampleRate, maxMagnitude);
+    this.updateChannelSmoothBands(ch, dtMs);
+    return bandEnergies;
+  }
+  /**
+   * Full analysis for the main channel (common analysis + beat pipeline).
+   */
+  analyzeMainFrame(frame, sampleRate, timestampMs) {
+    const ch = this.mainChannel;
+    const rawBands = this.analyzeChannelFrame(ch, frame, sampleRate, timestampMs);
+    const dtMs = ch.lastDtMs;
+    if (!rawBands) {
+      const decayed = this.stateManager.processEnvelopeDecay(dtMs);
+      this.audioStateBeat.kick = decayed.kick;
+      this.audioStateBeat.snare = decayed.snare;
+      this.audioStateBeat.hat = decayed.hat;
+      this.audioStateBeat.any = decayed.any;
+      this.audioStateBeat.kickSmoothed = decayed.kickSmoothed;
+      this.audioStateBeat.snareSmoothed = decayed.snareSmoothed;
+      this.audioStateBeat.hatSmoothed = decayed.hatSmoothed;
+      this.audioStateBeat.anySmoothed = decayed.anySmoothed;
+      this.audioStateBeat.events = [];
+      this.rawBandsPreGain = { low: 0, lowMid: 0, mid: 0, highMid: 0, high: 0 };
+      this.sendChannelResults(ch, true);
+      return;
     }
-    this.calculateSpectralFeaturesFromMagnitude(magnitudes, sampleRate, maxMagnitude);
+    this.rawBandsPreGain = { ...rawBands };
     if (this.onsetDetectionEnabled && this.beatDetectionEnabled) {
-      const beatState = this.runBeatPipeline(bandEnergies, dtMs, timestampMs, sampleRate);
+      const beatState = this.runBeatPipeline(rawBands, dtMs, timestampMs, sampleRate);
       if (beatState) {
         const { phase: _phase, bar: _bar, debug: _debug, ...beatForState } = beatState;
         const now = performance.now();
-        this.audioState.beat = this.onsetTapManager.processFrame(beatForState, now, dtMs);
+        this.audioStateBeat = this.onsetTapManager.processFrame(beatForState, now, dtMs);
         if (this.debugMode) {
           const pllState = this.pll.getState();
           const currentState = this.stateManager.getState();
@@ -12835,9 +12995,7 @@ class AudioSystem {
           if (bpmVariance !== void 0) trackingData.bpmVariance = bpmVariance;
           const compressed = this.stateManager.isCompressed();
           if (compressed) trackingData.compressed = compressed;
-          if (beatState.events.some((e) => e.type === "kick")) {
-            trackingData.kickPhase = pllState.phase;
-          }
+          if (beatState.events.some((e) => e.type === "kick")) trackingData.kickPhase = pllState.phase;
           if (beatState.debug?.pllGain !== void 0) trackingData.pllGain = beatState.debug.pllGain;
           if (beatState.debug?.tempoConfidence !== void 0) trackingData.tempoConf = beatState.debug.tempoConfidence;
           if (beatState.debug?.trackingConfidence !== void 0) trackingData.trackingConf = beatState.debug.trackingConfidence;
@@ -12855,11 +13013,11 @@ class AudioSystem {
               state: currentState
             },
             {
-              low: this.audioState.bands.low,
-              lowMid: this.audioState.bands.lowMid,
-              mid: this.audioState.bands.mid,
-              highMid: this.audioState.bands.highMid,
-              high: this.audioState.bands.high
+              low: ch.audioState.bands.low,
+              lowMid: ch.audioState.bands.lowMid,
+              mid: ch.audioState.bands.mid,
+              highMid: ch.audioState.bands.highMid,
+              high: ch.audioState.bands.high
             },
             this.stateManager.getLastRejections(),
             trackingData
@@ -12867,70 +13025,62 @@ class AudioSystem {
         }
       }
     }
-    this.updateSmoothBands(dtMs);
-    this.sendAnalysisResultsToWorker();
+    this.sendChannelResults(ch, true);
+  }
+  /**
+   * Lightweight analysis for additional/device channels (no beat detection).
+   */
+  analyzeAdditionalFrame(channel, frame, sampleRate, timestampMs) {
+    this.analyzeChannelFrame(channel, frame, sampleRate, timestampMs);
+    this.sendChannelResults(channel, false);
   }
   /**
-   * Compute FFT and derived arrays
+   * Compute FFT on a specific channel's buffers
    */
-  computeFFT(frame) {
-    if (!this.fftEngine || !this.fftInput || !this.fftOutput || !this.hannWindow || !this.frequencyData || !this.fftMagnitude || !this.fftMagnitudeDb || !this.fftPhase) {
-      if (this.debugMode && (this.analysisTicks === 1 || this.analysisTicks % 240 === 0)) {
-        this.debugLog("[AudioSystem][computeFFT] RETURNING NULL - resources missing at tick", this.analysisTicks);
+  computeChannelFFT(ch, frame) {
+    if (!ch.fftEngine || !ch.fftInput || !ch.fftOutput || !ch.hannWindow || !ch.frequencyData || !ch.fftMagnitude || !ch.fftMagnitudeDb || !ch.fftPhase) {
+      if (this.debugMode && (ch.analysisTicks === 1 || ch.analysisTicks % 240 === 0)) {
+        this.debugLog(`[AudioSystem][computeFFT] RETURNING NULL - resources missing at tick ${ch.analysisTicks}, channel ${ch.streamIndex}`);
       }
       return null;
     }
-    const binCount = this.fftSize / 2;
-    const input = this.fftInput;
-    const output = this.fftOutput;
+    const binCount = ch.fftSize / 2;
+    const input = ch.fftInput;
+    const output = ch.fftOutput;
     input.fill(0);
-    const frameLength = Math.min(frame.length, this.fftSize);
-    let frameMax = 0;
-    for (let i = 0; i < Math.min(32, frame.length); i++) {
-      if (Math.abs(frame[i]) > frameMax) frameMax = Math.abs(frame[i]);
-    }
+    const frameLength = Math.min(frame.length, ch.fftSize);
     for (let i = 0; i < frameLength; i++) {
-      input[2 * i] = frame[i] * this.hannWindow[i];
+      input[2 * i] = frame[i] * ch.hannWindow[i];
       input[2 * i + 1] = 0;
     }
-    let inputMax = 0;
-    for (let i = 0; i < Math.min(64, input.length); i += 2) {
-      if (Math.abs(input[i]) > inputMax) inputMax = Math.abs(input[i]);
-    }
-    this.fftEngine.transform(output, input);
-    let outputMax = 0;
-    for (let i = 0; i < Math.min(64, output.length); i++) {
-      if (Math.abs(output[i]) > outputMax) outputMax = Math.abs(output[i]);
-    }
+    ch.fftEngine.transform(output, input);
     let maxMagnitude = 0;
     for (let i = 0; i < binCount; i++) {
       const re = output[2 * i];
       const im = output[2 * i + 1];
-      const mag = Math.sqrt(re * re + im * im) / this.fftSize;
-      this.fftMagnitude[i] = mag;
-      if (mag > maxMagnitude) {
-        maxMagnitude = mag;
-      }
-      this.fftPhase[i] = Math.atan2(im, re);
+      const mag = Math.sqrt(re * re + im * im) / ch.fftSize;
+      ch.fftMagnitude[i] = mag;
+      if (mag > maxMagnitude) maxMagnitude = mag;
+      ch.fftPhase[i] = Math.atan2(im, re);
     }
     if (maxMagnitude <= 0) {
-      this.frequencyData.fill(0);
+      ch.frequencyData.fill(0);
       for (let i = 0; i < binCount; i++) {
-        this.fftMagnitudeDb[i] = 20 * Math.log10(this.fftMagnitude[i] + 1e-12);
+        ch.fftMagnitudeDb[i] = 20 * Math.log10(ch.fftMagnitude[i] + 1e-12);
       }
     } else {
       for (let i = 0; i < binCount; i++) {
-        const mag = this.fftMagnitude[i];
+        const mag = ch.fftMagnitude[i];
         const norm = mag / maxMagnitude;
-        this.frequencyData[i] = Math.min(255, Math.max(0, Math.round(norm * 255)));
-        this.fftMagnitudeDb[i] = 20 * Math.log10(mag + 1e-12);
+        ch.frequencyData[i] = Math.min(255, Math.max(0, Math.round(norm * 255)));
+        ch.fftMagnitudeDb[i] = 20 * Math.log10(mag + 1e-12);
       }
     }
     return {
-      magnitudes: this.fftMagnitude,
-      magnitudesDb: this.fftMagnitudeDb,
-      phases: this.fftPhase,
-      frequencyData: this.frequencyData,
+      magnitudes: ch.fftMagnitude,
+      magnitudesDb: ch.fftMagnitudeDb,
+      phases: ch.fftPhase,
+      frequencyData: ch.frequencyData,
       maxMagnitude
     };
   }
@@ -12950,9 +13100,9 @@ class AudioSystem {
     return { rms, peak };
   }
   /**
-   * Calculate perceptual/log-ish bands (pre-gain), normalized by max magnitude
+   * Calculate perceptual/log-ish bands on a specific channel
    */
-  calculateFrequencyBandsFromMagnitude(magnitudes, sampleRate, maxMagnitude) {
+  calculateChannelBands(ch, magnitudes, sampleRate, maxMagnitude) {
     const nyquist = sampleRate / 2;
     const binCount = magnitudes.length;
     const bands = {
@@ -12976,33 +13126,32 @@ class AudioSystem {
       const average = count > 0 ? sum / count : 0;
       const rawNormalized = maxMagnitude > 0 ? Math.min(1, average / maxMagnitude) : 0;
       rawBands[bandName] = rawNormalized;
-      const prevFloor = this.bandNoiseFloor[bandName] ?? 1e-4;
+      const prevFloor = ch.bandNoiseFloor[bandName] ?? 1e-4;
       const newFloor = prevFloor * 0.995 + average * 5e-3;
-      this.bandNoiseFloor[bandName] = newFloor;
+      ch.bandNoiseFloor[bandName] = newFloor;
       const floorAdjusted = Math.max(0, average - newFloor * 1.5);
       const normalized = maxMagnitude > 0 ? Math.min(1, floorAdjusted / maxMagnitude) : 0;
       normalizedBands[bandName] = normalized;
     }
-    this.audioState.bands = {
-      ...this.audioState.bands,
+    ch.audioState.bands = {
+      ...ch.audioState.bands,
       low: rawBands.low,
       lowMid: rawBands.lowMid,
       mid: rawBands.mid,
       highMid: rawBands.highMid,
       high: rawBands.high,
-      lowSmoothed: this.audioState.bands.lowSmoothed,
-      lowMidSmoothed: this.audioState.bands.lowMidSmoothed,
-      midSmoothed: this.audioState.bands.midSmoothed,
-      highMidSmoothed: this.audioState.bands.highMidSmoothed,
-      highSmoothed: this.audioState.bands.highSmoothed
+      lowSmoothed: ch.audioState.bands.lowSmoothed,
+      lowMidSmoothed: ch.audioState.bands.lowMidSmoothed,
+      midSmoothed: ch.audioState.bands.midSmoothed,
+      highMidSmoothed: ch.audioState.bands.highMidSmoothed,
+      highSmoothed: ch.audioState.bands.highSmoothed
     };
-    this.rawBandsPreGain = { ...rawBands };
     return normalizedBands;
   }
   /**
-   * Spectral features from magnitude spectrum
+   * Spectral features on a specific channel
    */
-  calculateSpectralFeaturesFromMagnitude(magnitudes, sampleRate, maxMagnitude) {
+  calculateChannelSpectral(ch, magnitudes, sampleRate, maxMagnitude) {
     const nyquist = sampleRate / 2;
     const binCount = magnitudes.length;
     let sumMagnitude = 0;
@@ -13014,7 +13163,7 @@ class AudioSystem {
       sumWeightedFreq += freq * magnitude;
     }
     const centroid = sumMagnitude > 0 ? sumWeightedFreq / sumMagnitude : 0;
-    this.audioState.spectral.brightness = Math.min(1, centroid / nyquist);
+    ch.audioState.spectral.brightness = Math.min(1, centroid / nyquist);
     let geometricMeanLog = 0;
     let arithmeticMeanSum = 0;
     let nonZeroCount = 0;
@@ -13029,9 +13178,9 @@ class AudioSystem {
     if (nonZeroCount > 0) {
       const arithmeticMean = arithmeticMeanSum / nonZeroCount;
       const geometricMean = Math.exp(geometricMeanLog / nonZeroCount);
-      this.audioState.spectral.flatness = Math.min(1, geometricMean / arithmeticMean);
+      ch.audioState.spectral.flatness = Math.min(1, geometricMean / arithmeticMean);
     } else {
-      this.audioState.spectral.flatness = 0;
+      ch.audioState.spectral.flatness = 0;
     }
   }
   /**
@@ -13039,12 +13188,12 @@ class AudioSystem {
    */
   runBeatPipeline(rawBandsForOnsets, dtMs, timestampMs, sampleRate) {
     let onsets;
-    const essentiaReady = (this.essentiaOnsetDetection?.isReady() || false) && !!this.fftMagnitudeDb && !!this.fftPhase;
-    const hasFftData = !!(this.fftMagnitudeDb && this.fftPhase);
+    const essentiaReady = (this.essentiaOnsetDetection?.isReady() || false) && !!this.mainChannel.fftMagnitudeDb && !!this.mainChannel.fftPhase;
+    const hasFftData = !!(this.mainChannel.fftMagnitudeDb && this.mainChannel.fftPhase);
     if (essentiaReady && hasFftData) {
       const essentiaResult = this.essentiaOnsetDetection.detectFromSpectrum(
-        this.fftMagnitudeDb,
-        this.fftPhase,
+        this.mainChannel.fftMagnitudeDb,
+        this.mainChannel.fftPhase,
         sampleRate
         // DO NOT pass normalized bands - causes false snare detections on kicks
         // Essentia should compute its own bands from spectrum for accurate ratios
@@ -13115,115 +13264,70 @@ class AudioSystem {
       console.log(`   Conf:   ${beatState.confidence.toFixed(2)}`);
       if (this.onsetLogBuffer.length > 0) {
         console.log(`🎵 Recent Onsets (last ${Math.min(10, this.onsetLogBuffer.length)}):`);
-        const recentOnsets = this.onsetLogBuffer.slice(-10);
-        recentOnsets.forEach((onset, idx) => {
-          const relTime = ((onset.time - timestampMs) / 1e3).toFixed(2);
-          const phaseStr = `φ=${onset.phase.toFixed(2)}`;
-          const barStr = `bar=${onset.bar + 1}`;
-          console.log(`   ${idx + 1}. t=${relTime}s | ${onset.type.padEnd(5)} | ${phaseStr} | ${barStr} | [${onset.bands.join(",")}] | str=${onset.strength.toFixed(2)}`);
-        });
-      } else {
-        console.log(`🎵 Recent Onsets: none detected`);
-      }
-      console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-`);
-      this.lastPhaseLogTime = timestampMs;
-    }
-    const candidates = [
-      { value: beatState.bpm, source: "pll" },
-      { value: tempo.bpm, source: "tempo" },
-      { value: this.lastNonZeroBpm, source: "carry" },
-      { value: 120, source: "default" }
-    ];
-    const selected = candidates.find((c) => Number.isFinite(c.value) && c.value > 0) ?? { value: 120, source: "default" };
-    const resolvedBpm = selected.value;
-    const prevSource = this.lastBpmSource;
-    this.lastNonZeroBpm = resolvedBpm;
-    this.lastBpmSource = selected.source;
-    if (this.debugMode && prevSource !== this.lastBpmSource) {
-      console.log(`[AudioSystem][bpm] Source changed: ${prevSource} -> ${this.lastBpmSource} (resolved=${resolvedBpm.toFixed(2)}, pll=${beatState.bpm?.toFixed?.(2) ?? beatState.bpm}, tempo=${tempo.bpm?.toFixed?.(2) ?? tempo.bpm})`);
-    }
-    const mergedBeatState = beatState.bpm === resolvedBpm ? beatState : { ...beatState, bpm: resolvedBpm };
-    this.lastKickDetected = mergedBeatState.events.some((e) => e.type === "kick") || pllKickCue;
-    return mergedBeatState;
-  }
-  /**
-   * Debug logging helper
-   */
-  debugLog(message, ...args) {
-    if (this.debugMode) {
-      console.log(message, ...args);
-    }
-  }
-  // Analysis configuration (optimized for onset detection)
-  fftSize = 2048;
-  // Good balance for quality vs performance
-  // High-speed analysis for onset detection (separate from RAF)
-  analysisInterval = null;
-  analysisIntervalMs = 8;
-  // 125Hz sampling for 5-8ms transient capture
-  // Analysis data arrays
-  frequencyData = null;
-  timeDomainData = null;
-  // FFT data (computed locally or fed to Essentia)
-  fftEngine = null;
-  fftInput = null;
-  fftOutput = null;
-  fftMagnitude = null;
-  fftMagnitudeDb = null;
-  fftPhase = null;
-  hannWindow = null;
-  // Audio analysis state (host-side state)
-  audioState = {
-    isConnected: false,
-    volume: {
-      current: 0,
-      peak: 0,
-      smoothed: 0
-    },
-    bands: {
-      low: 0,
-      lowMid: 0,
-      mid: 0,
-      highMid: 0,
-      high: 0,
-      lowSmoothed: 0,
-      lowMidSmoothed: 0,
-      midSmoothed: 0,
-      highMidSmoothed: 0,
-      highSmoothed: 0
-    },
-    beat: {
-      kick: 0,
-      snare: 0,
-      hat: 0,
-      any: 0,
-      kickSmoothed: 0,
-      snareSmoothed: 0,
-      hatSmoothed: 0,
-      anySmoothed: 0,
-      events: [],
-      bpm: 120,
-      confidence: 0,
-      isLocked: false
-    },
-    spectral: {
-      brightness: 0,
-      flatness: 0
+        const recentOnsets = this.onsetLogBuffer.slice(-10);
+        recentOnsets.forEach((onset, idx) => {
+          const relTime = ((onset.time - timestampMs) / 1e3).toFixed(2);
+          const phaseStr = `φ=${onset.phase.toFixed(2)}`;
+          const barStr = `bar=${onset.bar + 1}`;
+          console.log(`   ${idx + 1}. t=${relTime}s | ${onset.type.padEnd(5)} | ${phaseStr} | ${barStr} | [${onset.bands.join(",")}] | str=${onset.strength.toFixed(2)}`);
+        });
+      } else {
+        console.log(`🎵 Recent Onsets: none detected`);
+      }
+      console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+      this.lastPhaseLogTime = timestampMs;
+    }
+    const candidates = [
+      { value: beatState.bpm, source: "pll" },
+      { value: tempo.bpm, source: "tempo" },
+      { value: this.lastNonZeroBpm, source: "carry" },
+      { value: 120, source: "default" }
+    ];
+    const selected = candidates.find((c) => Number.isFinite(c.value) && c.value > 0) ?? { value: 120, source: "default" };
+    const resolvedBpm = selected.value;
+    const prevSource = this.lastBpmSource;
+    this.lastNonZeroBpm = resolvedBpm;
+    this.lastBpmSource = selected.source;
+    if (this.debugMode && prevSource !== this.lastBpmSource) {
+      console.log(`[AudioSystem][bpm] Source changed: ${prevSource} -> ${this.lastBpmSource} (resolved=${resolvedBpm.toFixed(2)}, pll=${beatState.bpm?.toFixed?.(2) ?? beatState.bpm}, tempo=${tempo.bpm?.toFixed?.(2) ?? tempo.bpm})`);
+    }
+    const mergedBeatState = beatState.bpm === resolvedBpm ? beatState : { ...beatState, bpm: resolvedBpm };
+    this.lastKickDetected = mergedBeatState.events.some((e) => e.type === "kick") || pllKickCue;
+    return mergedBeatState;
+  }
+  /**
+   * Debug logging helper
+   */
+  debugLog(message, ...args) {
+    if (this.debugMode) {
+      console.log(message, ...args);
     }
+  }
+  // Analysis configuration
+  fftSize = 2048;
+  // Beat state for main channel (not on AudioChannel because it's main-only)
+  audioStateBeat = {
+    kick: 0,
+    snare: 0,
+    hat: 0,
+    any: 0,
+    kickSmoothed: 0,
+    snareSmoothed: 0,
+    hatSmoothed: 0,
+    anySmoothed: 0,
+    events: [],
+    bpm: 120,
+    confidence: 0,
+    isLocked: false
   };
-  // Waveform data for transfer to worker
-  lastWaveformFrame = null;
-  // Analysis loop
-  analysisLoopId = null;
-  isAnalysisRunning = false;
-  lastAnalysisTimestamp = 0;
   // Callback to send results to worker
   sendAnalysisResults = null;
   constructor(sendAnalysisResultsCallback) {
     this.handleAudioStreamUpdate = this.handleAudioStreamUpdate.bind(this);
     this.performAnalysis = this.performAnalysis.bind(this);
     this.sendAnalysisResults = sendAnalysisResultsCallback || null;
+    this.mainChannel = AudioChannel.create(0, this.fftSize);
     this.onsetDetection = new MultiOnsetDetection();
     this.essentiaOnsetDetection = new EssentiaOnsetDetection();
     this.initializeEssentia();
@@ -13231,17 +13335,8 @@ class AudioSystem {
     this.pll = new PhaseLockedLoop();
     this.stateManager = new BeatStateManager();
     this.onsetTapManager = new OnsetTapManager();
-    this.volumeAutoGain = new AutoGain(3e3, 60);
-    this.bandAutoGain = {
-      low: new AutoGain(3e3, 60),
-      lowMid: new AutoGain(3e3, 60),
-      mid: new AutoGain(3e3, 60),
-      highMid: new AutoGain(3e3, 60),
-      high: new AutoGain(3e3, 60)
-    };
     const sampleRate = 60;
-    this.envelopeFollowers = {
-      // Beat energy curves - kept for API compatibility, but values come from stateManager
+    this.beatEnvelopeFollowers = {
       kick: new EnvelopeFollower(0, 300, sampleRate),
       snare: new EnvelopeFollower(0, 300, sampleRate),
       hat: new EnvelopeFollower(0, 300, sampleRate),
@@ -13249,45 +13344,15 @@ class AudioSystem {
       kickSmoothed: new EnvelopeFollower(5, 500, sampleRate),
       snareSmoothed: new EnvelopeFollower(5, 500, sampleRate),
       hatSmoothed: new EnvelopeFollower(5, 500, sampleRate),
-      anySmoothed: new EnvelopeFollower(5, 500, sampleRate),
-      // Volume smoothing
-      volumeSmoothed: new EnvelopeFollower(50, 200, sampleRate),
-      // Band smoothing
-      lowSmoothed: new EnvelopeFollower(20, 150, sampleRate),
-      lowMidSmoothed: new EnvelopeFollower(20, 150, sampleRate),
-      midSmoothed: new EnvelopeFollower(20, 150, sampleRate),
-      highMidSmoothed: new EnvelopeFollower(20, 150, sampleRate),
-      highSmoothed: new EnvelopeFollower(20, 150, sampleRate)
+      anySmoothed: new EnvelopeFollower(5, 500, sampleRate)
     };
-    this.refreshFFTResources();
     this.resetEssentiaBandHistories();
   }
-  /**
-   * Prepare FFT buffers and windowing for the selected fftSize
-   */
-  refreshFFTResources() {
-    const binCount = this.fftSize / 2;
-    this.frequencyData = new Uint8Array(binCount);
-    this.fftMagnitude = new Float32Array(binCount);
-    this.fftMagnitudeDb = new Float32Array(binCount);
-    this.fftPhase = new Float32Array(binCount);
-    this.timeDomainData = new Float32Array(this.fftSize);
-    this.fftEngine = new FFT$1(this.fftSize);
-    this.fftInput = new Float32Array(this.fftSize * 2);
-    this.fftOutput = new Float32Array(this.fftSize * 2);
-    this.hannWindow = new Float32Array(this.fftSize);
-    const twoPi = Math.PI * 2;
-    for (let i = 0; i < this.fftSize; i++) {
-      this.hannWindow[i] = 0.5 * (1 - Math.cos(twoPi * i / (this.fftSize - 1)));
-    }
-    this.analysisTicks = 0;
-    this.workletFrameCount = 0;
-  }
   /**
    * Get the current audio analysis state (for host-side usage)
    */
   getAudioState() {
-    return { ...this.audioState };
+    return { ...this.mainChannel.audioState };
   }
   /**
    * Initialize Essentia.js (async WASM loading)
@@ -13317,161 +13382,140 @@ class AudioSystem {
     return false;
   }
   /**
-   * Handle audio stream update (called from VijiCore)
+   * Handle audio stream update for main stream (called from VijiCore)
    */
   handleAudioStreamUpdate(data) {
     try {
       if (data.audioStream) {
         this.setAudioStream(data.audioStream);
       } else {
-        this.disconnectAudioStream();
+        this.disconnectMainStream();
       }
     } catch (error) {
       console.error("Error handling audio stream update:", error);
-      this.audioState.isConnected = false;
-      this.sendAnalysisResultsToWorker();
+      this.mainChannel.audioState.isConnected = false;
+      this.sendChannelResults(this.mainChannel, true);
     }
   }
   /**
-   * Set the audio stream for analysis
+   * Ensure the shared AudioContext is created and resumed.
    */
-  async setAudioStream(audioStream) {
-    this.disconnectAudioStream();
-    this.refreshFFTResources();
-    this.resetEssentiaBandHistories();
-    let bufferLength = this.fftSize / 2;
-    this.workletFrameCount = 0;
+  async ensureAudioContext() {
+    if (!this.audioContext) {
+      this.audioContext = new AudioContext();
+    }
+    if (this.audioContext.state === "suspended") {
+      await this.audioContext.resume();
+    }
+    return this.audioContext;
+  }
+  /**
+   * Connect a channel to Web Audio nodes (source, worklet/analyser).
+   * Used for both main and additional channels.
+   */
+  async connectChannel(ch, audioStream, isMain) {
+    ch.disconnectNodes();
+    ch.refreshFFTResources();
+    ch.workletFrameCount = 0;
     const audioTracks = audioStream.getAudioTracks();
     if (audioTracks.length === 0) {
-      console.warn("No audio tracks in provided stream");
-      this.audioState.isConnected = false;
-      this.sendAnalysisResultsToWorker();
+      console.warn(`No audio tracks in stream for channel ${ch.streamIndex}`);
+      ch.audioState.isConnected = false;
+      this.sendChannelResults(ch, isMain);
       return;
     }
     try {
-      if (!this.audioContext) {
-        this.audioContext = new AudioContext();
-        if (this.audioContext.state === "suspended") {
-          await this.audioContext.resume();
-        }
-      }
-      this.mediaStreamSource = this.audioContext.createMediaStreamSource(audioStream);
-      this.workletReady = await this.setupAudioWorklet();
-      if (this.workletReady && this.workletNode) {
-        this.analysisMode = "worklet";
-        this.currentSampleRate = this.audioContext.sampleRate;
-        this.mediaStreamSource.connect(this.workletNode);
-        this.workletNode.connect(this.audioContext.destination);
-        this.debugLog("Audio worklet analysis enabled");
+      const ctx = await this.ensureAudioContext();
+      ch.mediaStreamSource = ctx.createMediaStreamSource(audioStream);
+      const workletOk = await this.setupChannelWorklet(ch, isMain);
+      if (workletOk && ch.workletNode) {
+        ch.analysisMode = "worklet";
+        ch.currentSampleRate = ctx.sampleRate;
+        ch.mediaStreamSource.connect(ch.workletNode);
+        ch.workletNode.connect(ctx.destination);
+        this.debugLog(`Audio worklet enabled for channel ${ch.streamIndex}`);
         setTimeout(() => {
-          if (this.analysisMode === "worklet" && this.workletFrameCount === 0) {
-            this.debugLog("[AudioSystem] Worklet produced no frames, falling back to analyser.");
-            this.analysisMode = "analyser";
-            if (this.workletNode) {
+          if (ch.analysisMode === "worklet" && ch.workletFrameCount === 0) {
+            this.debugLog(`[AudioSystem] Worklet silent for channel ${ch.streamIndex}, falling back to analyser.`);
+            ch.analysisMode = "analyser";
+            if (ch.workletNode) {
               try {
-                this.workletNode.port.onmessage = null;
-                this.workletNode.disconnect();
+                ch.workletNode.port.onmessage = null;
+                ch.workletNode.disconnect();
               } catch (_) {
               }
-              this.workletNode = null;
+              ch.workletNode = null;
             }
-            this.workletReady = false;
-            this.analyser = this.audioContext.createAnalyser();
-            this.analyser.fftSize = this.fftSize;
-            this.analyser.smoothingTimeConstant = 0;
-            this.mediaStreamSource.connect(this.analyser);
-            bufferLength = this.analyser.frequencyBinCount;
-            this.frequencyData = new Uint8Array(bufferLength);
-            this.timeDomainData = new Float32Array(this.fftSize);
-            this.startAnalysisLoop();
+            ch.workletReady = false;
+            ch.analyser = ctx.createAnalyser();
+            ch.analyser.fftSize = ch.fftSize;
+            ch.analyser.smoothingTimeConstant = 0;
+            ch.mediaStreamSource.connect(ch.analyser);
+            ch.frequencyData = new Uint8Array(ch.analyser.frequencyBinCount);
+            ch.timeDomainData = new Float32Array(ch.fftSize);
+            this.ensureAnalysisLoop();
           }
         }, 600);
       } else {
-        this.analysisMode = "analyser";
-        this.analyser = this.audioContext.createAnalyser();
-        this.analyser.fftSize = this.fftSize;
-        this.analyser.smoothingTimeConstant = 0;
-        this.mediaStreamSource.connect(this.analyser);
-        this.debugLog("Audio worklet unavailable, using analyser fallback");
-        bufferLength = this.analyser.frequencyBinCount;
-        this.frequencyData = new Uint8Array(bufferLength);
-        this.timeDomainData = new Float32Array(this.fftSize);
-      }
-      this.currentStream = audioStream;
-      this.audioState.isConnected = true;
-      if (this.analysisMode === "worklet") {
-        this.isAnalysisRunning = true;
-      }
-      if (this.analysisMode === "analyser") {
-        this.startAnalysisLoop();
-      }
-      if (this.analysisMode === "analyser" && !this.isAnalysisRunning) {
-        this.debugLog("[AudioSystem] Analysis loop not running after setup, forcing start.");
-        this.startAnalysisLoop();
-      }
-      const tracks = audioStream.getAudioTracks();
-      this.debugLog("[AudioSystem] Stream info", {
-        trackCount: tracks.length,
-        trackSettings: tracks.map((t) => t.getSettings?.() || {}),
-        trackMuted: tracks.map((t) => t.muted),
-        mode: this.analysisMode
-      });
+        ch.analysisMode = "analyser";
+        ch.analyser = ctx.createAnalyser();
+        ch.analyser.fftSize = ch.fftSize;
+        ch.analyser.smoothingTimeConstant = 0;
+        ch.mediaStreamSource.connect(ch.analyser);
+        ch.frequencyData = new Uint8Array(ch.analyser.frequencyBinCount);
+        ch.timeDomainData = new Float32Array(ch.fftSize);
+        this.debugLog(`Analyser fallback for channel ${ch.streamIndex}`);
+      }
+      ch.currentStream = audioStream;
+      ch.audioState.isConnected = true;
+      if (ch.analysisMode === "worklet") {
+        ch.isAnalysisRunning = true;
+      } else {
+        this.ensureAnalysisLoop();
+      }
       this.startStalenessTimer();
-      this.debugLog("Audio stream connected successfully (host-side)", {
-        sampleRate: this.audioContext.sampleRate,
-        fftSize: this.fftSize,
-        bufferLength
+      this.debugLog(`Audio stream connected for channel ${ch.streamIndex}`, {
+        sampleRate: ctx.sampleRate,
+        fftSize: ch.fftSize,
+        mode: ch.analysisMode
       });
     } catch (error) {
-      console.error("Failed to set up audio analysis:", error);
-      this.audioState.isConnected = false;
-      this.disconnectAudioStream();
+      console.error(`Failed to set up audio for channel ${ch.streamIndex}:`, error);
+      ch.audioState.isConnected = false;
+      ch.disconnectNodes();
     }
-    this.sendAnalysisResultsToWorker();
+    this.sendChannelResults(ch, isMain);
   }
   /**
-   * Disconnect current audio stream and clean up resources
+   * Set the main audio stream for analysis (preserves original public API surface).
    */
-  disconnectAudioStream() {
-    this.stopAnalysisLoop();
-    this.stopStalenessTimer();
+  async setAudioStream(audioStream) {
+    this.disconnectMainStream();
     this.resetEssentiaBandHistories();
-    if (this.mediaStreamSource) {
-      this.mediaStreamSource.disconnect();
-      this.mediaStreamSource = null;
-    }
-    if (this.analyser) {
-      this.analyser.disconnect();
-      this.analyser = null;
-    }
-    if (this.workletNode) {
-      try {
-        this.workletNode.port.onmessage = null;
-        this.workletNode.disconnect();
-      } catch (_) {
-      }
-      this.workletNode = null;
-    }
-    this.workletReady = false;
-    this.analysisMode = "analyser";
-    this.frequencyData = null;
-    this.timeDomainData = null;
-    this.fftMagnitude = null;
-    this.fftMagnitudeDb = null;
-    this.fftPhase = null;
-    this.currentStream = null;
-    this.audioState.isConnected = false;
-    this.resetAudioValues();
-    this.sendAnalysisResultsToWorker();
-    this.debugLog("Audio stream disconnected (host-side)");
+    await this.connectChannel(this.mainChannel, audioStream, true);
   }
   /**
-   * Initialize audio worklet for high-quality capture (complex STFT path)
+   * Disconnect the main audio stream (does NOT close AudioContext -- additional channels may still be active).
    */
-  async setupAudioWorklet() {
-    if (!this.audioContext?.audioWorklet) {
-      return false;
+  disconnectMainStream() {
+    this.mainChannel.disconnectNodes();
+    this.mainChannel.audioState.isConnected = false;
+    this.mainChannel.isAnalysisRunning = false;
+    this.mainChannel.currentStream = null;
+    this.resetAudioValues();
+    if (this.additionalChannels.size === 0) {
+      this.stopAnalysisLoop();
+      this.stopStalenessTimer();
     }
+    this.sendChannelResults(this.mainChannel, true);
+    this.debugLog("Main audio stream disconnected (host-side)");
+  }
+  /**
+   * Set up an AudioWorklet node for a specific channel.
+   * Registers the processor module once (shared), creates a new WorkletNode per channel.
+   */
+  async setupChannelWorklet(ch, isMain) {
+    if (!this.audioContext?.audioWorklet) return false;
     try {
       if (!this.workletRegistered) {
         const workletSource = `
@@ -13521,65 +13565,71 @@ class AudioSystem {
         URL.revokeObjectURL(workletUrl);
         this.workletRegistered = true;
       }
-      this.workletNode = new AudioWorkletNode(this.audioContext, "audio-analysis-processor", {
+      ch.workletNode = new AudioWorkletNode(this.audioContext, "audio-analysis-processor", {
         numberOfOutputs: 1,
         outputChannelCount: [1],
-        processorOptions: {
-          fftSize: this.fftSize,
-          hopSize: this.fftSize / 2
-        }
+        processorOptions: { fftSize: ch.fftSize, hopSize: ch.fftSize / 2 }
       });
-      this.workletNode.port.onmessage = (event) => {
+      ch.workletNode.port.onmessage = (event) => {
         const data = event.data || {};
         if (data.type === "audio-frame" && data.samples) {
-          this.handleWorkletFrame(data.samples, data.sampleRate, data.timestamp);
+          if (isMain) {
+            this.handleMainWorkletFrame(data.samples, data.sampleRate, data.timestamp);
+          } else {
+            this.handleAdditionalWorkletFrame(ch, data.samples, data.sampleRate, data.timestamp);
+          }
         }
       };
       return true;
     } catch (error) {
-      console.warn("Audio worklet initialization failed, falling back to analyser:", error);
-      this.workletNode = null;
+      console.warn(`Audio worklet init failed for channel ${ch.streamIndex}:`, error);
+      ch.workletNode = null;
       return false;
     }
   }
   /**
-   * Start the audio analysis loop at high speed (8ms intervals for transient capture)
+   * Ensure the shared analysis interval is running (for analyser-mode channels).
    */
-  startAnalysisLoop() {
-    if (this.isAnalysisRunning || this.analysisMode !== "analyser") {
-      return;
-    }
-    this.isAnalysisRunning = true;
+  ensureAnalysisLoop() {
+    if (this.analysisInterval !== null) return;
     this.analysisInterval = window.setInterval(() => {
       this.performAnalysis();
     }, this.analysisIntervalMs);
-    this.debugLog("[AudioSystem] Analysis loop started", {
-      intervalMs: this.analysisIntervalMs
-    });
+    this.debugLog("[AudioSystem] Shared analysis loop started", { intervalMs: this.analysisIntervalMs });
   }
   /**
-   * Stop the audio analysis loop
+   * Stop the shared analysis loop.
    */
   stopAnalysisLoop() {
-    this.isAnalysisRunning = false;
     if (this.analysisInterval !== null) {
       clearInterval(this.analysisInterval);
       this.analysisInterval = null;
     }
-    if (this.analysisLoopId !== null) {
-      cancelAnimationFrame(this.analysisLoopId);
-      this.analysisLoopId = null;
+    this.mainChannel.isAnalysisRunning = false;
+    for (const ch of this.additionalChannels.values()) {
+      ch.isAnalysisRunning = false;
     }
   }
+  /**
+   * Shared staleness timer: checks all channels for stale data.
+   */
   startStalenessTimer() {
-    this.stopStalenessTimer();
-    this.lastFrameTime = performance.now();
+    if (this.stalenessTimer !== null) return;
     this.stalenessTimer = setInterval(() => {
-      if (!this.audioState.isConnected || this.lastFrameTime === 0) return;
-      const elapsed = performance.now() - this.lastFrameTime;
-      if (elapsed > AudioSystem.STALENESS_THRESHOLD_MS) {
-        this.resetAudioValues();
-        this.sendAnalysisResultsToWorker();
+      const now = performance.now();
+      if (this.mainChannel.audioState.isConnected && this.mainChannel.lastFrameTime > 0) {
+        if (now - this.mainChannel.lastFrameTime > AudioSystem.STALENESS_THRESHOLD_MS) {
+          this.resetAudioValues();
+          this.sendChannelResults(this.mainChannel, true);
+        }
+      }
+      for (const ch of this.additionalChannels.values()) {
+        if (ch.audioState.isConnected && ch.lastFrameTime > 0) {
+          if (now - ch.lastFrameTime > AudioSystem.STALENESS_THRESHOLD_MS) {
+            ch.resetValues();
+            this.sendChannelResults(ch, false);
+          }
+        }
       }
     }, 250);
   }
@@ -13591,114 +13641,96 @@ class AudioSystem {
   }
   /**
    * Pause audio analysis (for tests or temporary suspension)
-   * The setInterval continues but performAnalysis() exits early
    */
   pauseAnalysis() {
-    this.isAnalysisRunning = false;
+    this.mainChannel.isAnalysisRunning = false;
+    for (const ch of this.additionalChannels.values()) ch.isAnalysisRunning = false;
   }
   /**
    * Resume audio analysis after pause
    */
   resumeAnalysis() {
-    this.isAnalysisRunning = true;
+    this.mainChannel.isAnalysisRunning = true;
+    for (const ch of this.additionalChannels.values()) ch.isAnalysisRunning = true;
   }
   /**
-   * Perform audio analysis (called every frame)
-   * Uses industry-grade 4-layer architecture:
-   * Layer 1: MultiOnsetDetection (per-band onset detection)
-   * Layer 2: TempoInduction (dual-method BPM detection)
-   * Layer 3: PhaseLockedLoop (stable phase tracking)
-   * Layer 4: BeatStateManager (state machine + confidence)
+   * Shared analysis loop callback: iterates main + additional channels in analyser mode.
    */
   performAnalysis() {
-    if (!this.isAnalysisRunning || this.analysisMode !== "analyser" || !this.audioContext || !this.analyser) {
-      return;
-    }
-    if (!this.timeDomainData || this.timeDomainData.length !== this.fftSize) {
-      this.timeDomainData = new Float32Array(this.fftSize);
-    }
-    this.analyser.getFloatTimeDomainData(this.timeDomainData);
-    this.analysisTicks++;
-    for (let i = 0; i < 32 && i < this.timeDomainData.length; i++) {
-      Math.abs(this.timeDomainData[i]);
-    }
+    if (!this.audioContext) return;
+    const sampleRate = this.audioContext.sampleRate;
     const detectionTimeMs = performance.now();
-    this.analyzeFrame(this.timeDomainData, this.audioContext.sampleRate, detectionTimeMs);
-  }
-  applyAutoGain() {
-    this.audioState.volume.current = this.volumeAutoGain.process(this.audioState.volume.current);
-    this.audioState.volume.peak = this.volumeAutoGain.process(this.audioState.volume.peak);
-    const bands = this.audioState.bands;
-    bands.low = this.bandAutoGain.low.process(bands.low);
-    bands.lowMid = this.bandAutoGain.lowMid.process(bands.lowMid);
-    bands.mid = this.bandAutoGain.mid.process(bands.mid);
-    bands.highMid = this.bandAutoGain.highMid.process(bands.highMid);
-    bands.high = this.bandAutoGain.high.process(bands.high);
+    const mc = this.mainChannel;
+    if (mc.isAnalysisRunning && mc.analysisMode === "analyser" && mc.analyser) {
+      if (!mc.timeDomainData || mc.timeDomainData.length !== mc.fftSize) {
+        mc.timeDomainData = new Float32Array(mc.fftSize);
+      }
+      mc.analyser.getFloatTimeDomainData(mc.timeDomainData);
+      this.analyzeMainFrame(mc.timeDomainData, sampleRate, detectionTimeMs);
+    }
+    for (const ch of this.additionalChannels.values()) {
+      if (ch.isAnalysisRunning && ch.analysisMode === "analyser" && ch.analyser) {
+        if (!ch.timeDomainData || ch.timeDomainData.length !== ch.fftSize) {
+          ch.timeDomainData = new Float32Array(ch.fftSize);
+        }
+        ch.analyser.getFloatTimeDomainData(ch.timeDomainData);
+        this.analyzeAdditionalFrame(ch, ch.timeDomainData, sampleRate, detectionTimeMs);
+      }
+    }
+  }
+  applyChannelAutoGain(ch) {
+    ch.audioState.volume.current = ch.volumeAutoGain.process(ch.audioState.volume.current);
+    ch.audioState.volume.peak = ch.volumeAutoGain.process(ch.audioState.volume.peak);
+    const bands = ch.audioState.bands;
+    bands.low = ch.bandAutoGain.low.process(bands.low);
+    bands.lowMid = ch.bandAutoGain.lowMid.process(bands.lowMid);
+    bands.mid = ch.bandAutoGain.mid.process(bands.mid);
+    bands.highMid = ch.bandAutoGain.highMid.process(bands.highMid);
+    bands.high = ch.bandAutoGain.high.process(bands.high);
   }
   // Note: updateBeatState is now handled by BeatStateManager
   /**
-   * Update smooth versions of frequency bands
+   * Update smooth versions of frequency bands on a specific channel
    */
-  updateSmoothBands(dtMs) {
-    this.audioState.volume.smoothed = this.envelopeFollowers.volumeSmoothed.process(
-      this.audioState.volume.current,
-      dtMs
-    );
-    this.audioState.bands.lowSmoothed = this.envelopeFollowers.lowSmoothed.process(
-      this.audioState.bands.low,
-      dtMs
-    );
-    this.audioState.bands.lowMidSmoothed = this.envelopeFollowers.lowMidSmoothed.process(
-      this.audioState.bands.lowMid,
-      dtMs
-    );
-    this.audioState.bands.midSmoothed = this.envelopeFollowers.midSmoothed.process(
-      this.audioState.bands.mid,
-      dtMs
-    );
-    this.audioState.bands.highMidSmoothed = this.envelopeFollowers.highMidSmoothed.process(
-      this.audioState.bands.highMid,
-      dtMs
-    );
-    this.audioState.bands.highSmoothed = this.envelopeFollowers.highSmoothed.process(
-      this.audioState.bands.high,
-      dtMs
-    );
+  updateChannelSmoothBands(ch, dtMs) {
+    const ef = ch.envelopeFollowers;
+    ch.audioState.volume.smoothed = ef.volumeSmoothed.process(ch.audioState.volume.current, dtMs);
+    ch.audioState.bands.lowSmoothed = ef.lowSmoothed.process(ch.audioState.bands.low, dtMs);
+    ch.audioState.bands.lowMidSmoothed = ef.lowMidSmoothed.process(ch.audioState.bands.lowMid, dtMs);
+    ch.audioState.bands.midSmoothed = ef.midSmoothed.process(ch.audioState.bands.mid, dtMs);
+    ch.audioState.bands.highMidSmoothed = ef.highMidSmoothed.process(ch.audioState.bands.highMid, dtMs);
+    ch.audioState.bands.highSmoothed = ef.highSmoothed.process(ch.audioState.bands.high, dtMs);
   }
   /**
-   * Send analysis results to worker
+   * Send analysis results for a specific channel to the worker.
+   * Tags with streamIndex and conditionally includes beat data (main channel only).
    */
-  sendAnalysisResultsToWorker() {
-    if (this.sendAnalysisResults) {
-      const frequencyData = this.frequencyData ? new Uint8Array(this.frequencyData) : new Uint8Array(0);
-      const waveformData = this.lastWaveformFrame ? new Float32Array(this.lastWaveformFrame) : new Float32Array(0);
-      this.sendAnalysisResults({
-        type: "audio-analysis-update",
-        data: {
-          isConnected: this.audioState.isConnected,
-          volume: this.audioState.volume,
-          bands: this.audioState.bands,
-          beat: this.audioState.beat,
-          spectral: this.audioState.spectral,
-          frequencyData,
-          waveformData,
-          timestamp: performance.now()
-        }
-      });
+  sendChannelResults(ch, includeBeat) {
+    if (!this.sendAnalysisResults) return;
+    const frequencyData = ch.frequencyData ? new Uint8Array(ch.frequencyData) : new Uint8Array(0);
+    const waveformData = ch.lastWaveformFrame ? new Float32Array(ch.lastWaveformFrame) : new Float32Array(0);
+    const data = {
+      streamIndex: ch.streamIndex,
+      isConnected: ch.audioState.isConnected,
+      volume: ch.audioState.volume,
+      bands: ch.audioState.bands,
+      spectral: ch.audioState.spectral,
+      frequencyData,
+      waveformData,
+      timestamp: performance.now()
+    };
+    if (includeBeat) {
+      data.beat = this.audioStateBeat;
     }
+    this.sendAnalysisResults({ type: "audio-analysis-update", data });
   }
   /**
-   * Reset audio values to defaults
+   * Reset audio values to defaults (main channel + beat state)
    */
   resetAudioValues() {
-    this.audioState.volume.current = 0;
-    this.audioState.volume.peak = 0;
-    this.audioState.volume.smoothed = 0;
+    this.mainChannel.resetValues();
     this.lastKickDetected = false;
-    for (const band in this.audioState.bands) {
-      this.audioState.bands[band] = 0;
-    }
-    this.audioState.beat = {
+    this.audioStateBeat = {
       kick: 0,
       snare: 0,
       hat: 0,
@@ -13712,36 +13744,98 @@ class AudioSystem {
       confidence: 0,
       isLocked: false
     };
-    this.audioState.spectral = {
-      brightness: 0,
-      flatness: 0
-    };
   }
   /**
-   * Reset all audio state (called when destroying)
+   * Reset all audio state (called when destroying).
+   * Disconnects all channels, closes AudioContext, resets all modules.
    */
   resetAudioState() {
-    this.disconnectAudioStream();
+    this.stopAnalysisLoop();
+    this.stopStalenessTimer();
     this.resetEssentiaBandHistories();
+    for (const ch of this.additionalChannels.values()) {
+      ch.destroy();
+    }
+    this.additionalChannels.clear();
+    this.mainChannel.disconnectNodes();
+    this.mainChannel.audioState.isConnected = false;
+    this.mainChannel.isAnalysisRunning = false;
+    this.mainChannel.currentStream = null;
     if (this.audioContext && this.audioContext.state !== "closed") {
       this.audioContext.close();
       this.audioContext = null;
     }
-    this.workletNode = null;
-    this.workletReady = false;
     this.workletRegistered = false;
-    this.analysisMode = "analyser";
     this.onsetDetection.reset();
     this.tempoInduction.reset();
     this.pll.reset();
     this.stateManager.reset();
-    this.volumeAutoGain.reset();
-    Object.values(this.bandAutoGain).forEach((g) => g.reset());
     this.onsetTapManager.reset();
-    Object.values(this.envelopeFollowers).forEach((env) => env.reset());
+    Object.values(this.beatEnvelopeFollowers).forEach((env) => env.reset());
     this.resetAudioValues();
   }
   // ═══════════════════════════════════════════════════════════
+  // Multi-Channel Stream Management
+  // ═══════════════════════════════════════════════════════════
+  /**
+   * Add an additional audio stream (lightweight analysis, no beat detection).
+   * @param streamIndex Global stream index (from VijiCore: AUDIO_ADDITIONAL_BASE + n or AUDIO_DEVICE_BASE + n)
+   * @param stream The MediaStream to analyze
+   */
+  async addStream(streamIndex, stream) {
+    if (this.additionalChannels.has(streamIndex)) {
+      this.removeStream(streamIndex);
+    }
+    const ch = AudioChannel.create(streamIndex, this.fftSize);
+    this.additionalChannels.set(streamIndex, ch);
+    await this.connectChannel(ch, stream, false);
+  }
+  /**
+   * Remove an additional audio stream.
+   */
+  removeStream(streamIndex) {
+    const ch = this.additionalChannels.get(streamIndex);
+    if (!ch) return;
+    ch.destroy();
+    this.additionalChannels.delete(streamIndex);
+    const disconnected = AudioChannel.create(streamIndex, this.fftSize);
+    disconnected.audioState.isConnected = false;
+    this.sendChannelResults(disconnected, false);
+    disconnected.destroy();
+    if (this.additionalChannels.size === 0 && !this.mainChannel.audioState.isConnected) {
+      this.stopAnalysisLoop();
+      this.stopStalenessTimer();
+    }
+  }
+  /**
+   * Tear down all additional channels and rebuild with corrected indices.
+   * Mirrors video's reinitializeAdditionalCoordinators pattern.
+   */
+  async reinitializeAdditionalChannels(streams, baseIndex) {
+    const toRemove = [];
+    for (const [idx, ch] of this.additionalChannels) {
+      if (idx >= baseIndex && idx < baseIndex + 100) {
+        ch.destroy();
+        toRemove.push(idx);
+      }
+    }
+    for (const idx of toRemove) {
+      this.additionalChannels.delete(idx);
+    }
+    for (let i = 0; i < streams.length; i++) {
+      const newIndex = baseIndex + i;
+      const ch = AudioChannel.create(newIndex, this.fftSize);
+      this.additionalChannels.set(newIndex, ch);
+      await this.connectChannel(ch, streams[i], false);
+    }
+  }
+  /**
+   * Get the number of additional audio channels.
+   */
+  getChannelCount() {
+    return this.additionalChannels.size;
+  }
+  // ═══════════════════════════════════════════════════════════
   // Public API Methods for Audio Analysis Configuration
   // ═══════════════════════════════════════════════════════════
   /**
@@ -13804,10 +13898,10 @@ class AudioSystem {
   setFFTSize(size) {
     if (this.fftSize === size) return;
     this.fftSize = size;
-    this.refreshFFTResources();
-    if (this.currentStream) {
-      const stream = this.currentStream;
-      this.setAudioStream(stream);
+    this.mainChannel.fftSize = size;
+    this.mainChannel.refreshFFTResources();
+    if (this.mainChannel.currentStream) {
+      this.setAudioStream(this.mainChannel.currentStream);
     }
   }
   /**
@@ -13816,8 +13910,12 @@ class AudioSystem {
   setAutoGain(enabled) {
     this.autoGainEnabled = enabled;
     if (!enabled) {
-      this.volumeAutoGain.reset();
-      Object.values(this.bandAutoGain).forEach((g) => g.reset());
+      this.mainChannel.volumeAutoGain.reset();
+      Object.values(this.mainChannel.bandAutoGain).forEach((g) => g.reset());
+      for (const ch of this.additionalChannels.values()) {
+        ch.volumeAutoGain.reset();
+        Object.values(ch.bandAutoGain).forEach((g) => g.reset());
+      }
     }
   }
   /**
@@ -13845,7 +13943,7 @@ class AudioSystem {
    */
   getState() {
     return {
-      isConnected: this.audioState.isConnected,
+      isConnected: this.mainChannel.audioState.isConnected,
       currentBPM: this.pll.getBPM(),
       confidence: this.tempoInduction.getConfidence(),
       isLocked: this.stateManager.isLocked(),
@@ -13863,11 +13961,11 @@ class AudioSystem {
    */
   getCurrentAudioData() {
     return {
-      isConnected: this.audioState.isConnected,
-      volume: { ...this.audioState.volume },
-      bands: { ...this.audioState.bands },
-      beat: { ...this.audioState.beat },
-      spectral: { ...this.audioState.spectral }
+      isConnected: this.mainChannel.audioState.isConnected,
+      volume: { ...this.mainChannel.audioState.volume },
+      bands: { ...this.mainChannel.audioState.bands },
+      beat: { ...this.audioStateBeat },
+      spectral: { ...this.mainChannel.audioState.spectral }
     };
   }
   /**
@@ -13913,29 +14011,25 @@ class AudioSystem {
       },
       // Raw audio levels (AFTER normalization for visual output)
       levels: {
-        low: this.audioState.bands.low,
-        lowMid: this.audioState.bands.lowMid,
-        mid: this.audioState.bands.mid,
-        highMid: this.audioState.bands.highMid,
-        high: this.audioState.bands.high,
-        volume: this.audioState.volume.current
+        low: this.mainChannel.audioState.bands.low,
+        lowMid: this.mainChannel.audioState.bands.lowMid,
+        mid: this.mainChannel.audioState.bands.mid,
+        highMid: this.mainChannel.audioState.bands.highMid,
+        high: this.mainChannel.audioState.bands.high,
+        volume: this.mainChannel.audioState.volume.current
       },
-      // Pre-gain band levels (BEFORE auto-gain normalization)
       rawBands: { ...this.rawBandsPreGain },
-      // Auto-gain values
       bandGains: {
-        low: this.bandAutoGain.low.getGain(),
-        lowMid: this.bandAutoGain.lowMid.getGain(),
-        mid: this.bandAutoGain.mid.getGain(),
-        highMid: this.bandAutoGain.highMid.getGain(),
-        high: this.bandAutoGain.high.getGain()
+        low: this.mainChannel.bandAutoGain.low.getGain(),
+        lowMid: this.mainChannel.bandAutoGain.lowMid.getGain(),
+        mid: this.mainChannel.bandAutoGain.mid.getGain(),
+        highMid: this.mainChannel.bandAutoGain.highMid.getGain(),
+        high: this.mainChannel.bandAutoGain.high.getGain()
       },
-      volumeGain: this.volumeAutoGain.getGain(),
-      // Timing info
-      dtMs: this.lastDtMs,
+      volumeGain: this.mainChannel.volumeAutoGain.getGain(),
+      dtMs: this.mainChannel.lastDtMs,
       analysisIntervalMs: this.analysisIntervalMs,
-      // Current events
-      events: [...this.audioState.beat.events]
+      events: [...this.audioStateBeat.events]
     };
   }
 }
@@ -14360,7 +14454,8 @@ class DeviceSensorManager {
       name: device.name,
       motion: null,
       orientation: null,
-      video: null
+      video: null,
+      audio: null
     };
     this.externalDevices.set(device.id, newDevice);
     this.externalDeviceOrder.push(device.id);
@@ -14460,6 +14555,21 @@ class SceneAnalyzer {
     }
     return "native";
   }
+  /**
+   * P5 main-canvas mode from the renderer directive (only meaningful when
+   * {@link detectRendererType} is `'p5'`).
+   *
+   * - `// @renderer p5` → 2D (default)
+   * - `// @renderer p5 webgl` → WEBGL
+   */
+  static detectP5CanvasMode(sceneCode) {
+    if (/\/\/\s*@renderer\s+p5\s+webgl\b|\/\*\s*@renderer\s+p5\s+webgl\s*\*\//i.test(
+      sceneCode
+    )) {
+      return "webgl";
+    }
+    return "2d";
+  }
 }
 class VijiCore {
   iframeManager = null;
@@ -14500,16 +14610,25 @@ class VijiCore {
   //   Index 200..299:  Direct frame injection (compositor pipeline)
   //
   // The worker filters by streamType when building artist-facing arrays
-  // (viji.streams[], viji.devices[].video), so absolute indices are internal.
+  // (viji.videoStreams[], viji.devices[].video), so absolute indices are internal.
   // ═══════════════════════════════════════════════════════════════════════════
   static ADDITIONAL_STREAM_BASE = 1;
   static DEVICE_VIDEO_BASE = 100;
   static DIRECT_FRAME_BASE = 200;
+  // Audio stream index ranges (mirroring video)
+  static AUDIO_ADDITIONAL_BASE = 1;
+  static AUDIO_DEVICE_BASE = 100;
+  static MAX_ADDITIONAL_AUDIO_STREAMS = 8;
+  static MAX_ADDITIONAL_VIDEO_STREAMS = 8;
   // Separated video stream management
   videoStream = null;
   // Main stream (CV enabled) - always index 0
   videoStreams = [];
   // Additional streams (no CV)
+  // Audio stream management
+  audioStreams = [];
+  // Additional audio streams (lightweight analysis)
+  deviceAudioStreamIndices = /* @__PURE__ */ new Map();
   // Video coordinators
   mainVideoCoordinator = null;
   additionalCoordinators = [];
@@ -14565,6 +14684,7 @@ class VijiCore {
     this.stats.rendererType = SceneAnalyzer.detectRendererType(config.sceneCode);
     this.videoStream = config.videoStream || null;
     this.videoStreams = config.videoStreams || [];
+    this.audioStreams = config.audioStreams ? [...config.audioStreams] : [];
     this.currentInteractionEnabled = this.config.allowUserInteraction;
     if (config.allowDeviceInteraction) {
       this.deviceSensorManager = new DeviceSensorManager();
@@ -14783,6 +14903,14 @@ class VijiCore {
       if (this.config.audioStream) {
         await this.setAudioStream(this.config.audioStream);
       }
+      for (let i = 0; i < this.audioStreams.length; i++) {
+        const streamIndex = VijiCore.AUDIO_ADDITIONAL_BASE + i;
+        await this.audioSystem.addStream(streamIndex, this.audioStreams[i]);
+        this.workerManager.postMessage("audio-stream-setup", {
+          streamIndex,
+          streamType: "additional"
+        });
+      }
       this.stats.resolution = effectiveResolution;
       this.stats.scale = this.iframeManager.getScale();
       this.updateFrameRateStats();
@@ -15586,12 +15714,18 @@ class VijiCore {
   // ADDITIONAL VIDEO STREAMS API
   // ═══════════════════════════════════════════════════════
   /**
-   * Adds an additional video stream (no CV). Returns its index in viji.streams[].
+   * Adds an additional video stream (no CV). Returns its index in viji.videoStreams[].
    */
   async addVideoStream(stream) {
     this.validateReady();
     const existingIndex = this.videoStreams.indexOf(stream);
     if (existingIndex !== -1) return existingIndex;
+    if (this.videoStreams.length >= VijiCore.MAX_ADDITIONAL_VIDEO_STREAMS) {
+      throw new VijiCoreError(
+        `Maximum additional video streams reached (${VijiCore.MAX_ADDITIONAL_VIDEO_STREAMS})`,
+        "STREAM_LIMIT_REACHED"
+      );
+    }
     this.videoStreams.push(stream);
     const newIndex = this.videoStreams.length - 1;
     const streamIndex = VijiCore.ADDITIONAL_STREAM_BASE + newIndex;
@@ -15636,6 +15770,103 @@ class VijiCore {
   getVideoStreamCount() {
     return this.videoStreams.length;
   }
+  // ═══════════════════════════════════════════════════════════
+  // Audio Stream Management (mirroring video stream API)
+  // ═══════════════════════════════════════════════════════════
+  /**
+   * Add an additional audio stream for lightweight analysis (no beat detection).
+   * @param stream MediaStream with audio tracks
+   * @returns Index of the new stream (0-based within additional streams)
+   * @throws VijiCoreError if limit reached (max 8)
+   */
+  async addAudioStream(stream) {
+    this.validateReady();
+    const existingIndex = this.audioStreams.indexOf(stream);
+    if (existingIndex !== -1) return existingIndex;
+    if (this.audioStreams.length >= VijiCore.MAX_ADDITIONAL_AUDIO_STREAMS) {
+      throw new VijiCoreError(
+        `Maximum additional audio streams reached (${VijiCore.MAX_ADDITIONAL_AUDIO_STREAMS})`,
+        "STREAM_LIMIT_REACHED"
+      );
+    }
+    this.audioStreams.push(stream);
+    const newIndex = this.audioStreams.length - 1;
+    const streamIndex = VijiCore.AUDIO_ADDITIONAL_BASE + newIndex;
+    if (this.audioSystem) {
+      await this.audioSystem.addStream(streamIndex, stream);
+    }
+    this.workerManager?.postMessage("audio-stream-setup", {
+      streamIndex,
+      streamType: "additional"
+    });
+    return newIndex;
+  }
+  /**
+   * Remove an additional audio stream by index.
+   * Triggers re-indexing of remaining streams.
+   */
+  async removeAudioStream(index) {
+    this.validateReady();
+    if (index < 0 || index >= this.audioStreams.length) {
+      throw new VijiCoreError(`Invalid audio stream index: ${index}`, "INVALID_INDEX");
+    }
+    this.audioStreams[index].getTracks().forEach((track) => track.stop());
+    this.audioStreams.splice(index, 1);
+    if (this.audioSystem) {
+      await this.audioSystem.reinitializeAdditionalChannels(
+        this.audioStreams,
+        VijiCore.AUDIO_ADDITIONAL_BASE
+      );
+    }
+    for (let i = 0; i < this.audioStreams.length; i++) {
+      this.workerManager?.postMessage("audio-stream-setup", {
+        streamIndex: VijiCore.AUDIO_ADDITIONAL_BASE + i,
+        streamType: "additional"
+      });
+    }
+  }
+  /**
+   * Gets the number of additional audio streams.
+   */
+  getAudioStreamCount() {
+    return this.audioStreams.length;
+  }
+  /**
+   * Set audio stream from an external device.
+   * @param deviceId Device identifier (must be registered via addExternalDevice)
+   * @param stream MediaStream with audio tracks from the device
+   */
+  async setDeviceAudio(deviceId, stream) {
+    this.validateReady();
+    await this.clearDeviceAudio(deviceId);
+    const usedIndices = new Set(this.deviceAudioStreamIndices.values());
+    let streamIndex = VijiCore.AUDIO_DEVICE_BASE;
+    while (usedIndices.has(streamIndex)) {
+      streamIndex++;
+    }
+    this.deviceAudioStreamIndices.set(deviceId, streamIndex);
+    if (this.audioSystem) {
+      await this.audioSystem.addStream(streamIndex, stream);
+    }
+    this.workerManager?.postMessage("audio-stream-setup", {
+      streamIndex,
+      streamType: "device",
+      deviceId
+    });
+    this.debugLog(`Device audio set for ${deviceId} at index ${streamIndex}`);
+  }
+  /**
+   * Clear audio stream from a device.
+   */
+  async clearDeviceAudio(deviceId) {
+    const streamIndex = this.deviceAudioStreamIndices.get(deviceId);
+    if (streamIndex === void 0) return;
+    this.deviceAudioStreamIndices.delete(deviceId);
+    if (this.audioSystem) {
+      this.audioSystem.removeStream(streamIndex);
+    }
+    this.debugLog(`Device audio cleared for ${deviceId}`);
+  }
   /**
    * Reinitializes all additional coordinators after array mutation.
    */
@@ -15970,6 +16201,9 @@ class VijiCore {
     if (this.deviceVideoCoordinators.has(deviceId)) {
       this.clearDeviceVideo(deviceId);
     }
+    if (this.deviceAudioStreamIndices.has(deviceId)) {
+      this.clearDeviceAudio(deviceId);
+    }
     this.deviceSensorManager.removeExternalDevice(deviceId);
     this.syncDeviceStateToWorker();
     this.debugLog(`External device removed: ${deviceId}`);
@@ -16075,11 +16309,16 @@ class VijiCore {
       this.deviceSensorManager.destroy();
       this.deviceSensorManager = null;
     }
+    for (const [deviceId] of this.deviceAudioStreamIndices) {
+      await this.clearDeviceAudio(deviceId);
+    }
+    this.deviceAudioStreamIndices.clear();
     if (this.audioSystem) {
       this.audioSystem.resetAudioState();
       this.audioSystem = null;
     }
     this.currentAudioStream = null;
+    this.audioStreams = [];
     if (this.mainVideoCoordinator) {
       this.mainVideoCoordinator.resetVideoState();
       this.mainVideoCoordinator = null;
@@ -16158,4 +16397,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-C6fMmKQj.js.map
+//# sourceMappingURL=index-9YDi9UBP.js.map