@viji-dev/core 0.3.19 → 0.3.21

package/dist/{index-BKGarA3m.js → index-trkn0FNW.js}

@@ -73,8 +73,11 @@ class IFrameManager {
         document.body.appendChild(hiddenContainer);
         hiddenContainer.appendChild(iframe);
       } else {
+        if (getComputedStyle(this.hostContainer).position === "static") {
+          this.hostContainer.style.position = "relative";
+        }
         const visibility = this.initiallyVisible ? "" : "visibility:hidden;";
-        iframe.style.cssText = `width:100%;height:100%;border:none;display:block;${visibility}`;
+        iframe.style.cssText = `position:absolute;top:0;left:0;width:100%;height:100%;border:none;${visibility}`;
         this.hostContainer.appendChild(iframe);
       }
       const iframeContent = this.generateIFrameHTML();
@@ -564,7 +567,7 @@ class IFrameManager {
 }
 function WorkerWrapper(options) {
   return new Worker(
-    "" + new URL("assets/viji.worker-BnDb6mPh.js", import.meta.url).href,
+    "" + new URL("assets/viji.worker-bm-hvzXt.js", import.meta.url).href,
     {
       type: "module",
       name: options?.name
@@ -1478,13 +1481,17 @@ class MultiOnsetDetection {
         const displayName = bandName === "low" ? "low" : "high";
         if (onset) {
           if (bandName === "low") this.debugOnsetCount++;
-          if (this.consecutiveMisses[displayName] && this.consecutiveMisses[displayName].count > 3) {
-            console.log(`   ⚠️  [${displayName}] ${this.consecutiveMisses[displayName].count} consecutive misses (${this.consecutiveMisses[displayName].lastReason})`);
+          if (this.debugMode) {
+            if (this.consecutiveMisses[displayName] && this.consecutiveMisses[displayName].count > 3) {
+              console.log(`   ⚠️  [${displayName}] ${this.consecutiveMisses[displayName].count} consecutive misses (${this.consecutiveMisses[displayName].lastReason})`);
+            }
           }
           this.consecutiveMisses[displayName] = { count: 0, lastReason: "" };
-          const logCutoff = bandName === "high" ? adjustedCutoff : state.cutoff;
-          const emoji = bandName === "low" ? "🔥" : "✨";
-          console.log(`${emoji} [${displayName}] ONSET${bandName === "low" ? " #" + this.debugOnsetCount : ""}! flux=${flux.toFixed(3)} energy=${energy.toFixed(2)} cutoff=${logCutoff.toFixed(2)}`);
+          if (this.debugMode) {
+            const logCutoff = bandName === "high" ? adjustedCutoff : state.cutoff;
+            const emoji = bandName === "low" ? "🔥" : "✨";
+            console.log(`${emoji} [${displayName}] ONSET${bandName === "low" ? " #" + this.debugOnsetCount : ""}! flux=${flux.toFixed(3)} energy=${energy.toFixed(2)} cutoff=${logCutoff.toFixed(2)}`);
+          }
           if (this.debugMode) {
             const sixteenthNote = 6e4 / this.currentBPM / 4;
             console.log(`   📊 Sharpness: ${sharpness.toFixed(3)} | Raw Flux: ${flux.toFixed(3)} | Emphasized: ${emphasizedFlux.toFixed(3)}`);
@@ -1500,7 +1507,7 @@ class MultiOnsetDetection {
           }
           this.consecutiveMisses[displayName].count++;
           this.consecutiveMisses[displayName].lastReason = failReason;
-          if (this.consecutiveMisses[displayName].count === 1) {
+          if (this.debugMode && this.consecutiveMisses[displayName].count === 1) {
             const timeSince = (now - state.lastOnsetTime).toFixed(0);
             const logCutoff = bandName === "high" ? adjustedCutoff : state.cutoff;
             console.log(`⚠️  [${displayName}] MISS (${failReason}) flux=${flux.toFixed(3)} energy=${energy.toFixed(2)} cutoff=${logCutoff.toFixed(2)} lastOnset=${timeSince}ms ago`);
@@ -1546,7 +1553,7 @@ class MultiOnsetDetection {
           const state = this.bandStates.get(band);
           if (state) {
             state.primaryOnsetHistory.push(now);
-            if (band === "low") {
+            if (band === "low" && this.debugMode) {
               console.log(`   ✓ PRIMARY [low] onset recorded (total: ${state.primaryOnsetHistory.length})`);
             }
           }
@@ -1913,7 +1920,7 @@ class EssentiaOnsetDetection {
     this.initPromise = (async () => {
       try {
         const essentiaModule = await import("./essentia.js-core.es-DnrJE0uR.js");
-        const wasmModule = await import("./essentia-wasm.web-C7QoUtrj.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-C1URJxCY.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) {
@@ -2115,43 +2122,32 @@ class EssentiaOnsetDetection {
         onset: globalOnset,
         strength: clampedStrength,
         bands: {
-          // Low bands: Use complex domain (best for kicks)
           low: {
             onset: kickOnset,
-            // INDEPENDENT detection!
             strength: clampedComplex,
             energy: bandEnergies.low,
             sharpness: kickSharpness
-            // Attack sharpness for kick/bassline discrimination
           },
           lowMid: {
             onset: kickOnset,
-            // Follows kick detection (kick harmonics)
             strength: clampedComplex,
             energy: bandEnergies.lowMid,
             sharpness: kickSharpness
           },
-          // Mid band: Use spectral flux (best for snares)
           mid: {
             onset: snareOnset,
-            // INDEPENDENT detection!
             strength: clampedFlux,
             energy: bandEnergies.mid,
             sharpness: snareSharpness
-            // Transient quality for snare detection
           },
-          // High bands: Use HFC (best for hats)
           highMid: {
             onset: hatOnset,
-            // INDEPENDENT detection!
             strength: clampedHFC,
             energy: bandEnergies.highMid,
             sharpness: hatSharpness
-            // Transient quality for hat detection
           },
           high: {
             onset: hatOnset,
-            // INDEPENDENT detection!
             strength: clampedHFC,
             energy: bandEnergies.high,
             sharpness: hatSharpness
@@ -10230,7 +10226,7 @@ const CONFIDENCE_LOCKED_THRESHOLD = 0.6;
 const BREAKDOWN_THRESHOLD_MS = 2e3;
 const LOST_THRESHOLD_MS = 3e4;
 const GRID_INVALID_THRESHOLD = 0.25;
-const SAMPLE_RATE = 60;
+const SAMPLE_RATE$1 = 60;
 class BeatStateManager {
   // State machine
   state = "TRACKING";
@@ -10267,13 +10263,14 @@ class BeatStateManager {
   // Running average of onset strength
   // Envelope followers for beat energy curves
   envelopes = {
-    kick: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    snare: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    hat: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    any: new EnvelopeFollower(0, 300, SAMPLE_RATE),
-    kickSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE),
-    snareSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE),
-    anySmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE)
+    kick: new EnvelopeFollower(0, 300, SAMPLE_RATE$1),
+    snare: new EnvelopeFollower(0, 300, SAMPLE_RATE$1),
+    hat: new EnvelopeFollower(0, 300, SAMPLE_RATE$1),
+    any: new EnvelopeFollower(0, 300, SAMPLE_RATE$1),
+    kickSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE$1),
+    snareSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE$1),
+    hatSmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE$1),
+    anySmoothed: new EnvelopeFollower(5, 500, SAMPLE_RATE$1)
   };
   // Confidence factors
   tempoMethodAgreement = 0;
@@ -10514,10 +10511,11 @@ class BeatStateManager {
       this.debugKickCount++;
       const kickEvent = detectorEvents.find((e) => e.type === "kick");
       const bands = kickEvent && "bands" in kickEvent ? kickEvent.bands : kickBands;
+      const rawKickStrength = kickEvent?.strength || onsets.bands.low.strength;
       const event = {
         type: "kick",
         time: now,
-        strength: kickEvent?.strength || onsets.bands.low.strength,
+        strength: Math.min(1, rawKickStrength / 5),
         phase: pll.getPhase(),
         bar: pll.getBar(),
         isLayered: classification.snare || classification.hat,
@@ -10538,10 +10536,11 @@ class BeatStateManager {
       this.debugSnareCount++;
       const snareEvent = detectorEvents.find((e) => e.type === "snare");
       const bands = snareEvent && "bands" in snareEvent ? snareEvent.bands : snareBands;
+      const rawSnareStrength = snareEvent?.strength || onsets.bands.mid.strength;
       const event = {
         type: "snare",
         time: now,
-        strength: snareEvent?.strength || onsets.bands.mid.strength,
+        strength: Math.min(1, rawSnareStrength / 5),
         phase: pll.getPhase(),
         bar: pll.getBar(),
         isLayered: classification.kick || classification.hat,
@@ -10562,10 +10561,11 @@ class BeatStateManager {
       this.debugHatCount++;
       const hatEvent = detectorEvents.find((e) => e.type === "hat");
       const bands = hatEvent && "bands" in hatEvent ? hatEvent.bands : hatBands;
+      const rawHatStrength = hatEvent?.strength || onsets.bands.high.strength;
       const event = {
         type: "hat",
         time: now,
-        strength: hatEvent?.strength || onsets.bands.high.strength,
+        strength: Math.min(1, rawHatStrength / 3e3),
         phase: pll.getPhase(),
         bar: pll.getBar(),
         isLayered: classification.kick || classification.snare,
@@ -10596,6 +10596,7 @@ class BeatStateManager {
       any: this.envelopes.any.getValue(),
       kickSmoothed: this.envelopes.kickSmoothed.getValue(),
       snareSmoothed: this.envelopes.snareSmoothed.getValue(),
+      hatSmoothed: this.envelopes.hatSmoothed.getValue(),
       anySmoothed: this.envelopes.anySmoothed.getValue(),
       events: bufferedEvents,
       // Buffered events (persisted for 20ms, reliable for async access)
@@ -11184,9 +11185,7 @@ class BeatStateManager {
     if (snare) {
       const isLayered = timeSinceLastPrimaryKick <= 80;
       const midSharpness2 = bands.mid.sharpness ?? 1;
-      const isHighQuality = midSharpness2 > 0.25 && // Sharp attack (basic transient check)
-      bands.mid.strength > 0.3 && // Strong enough to be reliable
-      midRatio > 0.1;
+      const isHighQuality = midSharpness2 > 0.25 && bands.mid.strength > 0.3 && midRatio > 0.1;
       if (isHighQuality) {
         if (isLayered) {
           this.adaptiveProfiles.snareLayered.samples.push({
@@ -11416,6 +11415,7 @@ class BeatStateManager {
     }
     if (classification.hat) {
       this.envelopes.hat.trigger(1);
+      this.envelopes.hatSmoothed.trigger(1);
       this.envelopes.any.trigger(0.5);
     }
     if (classification.any && !classification.kick && !classification.snare && !classification.hat) {
@@ -11428,8 +11428,32 @@ class BeatStateManager {
     this.envelopes.any.process(0, dtMs);
     this.envelopes.kickSmoothed.process(0, dtMs);
     this.envelopes.snareSmoothed.process(0, dtMs);
+    this.envelopes.hatSmoothed.process(0, dtMs);
     this.envelopes.anySmoothed.process(0, dtMs);
   }
+  /**
+   * Decay envelopes without triggering new beats (used during silent frames)
+   */
+  processEnvelopeDecay(dtMs) {
+    this.envelopes.kick.process(0, dtMs);
+    this.envelopes.snare.process(0, dtMs);
+    this.envelopes.hat.process(0, dtMs);
+    this.envelopes.any.process(0, dtMs);
+    this.envelopes.kickSmoothed.process(0, dtMs);
+    this.envelopes.snareSmoothed.process(0, dtMs);
+    this.envelopes.hatSmoothed.process(0, dtMs);
+    this.envelopes.anySmoothed.process(0, dtMs);
+    return {
+      kick: this.envelopes.kick.getValue(),
+      snare: this.envelopes.snare.getValue(),
+      hat: this.envelopes.hat.getValue(),
+      any: this.envelopes.any.getValue(),
+      kickSmoothed: this.envelopes.kickSmoothed.getValue(),
+      snareSmoothed: this.envelopes.snareSmoothed.getValue(),
+      hatSmoothed: this.envelopes.hatSmoothed.getValue(),
+      anySmoothed: this.envelopes.anySmoothed.getValue()
+    };
+  }
   // ========== INDUSTRY-STANDARD HELPER METHODS ==========
   // NOTE: calculateGridAlignment() and calculateIOIConsistency() removed in Phase 1
   // These were part of advanced filtering that we disabled to maintain compatibility
@@ -12348,6 +12372,382 @@ FFT.prototype._singleRealTransform4 = function _singleRealTransform4(outOff, off
   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";
+          }
+          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 AudioSystem {
   // Audio context and analysis nodes
   audioContext = null;
@@ -12357,14 +12757,8 @@ class AudioSystem {
   analysisMode = "analyser";
   workletNode = null;
   workletReady = false;
+  workletRegistered = false;
   currentSampleRate = 44100;
-  pcmRing = null;
-  pcmWriteIndex = 0;
-  pcmFilled = 0;
-  pcmHistorySeconds = 8;
-  lastTempoExtraction = 0;
-  tempoExtractionIntervalMs = 2e3;
-  analysisBackend = "auto";
   bandNoiseFloor = {
     low: 1e-4,
     lowMid: 1e-4,
@@ -12376,16 +12770,11 @@ class AudioSystem {
   lastNonZeroBpm = 120;
   /** Tracks which source provided the current BPM (pll | tempo | carry | default) */
   lastBpmSource = "default";
-  aubioWarningLogged = false;
-  useEssentiaTempo = false;
-  // disabled by default to avoid WASM exception in some builds
   workletFrameCount = 0;
-  forceAnalyser = false;
-  statusLogTimer = null;
-  isAudioLab = typeof window !== "undefined" && typeof window.location !== "undefined" && window.location.href.includes("audio-lab");
+  lastFrameTime = 0;
+  stalenessTimer = null;
+  static STALENESS_THRESHOLD_MS = 500;
   analysisTicks = 0;
-  lastLoopWarn = 0;
-  verboseLabLogs = this.isAudioLab;
   lastPhaseLogTime = 0;
   onsetLogBuffer = [];
   // Debug logging control
@@ -12414,21 +12803,14 @@ class AudioSystem {
   };
   /** Last dt used in analysis loop (ms) */
   lastDtMs = 0;
-  /** Flag to disable auto-gain for debugging */
-  debugDisableAutoGain = false;
   /** Flag to track if we've logged detection method (to avoid spam) */
   bandNames = ["low", "lowMid", "mid", "highMid", "high"];
   essentiaBandHistories = /* @__PURE__ */ new Map();
   essentiaHistoryWindowMs = 5e3;
-  // Manual BPM mode
-  beatMode = "auto";
-  manualBPM = null;
-  tapHistory = [];
-  tapTimeout = null;
+  // Per-instrument onset tap manager
+  onsetTapManager;
   // Envelope followers for smooth energy curves
   envelopeFollowers;
-  // Global sensitivity multiplier
-  sensitivity = 1;
   // Feature enable flags
   beatDetectionEnabled = true;
   onsetDetectionEnabled = true;
@@ -12443,13 +12825,9 @@ class AudioSystem {
     this.tempoInduction.setDebugMode(enabled);
     this.stateManager.setDebugMode(enabled);
     this.essentiaOnsetDetection?.setDebugMode(enabled);
-    this.toggleStatusLogger(enabled);
-    this.verboseLabLogs = this.isAudioLab || this.debugMode;
     if (enabled) {
       this.diagnosticLogger.start();
-    }
-    if (enabled) {
-      console.log("🔬 [AudioSystem] Debug mode enabled");
+      this.debugLog("[AudioSystem] Debug mode enabled");
     }
   }
   /**
@@ -12487,42 +12865,6 @@ class AudioSystem {
     }
     return clone;
   }
-  logVerbose(label, payload) {
-    if (this.debugMode || this.verboseLabLogs) {
-      console.log(label, payload);
-    }
-  }
-  /**
-   * Start/stop periodic status logging. If maxSamples provided, stops after that many ticks.
-   */
-  toggleStatusLogger(enabled, maxSamples) {
-    if (enabled && !this.statusLogTimer) {
-      let samples = 0;
-      this.statusLogTimer = setInterval(() => {
-        samples++;
-        const a = this.audioState;
-        const maxBand = Math.max(a.bands.low, a.bands.lowMid, a.bands.mid, a.bands.highMid, a.bands.high);
-        console.log("[AudioSystem][status]", {
-          mode: this.analysisMode,
-          workletReady: this.workletReady,
-          workletFrames: this.workletFrameCount,
-          isConnected: a.isConnected,
-          vol: { cur: a.volume.current.toFixed(3), peak: a.volume.peak.toFixed(3) },
-          maxBand: maxBand.toFixed(3),
-          bpm: a.beat.bpm.toFixed(1),
-          bpmSource: this.lastBpmSource,
-          locked: a.beat.isLocked,
-          events: a.beat.events.length
-        });
-        if (maxSamples && samples >= maxSamples) {
-          this.toggleStatusLogger(false);
-        }
-      }, 1e3);
-    } else if (!enabled && this.statusLogTimer) {
-      clearInterval(this.statusLogTimer);
-      this.statusLogTimer = null;
-    }
-  }
   /**
    * Handle frames pushed from AudioWorklet
    */
@@ -12536,8 +12878,9 @@ class AudioSystem {
    */
   analyzeFrame(frame, sampleRate, timestampMs) {
     if (!frame || frame.length === 0) return;
+    this.lastFrameTime = performance.now();
     if (this.workletFrameCount === 1) {
-      console.log("[AudioSystem] First frame received", { sampleRate, mode: this.analysisMode });
+      this.debugLog("[AudioSystem] First frame received", { sampleRate, mode: this.analysisMode });
     }
     const dtMs = this.lastAnalysisTimestamp > 0 ? timestampMs - this.lastAnalysisTimestamp : 1e3 / 60;
     this.lastAnalysisTimestamp = timestampMs;
@@ -12546,15 +12889,11 @@ class AudioSystem {
     const { rms, peak } = this.calculateVolumeMetrics(frame);
     this.audioState.volume.current = rms;
     this.audioState.volume.peak = peak;
-    this.appendPcmFrame(frame, sampleRate);
-    if (this.useEssentiaTempo && timestampMs - this.lastTempoExtraction > this.tempoExtractionIntervalMs) {
-      this.runEssentiaTempoEstimate(sampleRate);
-      this.lastTempoExtraction = timestampMs;
-    }
+    this.lastWaveformFrame = frame;
     const fftResult = this.computeFFT(frame);
     if (!fftResult) {
-      if (this.analysisTicks === 1 || this.analysisTicks % 240 === 0) {
-        console.warn("[AudioSystem][analyzeFrame] computeFFT returned null at tick", this.analysisTicks);
+      if (this.debugMode && (this.analysisTicks === 1 || this.analysisTicks % 240 === 0)) {
+        this.debugLog("[AudioSystem][analyzeFrame] computeFFT returned null at tick", this.analysisTicks);
       }
       return;
     }
@@ -12575,80 +12914,76 @@ class AudioSystem {
         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;
     }
-    const rawBandsForOnsets = {
-      low: bandEnergies.low * this.sensitivity,
-      lowMid: bandEnergies.lowMid * this.sensitivity,
-      mid: bandEnergies.mid * this.sensitivity,
-      highMid: bandEnergies.highMid * this.sensitivity,
-      high: bandEnergies.high * this.sensitivity
-    };
     this.rawBandsPreGain = { ...bandEnergies };
     if (this.autoGainEnabled) {
       this.applyAutoGain();
     }
     this.calculateSpectralFeaturesFromMagnitude(magnitudes, sampleRate, maxMagnitude);
     if (this.onsetDetectionEnabled && this.beatDetectionEnabled) {
-      const beatState = this.runBeatPipeline(rawBandsForOnsets, dtMs, timestampMs, sampleRate);
+      const beatState = this.runBeatPipeline(bandEnergies, dtMs, timestampMs, sampleRate);
       if (beatState) {
-        this.audioState.beat = beatState;
-        const pllState = this.pll.getState();
-        const currentState = this.stateManager.getState();
-        const trackingData = {
-          timeSinceKick: this.stateManager.getTimeSinceLastKick(),
-          phaseError: this.pll.getLastPhaseError(),
-          adaptiveFloors: this.stateManager.getAdaptiveFloors()
-        };
-        const kickPattern = this.stateManager.getKickPattern();
-        if (kickPattern !== void 0) {
-          trackingData.kickPattern = kickPattern;
-        }
-        const bpmVariance = this.stateManager.getBPMVariance();
-        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.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;
-        }
-        this.diagnosticLogger.logFrame(
-          timestampMs,
-          {
-            bpm: beatState.bpm,
-            phase: pllState.phase,
-            bar: pllState.bar,
-            confidence: beatState.confidence,
-            kick: beatState.events.some((e) => e.type === "kick"),
-            snare: beatState.events.some((e) => e.type === "snare"),
-            hat: beatState.events.some((e) => e.type === "hat"),
-            isLocked: currentState === "LOCKED",
-            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
-          },
-          this.stateManager.getLastRejections(),
-          trackingData
-        );
+        const { phase: _phase, bar: _bar, debug: _debug, ...beatForState } = beatState;
+        const now = performance.now();
+        this.audioState.beat = this.onsetTapManager.processFrame(beatForState, now, dtMs);
+        if (this.debugMode) {
+          const pllState = this.pll.getState();
+          const currentState = this.stateManager.getState();
+          const trackingData = {
+            timeSinceKick: this.stateManager.getTimeSinceLastKick(),
+            phaseError: this.pll.getLastPhaseError(),
+            adaptiveFloors: this.stateManager.getAdaptiveFloors()
+          };
+          const kickPattern = this.stateManager.getKickPattern();
+          if (kickPattern !== void 0) trackingData.kickPattern = kickPattern;
+          const bpmVariance = this.stateManager.getBPMVariance();
+          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.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;
+          this.diagnosticLogger.logFrame(
+            timestampMs,
+            {
+              bpm: beatState.bpm,
+              phase: pllState.phase,
+              bar: pllState.bar,
+              confidence: beatState.confidence,
+              kick: beatState.events.some((e) => e.type === "kick"),
+              snare: beatState.events.some((e) => e.type === "snare"),
+              hat: beatState.events.some((e) => e.type === "hat"),
+              isLocked: currentState === "LOCKED",
+              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
+            },
+            this.stateManager.getLastRejections(),
+            trackingData
+          );
+        }
       }
     }
     this.updateSmoothBands(dtMs);
@@ -12658,30 +12993,9 @@ class AudioSystem {
    * Compute FFT and derived arrays
    */
   computeFFT(frame) {
-    if (this.analysisTicks === 1) {
-      console.log("[AudioSystem][computeFFT] FIRST CALL", {
-        hasEngine: !!this.fftEngine,
-        hasInput: !!this.fftInput,
-        hasOutput: !!this.fftOutput,
-        hasWindow: !!this.hannWindow,
-        hasFreqData: !!this.frequencyData,
-        hasMagnitude: !!this.fftMagnitude,
-        hasMagnitudeDb: !!this.fftMagnitudeDb,
-        hasPhase: !!this.fftPhase
-      });
-    }
     if (!this.fftEngine || !this.fftInput || !this.fftOutput || !this.hannWindow || !this.frequencyData || !this.fftMagnitude || !this.fftMagnitudeDb || !this.fftPhase) {
-      if (this.analysisTicks === 1 || this.analysisTicks % 240 === 0) {
-        console.warn("[AudioSystem][computeFFT] RETURNING NULL - ONE OR MORE RESOURCES MISSING");
-        console.warn("  tick:", this.analysisTicks);
-        console.warn("  hasEngine:", !!this.fftEngine);
-        console.warn("  hasInput:", !!this.fftInput);
-        console.warn("  hasOutput:", !!this.fftOutput);
-        console.warn("  hasWindow:", !!this.hannWindow);
-        console.warn("  hasFreqData:", !!this.frequencyData);
-        console.warn("  hasMagnitude:", !!this.fftMagnitude);
-        console.warn("  hasMagnitudeDb:", !!this.fftMagnitudeDb);
-        console.warn("  hasPhase:", !!this.fftPhase);
+      if (this.debugMode && (this.analysisTicks === 1 || this.analysisTicks % 240 === 0)) {
+        this.debugLog("[AudioSystem][computeFFT] RETURNING NULL - resources missing at tick", this.analysisTicks);
       }
       return null;
     }
@@ -12838,63 +13152,13 @@ class AudioSystem {
     } else {
       this.audioState.spectral.flatness = 0;
     }
-    const centroidChange = Math.abs(centroid - this.prevSpectralCentroid);
-    this.audioState.spectral.flux = Math.min(1, centroidChange / 1e3);
-    this.prevSpectralCentroid = centroid;
-  }
-  /**
-   * Append PCM frame to ring buffer for periodic Essentia tempo extraction
-   */
-  appendPcmFrame(frame, sampleRate) {
-    const requiredSize = Math.max(this.fftSize, Math.floor(sampleRate * this.pcmHistorySeconds));
-    if (!this.pcmRing || this.pcmRing.length !== requiredSize) {
-      this.pcmRing = new Float32Array(requiredSize);
-      this.pcmWriteIndex = 0;
-      this.pcmFilled = 0;
-    }
-    for (let i = 0; i < frame.length; i++) {
-      this.pcmRing[this.pcmWriteIndex] = frame[i];
-      this.pcmWriteIndex = (this.pcmWriteIndex + 1) % this.pcmRing.length;
-      if (this.pcmFilled < this.pcmRing.length) {
-        this.pcmFilled++;
-      }
-    }
-  }
-  /**
-   * Periodically estimate tempo using Essentia's RhythmExtractor2013 (offline chunk)
-   */
-  runEssentiaTempoEstimate(sampleRate) {
-    if (!this.essentiaOnsetDetection?.isReady() || !this.pcmRing) {
-      return;
-    }
-    const maxSamples = Math.min(this.pcmRing.length, Math.floor(sampleRate * this.pcmHistorySeconds));
-    const available = Math.min(this.pcmFilled, maxSamples);
-    if (available < sampleRate * 2) return;
-    const window2 = new Float32Array(available);
-    let idx = (this.pcmWriteIndex - available + this.pcmRing.length) % this.pcmRing.length;
-    for (let i = 0; i < available; i++) {
-      window2[i] = this.pcmRing[idx];
-      idx = (idx + 1) % this.pcmRing.length;
-    }
-    const tempo = this.essentiaOnsetDetection.detectTempoFromPCM(window2, sampleRate);
-    if (tempo?.bpm) {
-      const bpm = Math.max(60, Math.min(200, tempo.bpm));
-      this.pll.setBPM(bpm);
-      this.tempoInduction.setManualBPM(bpm);
-    }
   }
   /**
    * Run onset + beat detection pipeline and return BeatState
    */
   runBeatPipeline(rawBandsForOnsets, dtMs, timestampMs, sampleRate) {
     let onsets;
-    const backend = this.analysisBackend;
-    const allowEssentia = backend === "auto" || backend === "essentia";
-    if (backend === "aubio" && !this.aubioWarningLogged) {
-      console.warn("[AudioSystem] Aubio backend selected but not wired yet; using custom pipeline.");
-      this.aubioWarningLogged = true;
-    }
-    const essentiaReady = allowEssentia && (this.essentiaOnsetDetection?.isReady() || false) && !!this.fftMagnitudeDb && !!this.fftPhase;
+    const essentiaReady = (this.essentiaOnsetDetection?.isReady() || false) && !!this.fftMagnitudeDb && !!this.fftPhase;
     const hasFftData = !!(this.fftMagnitudeDb && this.fftPhase);
     if (essentiaReady && hasFftData) {
       const essentiaResult = this.essentiaOnsetDetection.detectFromSpectrum(
@@ -12917,9 +13181,6 @@ class AudioSystem {
     } else {
       onsets = this.onsetDetection.detect(rawBandsForOnsets, dtMs);
     }
-    if (this.beatMode === "manual" && this.manualBPM !== null) {
-      this.tempoInduction.setManualBPM(this.manualBPM);
-    }
     const tempo = this.tempoInduction.update(onsets, dtMs);
     this.onsetDetection.setBPM(tempo.bpm);
     const trackingConf = this.stateManager.calculateTrackingConfidence(tempo);
@@ -12998,7 +13259,7 @@ class AudioSystem {
     const prevSource = this.lastBpmSource;
     this.lastNonZeroBpm = resolvedBpm;
     this.lastBpmSource = selected.source;
-    if ((this.debugMode || this.verboseLabLogs) && prevSource !== this.lastBpmSource) {
+    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 };
@@ -13016,8 +13277,6 @@ class AudioSystem {
   // Analysis configuration (optimized for onset detection)
   fftSize = 2048;
   // Good balance for quality vs performance
-  smoothingTimeConstant = 0;
-  // NO smoothing for onset detection (was 0.5 which killed transients!)
   // High-speed analysis for onset detection (separate from RAF)
   analysisInterval = null;
   analysisIntervalMs = 8;
@@ -13060,28 +13319,26 @@ class AudioSystem {
       any: 0,
       kickSmoothed: 0,
       snareSmoothed: 0,
+      hatSmoothed: 0,
       anySmoothed: 0,
       events: [],
       bpm: 120,
-      phase: 0,
-      bar: 0,
       confidence: 0,
       isLocked: false
     },
     spectral: {
       brightness: 0,
-      flatness: 0,
-      flux: 0
+      flatness: 0
     }
   };
+  // Waveform data for transfer to worker
+  lastWaveformFrame = null;
   // Analysis loop
   analysisLoopId = null;
   isAnalysisRunning = false;
   lastAnalysisTimestamp = 0;
   // Callback to send results to worker
   sendAnalysisResults = null;
-  // Previous spectral centroid for change calculation
-  prevSpectralCentroid = 0;
   constructor(sendAnalysisResultsCallback) {
     this.handleAudioStreamUpdate = this.handleAudioStreamUpdate.bind(this);
     this.performAnalysis = this.performAnalysis.bind(this);
@@ -13092,6 +13349,7 @@ class AudioSystem {
     this.tempoInduction = new TempoInduction();
     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),
@@ -13109,6 +13367,7 @@ class AudioSystem {
       any: new EnvelopeFollower(0, 300, sampleRate),
       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),
@@ -13121,10 +13380,6 @@ class AudioSystem {
     };
     this.refreshFFTResources();
     this.resetEssentiaBandHistories();
-    if (this.isAudioLab) {
-      this.forceAnalyser = true;
-      console.warn("[AudioSystem] Audio-lab context detected: forcing analyser path for stability.");
-    }
   }
   /**
    * Prepare FFT buffers and windowing for the selected fftSize
@@ -13160,9 +13415,7 @@ class AudioSystem {
     if (!this.essentiaOnsetDetection) return;
     try {
       await this.essentiaOnsetDetection.initialize();
-      if (this.debugMode) {
-        console.log("✅ [AudioSystem] Essentia.js initialized successfully!");
-      }
+      this.debugLog("[AudioSystem] Essentia.js initialized successfully");
     } catch (error) {
       console.warn("⚠️  [AudioSystem] Essentia.js initialization failed, using custom onset detection:", error);
     }
@@ -13192,9 +13445,6 @@ class AudioSystem {
       } else {
         this.disconnectAudioStream();
       }
-      if (data.analysisConfig) {
-        this.updateAnalysisConfig(data.analysisConfig);
-      }
     } catch (error) {
       console.error("Error handling audio stream update:", error);
       this.audioState.isConnected = false;
@@ -13225,7 +13475,7 @@ class AudioSystem {
         }
       }
       this.mediaStreamSource = this.audioContext.createMediaStreamSource(audioStream);
-      this.workletReady = !this.forceAnalyser && await this.setupAudioWorklet();
+      this.workletReady = await this.setupAudioWorklet();
       if (this.workletReady && this.workletNode) {
         this.analysisMode = "worklet";
         this.currentSampleRate = this.audioContext.sampleRate;
@@ -13234,7 +13484,7 @@ class AudioSystem {
         this.debugLog("Audio worklet analysis enabled");
         setTimeout(() => {
           if (this.analysisMode === "worklet" && this.workletFrameCount === 0) {
-            console.warn("[AudioSystem] Worklet produced no frames, falling back to analyser.");
+            this.debugLog("[AudioSystem] Worklet produced no frames, falling back to analyser.");
             this.analysisMode = "analyser";
             if (this.workletNode) {
               try {
@@ -13247,7 +13497,7 @@ class AudioSystem {
             this.workletReady = false;
             this.analyser = this.audioContext.createAnalyser();
             this.analyser.fftSize = this.fftSize;
-            this.analyser.smoothingTimeConstant = this.smoothingTimeConstant;
+            this.analyser.smoothingTimeConstant = 0;
             this.mediaStreamSource.connect(this.analyser);
             bufferLength = this.analyser.frequencyBinCount;
             this.frequencyData = new Uint8Array(bufferLength);
@@ -13259,7 +13509,7 @@ class AudioSystem {
         this.analysisMode = "analyser";
         this.analyser = this.audioContext.createAnalyser();
         this.analyser.fftSize = this.fftSize;
-        this.analyser.smoothingTimeConstant = this.smoothingTimeConstant;
+        this.analyser.smoothingTimeConstant = 0;
         this.mediaStreamSource.connect(this.analyser);
         this.debugLog("Audio worklet unavailable, using analyser fallback");
         bufferLength = this.analyser.frequencyBinCount;
@@ -13275,17 +13525,17 @@ class AudioSystem {
         this.startAnalysisLoop();
       }
       if (this.analysisMode === "analyser" && !this.isAnalysisRunning) {
-        console.warn("[AudioSystem] Analysis loop not running after setup, forcing start.");
+        this.debugLog("[AudioSystem] Analysis loop not running after setup, forcing start.");
         this.startAnalysisLoop();
       }
       const tracks = audioStream.getAudioTracks();
-      this.logVerbose("[AudioSystem] Stream info", {
+      this.debugLog("[AudioSystem] Stream info", {
         trackCount: tracks.length,
         trackSettings: tracks.map((t) => t.getSettings?.() || {}),
         trackMuted: tracks.map((t) => t.muted),
-        forceAnalyser: this.forceAnalyser,
         mode: this.analysisMode
       });
+      this.startStalenessTimer();
       this.debugLog("Audio stream connected successfully (host-side)", {
         sampleRate: this.audioContext.sampleRate,
         fftSize: this.fftSize,
@@ -13303,6 +13553,7 @@ class AudioSystem {
    */
   disconnectAudioStream() {
     this.stopAnalysisLoop();
+    this.stopStalenessTimer();
     this.resetEssentiaBandHistories();
     if (this.mediaStreamSource) {
       this.mediaStreamSource.disconnect();
@@ -13333,27 +13584,6 @@ class AudioSystem {
     this.sendAnalysisResultsToWorker();
     this.debugLog("Audio stream disconnected (host-side)");
   }
-  /**
-   * Update analysis configuration
-   */
-  updateAnalysisConfig(config) {
-    let needsReconnect = false;
-    if (config.fftSize && config.fftSize !== this.fftSize) {
-      this.fftSize = config.fftSize;
-      this.refreshFFTResources();
-      needsReconnect = true;
-    }
-    if (config.smoothing !== void 0) {
-      this.smoothingTimeConstant = config.smoothing;
-      if (this.analyser) {
-        this.analyser.smoothingTimeConstant = this.smoothingTimeConstant;
-      }
-    }
-    if (needsReconnect && this.currentStream) {
-      const stream = this.currentStream;
-      this.setAudioStream(stream);
-    }
-  }
   /**
    * Initialize audio worklet for high-quality capture (complex STFT path)
    */
@@ -13362,50 +13592,54 @@ class AudioSystem {
       return false;
     }
     try {
-      const workletSource = `
-        class AudioAnalysisProcessor extends AudioWorkletProcessor {
-          constructor(options) {
-            super();
-            const opts = (options && options.processorOptions) || {};
-            this.windowSize = opts.fftSize || 2048;
-            this.hopSize = opts.hopSize || this.windowSize / 2;
-            this.buffer = new Float32Array(this.windowSize);
-            this.writeIndex = 0;
-          }
-          process(inputs, outputs) {
-            const input = inputs[0];
-            const output = outputs[0];
-            const channel = input && input[0];
-            if (output) {
-              for (let ch = 0; ch < output.length; ch++) {
-                output[ch].fill(0);
-              }
+      if (!this.workletRegistered) {
+        const workletSource = `
+          class AudioAnalysisProcessor extends AudioWorkletProcessor {
+            constructor(options) {
+              super();
+              const opts = (options && options.processorOptions) || {};
+              this.windowSize = opts.fftSize || 2048;
+              this.hopSize = opts.hopSize || this.windowSize / 2;
+              this.buffer = new Float32Array(this.windowSize);
+              this.writeIndex = 0;
             }
-            if (!channel) return true;
-            for (let i = 0; i < channel.length; i++) {
-              this.buffer[this.writeIndex++] = channel[i];
-              if (this.writeIndex >= this.windowSize) {
-                const frame = new Float32Array(this.windowSize);
-                frame.set(this.buffer);
-                this.port.postMessage(
-                  { type: 'audio-frame', samples: frame, sampleRate, timestamp: currentTime * 1000 },
-                  [frame.buffer]
-                );
-                const overlap = this.windowSize - this.hopSize;
-                if (overlap > 0) {
-                  this.buffer.set(this.buffer.subarray(this.hopSize, this.windowSize), 0);
+            process(inputs, outputs) {
+              const input = inputs[0];
+              const output = outputs[0];
+              const channel = input && input[0];
+              if (output) {
+                for (let ch = 0; ch < output.length; ch++) {
+                  output[ch].fill(0);
+                }
+              }
+              if (!channel) return true;
+              for (let i = 0; i < channel.length; i++) {
+                this.buffer[this.writeIndex++] = channel[i];
+                if (this.writeIndex >= this.windowSize) {
+                  const frame = new Float32Array(this.windowSize);
+                  frame.set(this.buffer);
+                  this.port.postMessage(
+                    { type: 'audio-frame', samples: frame, sampleRate, timestamp: currentTime * 1000 },
+                    [frame.buffer]
+                  );
+                  const overlap = this.windowSize - this.hopSize;
+                  if (overlap > 0) {
+                    this.buffer.set(this.buffer.subarray(this.hopSize, this.windowSize), 0);
+                  }
+                  this.writeIndex = overlap > 0 ? overlap : 0;
                 }
-                this.writeIndex = overlap > 0 ? overlap : 0;
               }
+              return true;
             }
-            return true;
           }
-        }
-        registerProcessor('audio-analysis-processor', AudioAnalysisProcessor);
-      `;
-      const blob = new Blob([workletSource], { type: "application/javascript" });
-      const workletUrl = URL.createObjectURL(blob);
-      await this.audioContext.audioWorklet.addModule(workletUrl);
+          registerProcessor('audio-analysis-processor', AudioAnalysisProcessor);
+        `;
+        const blob = new Blob([workletSource], { type: "application/javascript" });
+        const workletUrl = URL.createObjectURL(blob);
+        await this.audioContext.audioWorklet.addModule(workletUrl);
+        URL.revokeObjectURL(workletUrl);
+        this.workletRegistered = true;
+      }
       this.workletNode = new AudioWorkletNode(this.audioContext, "audio-analysis-processor", {
         numberOfOutputs: 1,
         outputChannelCount: [1],
@@ -13431,26 +13665,15 @@ class AudioSystem {
    * Start the audio analysis loop at high speed (8ms intervals for transient capture)
    */
   startAnalysisLoop() {
-    console.log("[AudioSystem] startAnalysisLoop called", {
-      isAnalysisRunning: this.isAnalysisRunning,
-      analysisMode: this.analysisMode,
-      hasAnalyser: !!this.analyser,
-      hasContext: !!this.audioContext
-    });
     if (this.isAnalysisRunning || this.analysisMode !== "analyser") {
-      console.warn("[AudioSystem] startAnalysisLoop SKIPPED", {
-        isAnalysisRunning: this.isAnalysisRunning,
-        analysisMode: this.analysisMode
-      });
       return;
     }
     this.isAnalysisRunning = true;
     this.analysisInterval = window.setInterval(() => {
       this.performAnalysis();
     }, this.analysisIntervalMs);
-    console.log("[AudioSystem] ✅ Analysis loop started", {
-      intervalMs: this.analysisIntervalMs,
-      intervalId: this.analysisInterval
+    this.debugLog("[AudioSystem] Analysis loop started", {
+      intervalMs: this.analysisIntervalMs
     });
   }
   /**
@@ -13467,6 +13690,24 @@ class AudioSystem {
       this.analysisLoopId = null;
     }
   }
+  startStalenessTimer() {
+    this.stopStalenessTimer();
+    this.lastFrameTime = performance.now();
+    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();
+      }
+    }, 250);
+  }
+  stopStalenessTimer() {
+    if (this.stalenessTimer !== null) {
+      clearInterval(this.stalenessTimer);
+      this.stalenessTimer = null;
+    }
+  }
   /**
    * Pause audio analysis (for tests or temporary suspension)
    * The setInterval continues but performAnalysis() exits early
@@ -13489,25 +13730,7 @@ class AudioSystem {
    * Layer 4: BeatStateManager (state machine + confidence)
    */
   performAnalysis() {
-    if (this.analysisTicks === 0) {
-      console.log("[AudioSystem] performAnalysis FIRST CALL", {
-        isAnalysisRunning: this.isAnalysisRunning,
-        mode: this.analysisMode,
-        hasContext: !!this.audioContext,
-        hasAnalyser: !!this.analyser
-      });
-    }
     if (!this.isAnalysisRunning || this.analysisMode !== "analyser" || !this.audioContext || !this.analyser) {
-      const now = performance.now();
-      if (now - this.lastLoopWarn > 2e3) {
-        console.warn("[AudioSystem] performAnalysis skipped", {
-          isAnalysisRunning: this.isAnalysisRunning,
-          mode: this.analysisMode,
-          hasContext: !!this.audioContext,
-          hasAnalyser: !!this.analyser
-        });
-        this.lastLoopWarn = now;
-      }
       return;
     }
     if (!this.timeDomainData || this.timeDomainData.length !== this.fftSize) {
@@ -13515,14 +13738,6 @@ class AudioSystem {
     }
     this.analyser.getFloatTimeDomainData(this.timeDomainData);
     this.analysisTicks++;
-    if (this.analysisTicks === 1) {
-      console.log("[AudioSystem][analyser] first tick", {
-        fftSize: this.fftSize,
-        sampleRate: this.audioContext.sampleRate,
-        bufLen: this.timeDomainData.length
-      });
-      this.logVerbose("[AudioSystem][analyser] first 8 samples", Array.from(this.timeDomainData.slice(0, 8)));
-    }
     for (let i = 0; i < 32 && i < this.timeDomainData.length; i++) {
       Math.abs(this.timeDomainData[i]);
     }
@@ -13530,9 +13745,6 @@ class AudioSystem {
     this.analyzeFrame(this.timeDomainData, this.audioContext.sampleRate, detectionTimeMs);
   }
   applyAutoGain() {
-    if (this.debugDisableAutoGain) {
-      return;
-    }
     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;
@@ -13578,12 +13790,17 @@ class AudioSystem {
   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: {
-          ...this.audioState,
+          isConnected: this.audioState.isConnected,
+          volume: this.audioState.volume,
+          bands: this.audioState.bands,
+          beat: this.audioState.beat,
+          spectral: this.audioState.spectral,
           frequencyData,
-          // For getFrequencyData() access
+          waveformData,
           timestamp: performance.now()
         }
       });
@@ -13607,18 +13824,16 @@ class AudioSystem {
       any: 0,
       kickSmoothed: 0,
       snareSmoothed: 0,
+      hatSmoothed: 0,
       anySmoothed: 0,
       events: [],
       bpm: 120,
-      phase: 0,
-      bar: 0,
       confidence: 0,
       isLocked: false
     };
     this.audioState.spectral = {
       brightness: 0,
-      flatness: 0,
-      flux: 0
+      flatness: 0
     };
   }
   /**
@@ -13633,6 +13848,7 @@ class AudioSystem {
     }
     this.workletNode = null;
     this.workletReady = false;
+    this.workletRegistered = false;
     this.analysisMode = "analyser";
     this.onsetDetection.reset();
     this.tempoInduction.reset();
@@ -13640,183 +13856,48 @@ class AudioSystem {
     this.stateManager.reset();
     this.volumeAutoGain.reset();
     Object.values(this.bandAutoGain).forEach((g) => g.reset());
-    this.beatMode = "auto";
-    this.manualBPM = null;
-    this.tapHistory = [];
-    if (this.tapTimeout) {
-      clearTimeout(this.tapTimeout);
-      this.tapTimeout = null;
-    }
+    this.onsetTapManager.reset();
     Object.values(this.envelopeFollowers).forEach((env) => env.reset());
-    this.pcmRing = null;
-    this.pcmWriteIndex = 0;
-    this.pcmFilled = 0;
-    this.lastTempoExtraction = 0;
     this.resetAudioValues();
   }
-  /**
-   * Get current analysis configuration
-   */
-  getAnalysisConfig() {
-    return {
-      fftSize: this.fftSize,
-      smoothing: this.smoothingTimeConstant
-    };
-  }
-  /**
-   * Set analysis backend preference
-   */
-  setAnalysisBackend(backend) {
-    this.analysisBackend = backend;
-  }
-  getAnalysisBackend() {
-    return this.analysisBackend;
-  }
-  /**
-   * Force analyser path (skip worklet) for debugging
-   */
-  setForceAnalyser(enabled) {
-    this.forceAnalyser = enabled;
-    if (enabled) {
-      console.warn("[AudioSystem] forceAnalyser enabled - worklet will be skipped.");
-    }
-  }
-  isForceAnalyser() {
-    return this.forceAnalyser;
-  }
-  /**
-   * Enable/disable Essentia tempo extraction (disabled by default due to WASM exception config)
-   */
-  setEssentiaTempoEnabled(enabled) {
-    this.useEssentiaTempo = enabled;
-  }
-  isEssentiaTempoEnabled() {
-    return this.useEssentiaTempo;
-  }
   // ═══════════════════════════════════════════════════════════
   // Public API Methods for Audio Analysis Configuration
   // ═══════════════════════════════════════════════════════════
   /**
-   * Set global sensitivity multiplier
-   * @param value - Sensitivity (0.5-2.0, default 1.0)
+   * Record a tap for the specified instrument onset
    */
-  setSensitivity(value) {
-    this.sensitivity = Math.max(0.5, Math.min(2, value));
+  tapOnset(instrument) {
+    this.onsetTapManager.tap(instrument);
   }
   /**
-   * Get current sensitivity
+   * Clear tap pattern for an instrument, restoring auto-detection
    */
-  getSensitivity() {
-    return this.sensitivity;
+  clearOnsetTap(instrument) {
+    this.onsetTapManager.clear(instrument);
   }
   /**
-   * Tap tempo - record tap for manual BPM
+   * Get the current onset mode for an instrument
    */
-  tapTempo() {
-    const now = performance.now();
-    if (this.tapTimeout) {
-      clearTimeout(this.tapTimeout);
-    }
-    if (this.tapHistory.length > 0) {
-      const lastTap = this.tapHistory[this.tapHistory.length - 1];
-      const interval = now - lastTap;
-      if (interval < 200) {
-        this.startTapClearTimeout();
-        return;
-      }
-      if (interval > 2e3) {
-        this.tapHistory = [];
-      }
-    }
-    this.tapHistory.push(now);
-    if (this.tapHistory.length > 8) {
-      this.tapHistory.shift();
-    }
-    if (this.tapHistory.length >= 2) {
-      const bpm = this.calculateBPMFromTaps();
-      this.manualBPM = bpm;
-      this.beatMode = "manual";
-      this.pll.setBPM(bpm);
-      this.tempoInduction.setManualBPM(bpm);
-    }
-    this.startTapClearTimeout();
-  }
-  /**
-   * Calculate BPM from tap history
-   */
-  calculateBPMFromTaps() {
-    if (this.tapHistory.length < 2) return 120;
-    const intervals = [];
-    for (let i = 1; i < this.tapHistory.length; i++) {
-      intervals.push(this.tapHistory[i] - this.tapHistory[i - 1]);
-    }
-    if (intervals.length >= 4) {
-      const sorted = [...intervals].sort((a, b) => a - b);
-      const median = sorted[Math.floor(sorted.length / 2)];
-      const filtered = intervals.filter((val) => {
-        const deviation = Math.abs(val - median) / median;
-        return deviation < 0.3;
-      });
-      if (filtered.length >= 2) {
-        intervals.splice(0, intervals.length, ...filtered);
-      }
-    }
-    const avgInterval = intervals.reduce((sum, val) => sum + val, 0) / intervals.length;
-    let bpm = 6e4 / avgInterval;
-    while (bpm > 200) bpm /= 2;
-    while (bpm < 60) bpm *= 2;
-    return Math.round(bpm * 10) / 10;
-  }
-  /**
-   * Start auto-clear timeout for tap tempo
-   */
-  startTapClearTimeout() {
-    this.tapTimeout = setTimeout(() => {
-      this.tapHistory = [];
-    }, 2e3);
+  getOnsetMode(instrument) {
+    return this.onsetTapManager.getMode(instrument);
   }
   /**
-   * Clear tap tempo history
+   * Get pattern info for an instrument (null if no pattern recognized)
    */
-  clearTaps() {
-    this.tapHistory = [];
-    if (this.tapTimeout) {
-      clearTimeout(this.tapTimeout);
-      this.tapTimeout = null;
-    }
+  getOnsetPatternInfo(instrument) {
+    return this.onsetTapManager.getPatternInfo(instrument);
   }
   /**
-   * Get tap count
+   * Mute/unmute an instrument onset (suppresses output without destroying state)
    */
-  getTapCount() {
-    return this.tapHistory.length;
+  setOnsetMuted(instrument, muted) {
+    this.onsetTapManager.setMuted(instrument, muted);
   }
   /**
-   * Set beat sync mode
+   * Check if an instrument onset is muted
    */
-  setBeatMode(mode) {
-    this.beatMode = mode;
-    if (mode === "auto") {
-      this.clearTaps();
-      this.manualBPM = null;
-    }
-  }
-  /**
-   * Get beat sync mode
-   */
-  getBeatMode() {
-    return this.beatMode;
-  }
-  /**
-   * Set manual BPM
-   */
-  setManualBPM(bpm) {
-    bpm = Math.max(60, Math.min(200, bpm));
-    this.manualBPM = bpm;
-    this.beatMode = "manual";
-    this.pll.setBPM(bpm);
-    this.tempoInduction.setManualBPM(bpm);
-    this.clearTaps();
+  isOnsetMuted(instrument) {
+    return this.onsetTapManager.isMuted(instrument);
   }
   /**
    * Get current BPM (manual or auto-detected)
@@ -13848,21 +13929,11 @@ class AudioSystem {
       this.setAudioStream(stream);
     }
   }
-  /**
-   * Set smoothing time constant
-   */
-  setSmoothing(value) {
-    this.smoothingTimeConstant = Math.max(0, Math.min(1, value));
-    if (this.analyser) {
-      this.analyser.smoothingTimeConstant = this.smoothingTimeConstant;
-    }
-  }
   /**
    * Enable/disable auto-gain
    */
   setAutoGain(enabled) {
     this.autoGainEnabled = enabled;
-    this.debugDisableAutoGain = !enabled;
     if (!enabled) {
       this.volumeAutoGain.reset();
       Object.values(this.bandAutoGain).forEach((g) => g.reset());
@@ -13896,11 +13967,13 @@ class AudioSystem {
       isConnected: this.audioState.isConnected,
       currentBPM: this.pll.getBPM(),
       confidence: this.tempoInduction.getConfidence(),
-      mode: this.beatMode,
-      tapCount: this.tapHistory.length,
       isLocked: this.stateManager.isLocked(),
-      sensitivity: this.sensitivity,
-      trackingState: this.stateManager.getState()
+      trackingState: this.stateManager.getState(),
+      onsetModes: {
+        kick: this.onsetTapManager.getMode("kick"),
+        snare: this.onsetTapManager.getMode("snare"),
+        hat: this.onsetTapManager.getMode("hat")
+      }
     };
   }
   /**
@@ -13979,7 +14052,6 @@ class AudioSystem {
       volumeGain: this.volumeAutoGain.getGain(),
       // Timing info
       dtMs: this.lastDtMs,
-      smoothingTimeConstant: this.smoothingTimeConstant,
       analysisIntervalMs: this.analysisIntervalMs,
       // Current events
       events: [...this.audioState.beat.events]
@@ -14538,15 +14610,25 @@ class VijiCore {
   currentAudioStream = null;
   // ═══════════════════════════════════════════════════════════════════════════
   // VIDEO STREAM INDEX CONTRACT:
-  // Index 0: ALWAYS reserved for main video (with CV) - even when absent
-  // Index 1..N: Additional streams (no CV) - where N = videoStreams.length
-  // Index N+1..: Device streams - dynamically allocated, tracked in deviceVideoStreamIndices
+  // Each stream category uses a fixed, independent index range in the worker's
+  // videoSystems[] array. Categories cannot collide regardless of add/remove order.
+  //
+  //   Index 0:         Main video (with CV) - always reserved, even when absent
+  //   Index 1..99:     Additional MediaStreams (no CV)
+  //   Index 100..199:  Device video streams
+  //   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.
   // ═══════════════════════════════════════════════════════════════════════════
+  static ADDITIONAL_STREAM_BASE = 1;
+  static DEVICE_VIDEO_BASE = 100;
+  static DIRECT_FRAME_BASE = 200;
   // Separated video stream management
   videoStream = null;
   // Main stream (CV enabled) - always index 0
   videoStreams = [];
-  // Additional streams (no CV) - indices 1..N
+  // Additional streams (no CV)
   // Video coordinators
   mainVideoCoordinator = null;
   additionalCoordinators = [];
@@ -14554,7 +14636,6 @@ class VijiCore {
   directFrameSlots = 0;
   // Device video management (coordinators only, for cleanup)
   deviceVideoCoordinators = /* @__PURE__ */ new Map();
-  // Track assigned stream indices to prevent collisions (indices start at 1 + videoStreams.length)
   deviceVideoStreamIndices = /* @__PURE__ */ new Map();
   // Auto-capture frame buffer (zero-copy transfer)
   latestFrameBuffer = null;
@@ -14595,7 +14676,6 @@ class VijiCore {
     this.config = {
       ...config,
       frameRateMode: config.frameRateMode || "full",
-      parameters: config.parameters || [],
       noInputs: config.noInputs ?? false,
       // Canvas DOM interaction disabled in headless by default
       // InteractionManager (viji.mouse/etc) always exists regardless
@@ -14632,7 +14712,8 @@ class VijiCore {
     this.latestFrameBuffer = bitmap;
   }
   /**
-   * Get latest frame (transfers ownership, zero-copy)
+   * Get latest frame (transfers ownership, zero-copy).
+   * Internal: consumed by getLatestFramesFromSources().
    */
   getLatestFrame() {
     const frame = this.latestFrameBuffer;
@@ -14688,7 +14769,6 @@ class VijiCore {
     if (this.interactionManager && "setDebugMode" in this.interactionManager) {
       this.interactionManager.setDebugMode(enabled);
     }
-    if (this.audioSystem && "setDebugMode" in this.audioSystem) ;
     if (this.mainVideoCoordinator && "setDebugMode" in this.mainVideoCoordinator) {
       this.mainVideoCoordinator.setDebugMode(enabled);
     }
@@ -14722,15 +14802,6 @@ class VijiCore {
   hide() {
     this.iframeManager?.hide();
   }
-  /**
-   * Select audio analysis backend
-   */
-  setAudioAnalysisBackend(backend) {
-    this.audioSystem?.setAnalysisBackend(backend);
-  }
-  getAudioAnalysisBackend() {
-    return this.audioSystem?.getAnalysisBackend() ?? "auto";
-  }
   /**
    * Initializes the core components in sequence
    */
@@ -14793,7 +14864,7 @@ class VijiCore {
         });
       }
       for (let i = 0; i < this.videoStreams.length; i++) {
-        const streamIndex = 1 + i;
+        const streamIndex = VijiCore.ADDITIONAL_STREAM_BASE + i;
         const coordinator = new VideoCoordinator((message, transfer) => {
           if (this.workerManager) {
             if (message.type === "video-canvas-setup") {
@@ -15209,13 +15280,6 @@ class VijiCore {
   // ═══════════════════════════════════════════════════════════════════════════
   // Direct Frame Injection API (Compositor Pipeline)
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Worker-side stream index offset for direct frame slots.
-   * Accounts for main video stream and additional media streams.
-   */
-  get directFrameStartIndex() {
-    return (this.videoStream ? 1 : 0) + this.videoStreams.length;
-  }
   /**
    * Ensure the worker has enough direct frame slots prepared.
    * Auto-grows as needed; skips if already sufficient.
@@ -15224,8 +15288,7 @@ class VijiCore {
     if (count <= this.directFrameSlots) return;
     this.directFrameSlots = count;
     this.workerManager.postMessage("video-streams-prepare", {
-      mainStream: !!this.videoStream,
-      mediaStreamCount: this.videoStreams.length,
+      directFrameBaseIndex: VijiCore.DIRECT_FRAME_BASE,
       directFrameCount: count
     });
     this.debugLog(`[Compositor] Prepared ${count} direct frame slot(s)`);
@@ -15242,27 +15305,10 @@ class VijiCore {
     this.ensureDirectFrameSlots(streamIndex + 1);
     this.workerManager.postMessage("video-frame-direct", {
       imageBitmap: bitmap,
-      streamIndex: this.directFrameStartIndex + streamIndex,
+      streamIndex: VijiCore.DIRECT_FRAME_BASE + streamIndex,
       timestamp: performance.now()
     }, [bitmap]);
   }
-  /**
-   * Inject frames for all direct-frame stream slots at once (compositor pipeline).
-   * Auto-prepares slots on first call. Transfers ownership of all bitmaps (zero-copy).
-   */
-  injectFrames(bitmaps) {
-    if (!this.workerManager?.ready) {
-      throw new VijiCoreError("Core not ready", "NOT_READY");
-    }
-    this.ensureDirectFrameSlots(bitmaps.length);
-    bitmaps.forEach((bitmap, index) => {
-      this.workerManager.postMessage("video-frame-direct", {
-        imageBitmap: bitmap,
-        streamIndex: this.directFrameStartIndex + index,
-        timestamp: performance.now()
-      }, [bitmap]);
-    });
-  }
   /**
    * Link this core to receive events from a source core
    * @param syncResolution Smart default: true for headless, false for visible
@@ -15597,7 +15643,6 @@ class VijiCore {
     if (this.audioSystem) {
       this.audioSystem.handleAudioStreamUpdate({
         audioStream,
-        ...this.config.analysisConfig && { analysisConfig: this.config.analysisConfig },
         timestamp: performance.now()
       });
     }
@@ -15657,31 +15702,10 @@ class VijiCore {
     return this.videoStream;
   }
   // ═══════════════════════════════════════════════════════
-  // ADDITIONAL VIDEO STREAMS API (new)
+  // ADDITIONAL VIDEO STREAMS API
   // ═══════════════════════════════════════════════════════
   /**
-   * Sets all additional video streams (no CV)
-   */
-  async setVideoStreams(streams) {
-    this.validateReady();
-    this.videoStreams = [...streams];
-    await this.reinitializeAdditionalCoordinators();
-    this.debugLog(`Additional video streams updated: ${streams.length} streams`);
-  }
-  /**
-   * Gets all additional video streams
-   */
-  getVideoStreams() {
-    return [...this.videoStreams];
-  }
-  /**
-   * Gets video stream at specific index
-   */
-  getVideoStreamAt(index) {
-    return this.videoStreams[index] || null;
-  }
-  /**
-   * Adds a video stream
+   * Adds an additional video stream (no CV). Returns its index in viji.streams[].
    */
   async addVideoStream(stream) {
     this.validateReady();
@@ -15689,7 +15713,7 @@ class VijiCore {
     if (existingIndex !== -1) return existingIndex;
     this.videoStreams.push(stream);
     const newIndex = this.videoStreams.length - 1;
-    const streamIndex = 1 + newIndex;
+    const streamIndex = VijiCore.ADDITIONAL_STREAM_BASE + newIndex;
     const coordinator = new VideoCoordinator((message, transfer) => {
       if (this.workerManager) {
         if (message.type === "video-canvas-setup") {
@@ -15714,9 +15738,9 @@ class VijiCore {
     return newIndex;
   }
   /**
-   * Removes video stream at index
+   * Removes an additional video stream by index.
    */
-  async removeVideoStreamAt(index) {
+  async removeVideoStream(index) {
     this.validateReady();
     if (index < 0 || index >= this.videoStreams.length) {
       throw new VijiCoreError(`Invalid stream index: ${index}`, "INVALID_INDEX");
@@ -15726,43 +15750,19 @@ class VijiCore {
     await this.reinitializeAdditionalCoordinators();
   }
   /**
-   * Removes video stream by reference
+   * Gets the number of additional video streams.
    */
-  async removeVideoStream(stream) {
-    const index = this.videoStreams.indexOf(stream);
-    if (index === -1) return false;
-    await this.removeVideoStreamAt(index);
-    return true;
+  getVideoStreamCount() {
+    return this.videoStreams.length;
   }
   /**
-   * Updates video stream at index
-   */
-  async setVideoStreamAt(index, stream) {
-    this.validateReady();
-    if (index < 0 || index >= this.videoStreams.length) {
-      throw new VijiCoreError(`Invalid stream index: ${index}`, "INVALID_INDEX");
-    }
-    this.videoStreams[index].getTracks().forEach((track) => track.stop());
-    this.videoStreams[index] = stream;
-    if (this.additionalCoordinators[index]) {
-      this.additionalCoordinators[index].resetVideoState();
-      this.additionalCoordinators[index].handleVideoStreamUpdate({
-        videoStream: stream,
-        streamIndex: 1 + index,
-        streamType: "additional",
-        targetFrameRate: 30,
-        timestamp: performance.now()
-      });
-    }
-  }
-  /**
-   * Reinitializes all additional coordinators
+   * Reinitializes all additional coordinators after array mutation.
    */
   async reinitializeAdditionalCoordinators() {
     this.additionalCoordinators.forEach((coord) => coord.resetVideoState());
     this.additionalCoordinators = [];
     for (let i = 0; i < this.videoStreams.length; i++) {
-      const streamIndex = 1 + i;
+      const streamIndex = VijiCore.ADDITIONAL_STREAM_BASE + i;
       const coordinator = new VideoCoordinator((message, transfer) => {
         if (this.workerManager) {
           if (message.type === "video-canvas-setup") {
@@ -15822,98 +15822,82 @@ class VijiCore {
   // Audio Analysis API (Namespace-based)
   // ═══════════════════════════════════════════════════════════
   audio = {
-    /**
-     * Set global audio sensitivity (0.5-2.0, default 1.0)
-     */
-    setSensitivity: (value) => {
-      this.validateReady();
-      if (value < 0.5 || value > 2) {
-        throw new VijiCoreError("Sensitivity must be between 0.5 and 2.0", "INVALID_VALUE");
-      }
-      this.audioSystem?.setSensitivity(value);
-      this.debugLog(`Audio sensitivity set to ${value} (${this.instanceId})`);
-    },
-    /**
-     * Get current sensitivity
-     */
-    getSensitivity: () => {
-      this.validateReady();
-      return this.audioSystem?.getSensitivity() ?? 1;
-    },
     /**
      * Beat control namespace
      */
     beat: {
       /**
-       * Tap tempo - record tap for manual BPM
+       * Get current BPM (auto-detected)
        */
-      tap: () => {
+      getBPM: () => {
         this.validateReady();
-        this.audioSystem?.tapTempo();
-        this.debugLog(`Tap tempo recorded (${this.instanceId})`);
+        return this.audioSystem?.getCurrentBPM() ?? 120;
       },
       /**
-       * Clear tap tempo history
+       * Nudge beat phase
        */
-      clearTaps: () => {
+      nudge: (amount) => {
         this.validateReady();
-        this.audioSystem?.clearTaps();
-        this.debugLog(`Tap tempo cleared (${this.instanceId})`);
+        this.audioSystem?.nudgeBeatPhase(amount);
       },
       /**
-       * Get tap count
+       * Reset beat phase to next beat
        */
-      getTapCount: () => {
+      resetPhase: () => {
         this.validateReady();
-        return this.audioSystem?.getTapCount() ?? 0;
-      },
+        this.audioSystem?.resetBeatPhase();
+        this.debugLog(`Beat phase reset (${this.instanceId})`);
+      }
+    },
+    /**
+     * Per-instrument onset tap control
+     */
+    onset: {
       /**
-       * Set beat sync mode
+       * Tap an onset for a specific instrument.
+       * First tap switches the instrument from auto to tapping mode.
+       * If a repeating pattern is recognized, it continues after tapping stops.
        */
-      setMode: (mode) => {
+      tap: (instrument) => {
         this.validateReady();
-        this.audioSystem?.setBeatMode(mode);
-        this.debugLog(`Beat mode set to ${mode} (${this.instanceId})`);
+        this.audioSystem?.tapOnset(instrument);
       },
       /**
-       * Get beat sync mode
+       * Clear the tap pattern for an instrument, restoring auto-detection
        */
-      getMode: () => {
+      clear: (instrument) => {
         this.validateReady();
-        return this.audioSystem?.getBeatMode() ?? "auto";
+        this.audioSystem?.clearOnsetTap(instrument);
       },
       /**
-       * Set manual BPM
+       * Get onset mode for an instrument: 'auto' | 'tapping' | 'pattern'
        */
-      setBPM: (bpm) => {
+      getMode: (instrument) => {
         this.validateReady();
-        if (bpm < 60 || bpm > 240) {
-          throw new VijiCoreError("BPM must be between 60 and 240", "INVALID_VALUE");
-        }
-        this.audioSystem?.setManualBPM(bpm);
-        this.debugLog(`Manual BPM set to ${bpm} (${this.instanceId})`);
+        return this.audioSystem?.getOnsetMode(instrument) ?? "auto";
       },
       /**
-       * Get current BPM (manual or auto-detected)
+       * Get recognized pattern info for an instrument, or null
        */
-      getBPM: () => {
+      getPatternInfo: (instrument) => {
         this.validateReady();
-        return this.audioSystem?.getCurrentBPM() ?? 120;
+        return this.audioSystem?.getOnsetPatternInfo(instrument) ?? null;
       },
       /**
-       * Nudge beat phase
+       * Mute/unmute an instrument onset.
+       * Suppresses all output (auto, tap, pattern) without destroying state.
+       * Unmuting resumes pattern replay in-phase.
        */
-      nudge: (amount) => {
+      setMuted: (instrument, muted) => {
         this.validateReady();
-        this.audioSystem?.nudgeBeatPhase(amount);
+        this.audioSystem?.setOnsetMuted(instrument, muted);
       },
       /**
-       * Reset beat phase to next beat
+       * Check if an instrument onset is muted
        */
-      resetPhase: () => {
+      isMuted: (instrument) => {
         this.validateReady();
-        this.audioSystem?.resetBeatPhase();
-        this.debugLog(`Beat phase reset (${this.instanceId})`);
+        return this.audioSystem?.isOnsetMuted(instrument) ?? false;
       }
     },
     /**
@@ -15928,17 +15912,6 @@ class VijiCore {
         this.audioSystem?.setFFTSize(size);
         this.debugLog(`FFT size set to ${size} (${this.instanceId})`);
       },
-      /**
-       * Set smoothing time constant (0-1)
-       */
-      setSmoothing: (value) => {
-        this.validateReady();
-        if (value < 0 || value > 1) {
-          throw new VijiCoreError("Smoothing must be between 0 and 1", "INVALID_VALUE");
-        }
-        this.audioSystem?.setSmoothing(value);
-        this.debugLog(`Smoothing set to ${value} (${this.instanceId})`);
-      },
       /**
        * Enable/disable auto-gain
        */
@@ -15948,20 +15921,10 @@ class VijiCore {
         this.debugLog(`Auto-gain ${enabled ? "enabled" : "disabled"} (${this.instanceId})`);
       },
       /**
-       * Enable/disable beat detection
+       * Enable/disable audio analysis debug mode (independent from core debug mode)
        */
-      setBeatDetection: (enabled) => {
-        this.validateReady();
-        this.audioSystem?.setBeatDetection(enabled);
-        this.debugLog(`Beat detection ${enabled ? "enabled" : "disabled"} (${this.instanceId})`);
-      },
-      /**
-       * Enable/disable onset detection
-       */
-      setOnsetDetection: (enabled) => {
-        this.validateReady();
-        this.audioSystem?.setOnsetDetection(enabled);
-        this.debugLog(`Onset detection ${enabled ? "enabled" : "disabled"} (${this.instanceId})`);
+      setDebugMode: (enabled) => {
+        this.audioSystem?.setDebugMode(enabled);
       }
     },
     /**
@@ -15973,10 +15936,9 @@ class VijiCore {
         isConnected: false,
         currentBPM: 120,
         confidence: 0,
-        mode: "auto",
-        tapCount: 0,
         isLocked: false,
-        sensitivity: 1
+        trackingState: "LEARNING",
+        onsetModes: { kick: "auto", snare: "auto", hat: "auto" }
       };
     },
     /**
@@ -16008,15 +15970,14 @@ class VijiCore {
           any: 0,
           kickSmoothed: 0,
           snareSmoothed: 0,
+          hatSmoothed: 0,
           anySmoothed: 0,
           triggers: { any: false, kick: false, snare: false, hat: false },
           bpm: 120,
-          phase: 0,
-          bar: 0,
           confidence: 0,
           isLocked: false
         },
-        spectral: { brightness: 0, flatness: 0, flux: 0 }
+        spectral: { brightness: 0, flatness: 0 }
       };
     }
   };
@@ -16152,9 +16113,8 @@ class VijiCore {
   async setDeviceVideo(deviceId, stream) {
     this.validateReady();
     await this.clearDeviceVideo(deviceId);
-    const baseOffset = 1 + this.videoStreams.length;
     const usedIndices = new Set(this.deviceVideoStreamIndices.values());
-    let streamIndex = baseOffset;
+    let streamIndex = VijiCore.DEVICE_VIDEO_BASE;
     while (usedIndices.has(streamIndex)) {
       streamIndex++;
     }
@@ -16317,4 +16277,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-BKGarA3m.js.map
+//# sourceMappingURL=index-trkn0FNW.js.map