@viji-dev/core 0.5.4 → 0.5.6

package/dist/{index-_PbbZgmh.js → index-Yg6_UX8C.js}

@@ -1897,7 +1897,7 @@ class EssentiaOnsetDetection {
     this.initPromise = (async () => {
       try {
         const essentiaModule = await import("./essentia.js-core.es-DnrJE0uR.js");
-        const wasmModule = await import("./essentia-wasm.web-aU6UPupF.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-B2bIxnGE.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) {
@@ -6181,15 +6181,24 @@ class OnsetTapManager {
   muteChangeListeners = /* @__PURE__ */ new Set();
   /**
    * Record a tap on `instrument`. Drives the visual envelope, advances
-   * `lastTapTime`, and (by default) feeds the pattern-recognition pipeline.
+   * `lastTapTime`, flips mode to reflect activity, and (by default) feeds
+   * the pattern-recognition pipeline.
    *
-   * `options.skipRecognition: true` retains the visual side and session-timer
-   * scheduling but bypasses the recognition pipeline (no `tapIOIs` push,
-   * no `tryRecognizePattern`, no `applyPattern`, no `handlePatternTap`).
-   * Mode stays whatever it was. Useful for host-side relay of forwarded
-   * controller-tap messages where another instance is doing the
-   * authoritative recognition. The `MIN_TAP_INTERVAL_MS` debounce still
-   * applies (visual rate-limit).
+   * `options.skipRecognition: true` opts the tap out of the **recognition
+   * pipeline only** — `tapIOIs` accumulation, `tryRecognizePattern`,
+   * `applyPattern`, and `handlePatternTap` are skipped. Mode still flips
+   * `'auto' → 'tapping'` on the first tap of a session (already-`'tapping'`
+   * stays; already-`'pattern'` stays). This is load-bearing: `processFrame`'s
+   * drain of `pendingTapEvents` and its audio-event filter both gate on
+   * mode being non-`'auto'`, and downstream consumers (`onModeChange`
+   * listeners, `broadcastOnsetState`) read mode as the signal that a tap
+   * session is in progress. Suppressing the mode flip would silently break
+   * all of them.
+   *
+   * Used for host-side relay of forwarded tap messages where another
+   * instance owns the authoritative recognition (e.g. host receiving
+   * controller taps over WebRTC). The `MIN_TAP_INTERVAL_MS` debounce still
+   * applies regardless of `skipRecognition`.
    */
   tap(instrument, options) {
     const s = this.state[instrument];
@@ -6218,7 +6227,12 @@ class OnsetTapManager {
     s.pendingTapEvents.push(now);
     s.sessionActive = true;
     this.scheduleSessionTimers(instrument);
-    if (skipRecognition) return;
+    if (skipRecognition) {
+      if (s.mode === "auto") {
+        this.setMode(instrument, "tapping");
+      }
+      return;
+    }
     if (s.mode === "auto") {
       this.setMode(instrument, "tapping");
       if (ioi > 0) {
@@ -7408,6 +7422,7 @@ class AudioChannel {
     if (this.workletNode) {
       try {
         this.workletNode.port.onmessage = null;
+        this.workletNode.port.close();
         this.workletNode.disconnect();
       } catch (_) {
       }
@@ -7457,6 +7472,14 @@ class AudioSystem {
   onsetLogBuffer = [];
   // Debug logging control
   debugMode = false;
+  /**
+   * One-way lifecycle flag flipped at the top of `resetAudioState()`.
+   * Gates re-entry into `ensureAudioContext()` and the public stream-mutation
+   * entry points so an in-flight async caller (e.g. a worker RPC firing
+   * mid-teardown) cannot resurrect a fresh `AudioContext` after destroy
+   * has already nulled the field. AudioSystem is single-use after reset.
+   */
+  destroyed = false;
   // Diagnostic logger
   diagnosticLogger = new DiagnosticLogger();
   // Industry-grade audio analysis modules (4-layer architecture)
@@ -8042,6 +8065,7 @@ class AudioSystem {
    * Handle audio stream update for main stream (called from VijiCore)
    */
   handleAudioStreamUpdate(data) {
+    if (this.destroyed) return;
     try {
       if (data.audioStream) {
         this.setAudioStream(data.audioStream);
@@ -8058,6 +8082,9 @@ class AudioSystem {
    * Ensure the shared AudioContext is created and resumed.
    */
   async ensureAudioContext() {
+    if (this.destroyed) {
+      throw new Error("AudioSystem is destroyed");
+    }
     if (!this.audioContext) {
       this.audioContext = new AudioContext();
     }
@@ -8109,6 +8136,7 @@ class AudioSystem {
             if (ch.workletNode) {
               try {
                 ch.workletNode.port.onmessage = null;
+                ch.workletNode.port.close();
                 ch.workletNode.disconnect();
               } catch {
               }
@@ -8159,6 +8187,7 @@ class AudioSystem {
    * Set the main audio stream for analysis (preserves original public API surface).
    */
   async setAudioStream(audioStream) {
+    if (this.destroyed) return;
     this.disconnectMainStream();
     this.resetEssentiaBandHistories();
     await this.connectChannel(this.mainChannel, audioStream, true);
@@ -8430,8 +8459,14 @@ class AudioSystem {
   /**
    * Reset all audio state (called when destroying).
    * Disconnects all channels, closes AudioContext, resets all modules.
+   *
+   * Returns a Promise that resolves once `AudioContext.close()` has fully
+   * transitioned the context to `closed`. Callers tearing the system down
+   * (e.g. `VijiCore.destroy()`) MUST await this; otherwise Blink keeps the
+   * context alive in `Pending activities` and leaks ~4 MB per cycle.
    */
-  resetAudioState() {
+  async resetAudioState() {
+    this.destroyed = true;
     this.stopAnalysisLoop();
     this.stopStalenessTimer();
     this.stopIdleTicker();
@@ -8444,9 +8479,14 @@ class AudioSystem {
     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;
+    const ctxToClose = this.audioContext;
+    this.audioContext = null;
+    if (ctxToClose && ctxToClose.state !== "closed") {
+      try {
+        await ctxToClose.close();
+      } catch (e) {
+        this.debugLog(`AudioContext.close() rejected: ${e?.message ?? e}`);
+      }
     }
     this.workletRegistered = false;
     this.onsetDetection.reset();
@@ -8468,6 +8508,7 @@ class AudioSystem {
    * @param stream The MediaStream to analyze
    */
   async addStream(streamIndex, stream) {
+    if (this.destroyed) return;
     if (this.additionalChannels.has(streamIndex)) {
       this.removeStream(streamIndex);
     }
@@ -8497,6 +8538,7 @@ class AudioSystem {
    * Mirrors video's reinitializeAdditionalCoordinators pattern.
    */
   async reinitializeAdditionalChannels(streams, baseIndex) {
+    if (this.destroyed) return;
     const toRemove = [];
     for (const [idx, ch] of this.additionalChannels) {
       if (idx >= baseIndex && idx < baseIndex + 100) {
@@ -8525,9 +8567,12 @@ class AudioSystem {
   // ═══════════════════════════════════════════════════════════
   /**
    * Record a tap for the specified instrument onset.
-   * `options.skipRecognition` retains visual envelope + session timing but
-   * bypasses the recognition pipeline — used by host-side relay of forwarded
-   * tap messages where another core is doing the authoritative recognition.
+   * `options.skipRecognition` opts the tap out of the recognition pipeline
+   * only (no IOI accumulation, no `tryRecognizePattern`, no `applyPattern`).
+   * Mode still flips `'auto' → 'tapping'` so the visual envelope and
+   * audio-event filter run; only the pattern-detection pipeline is bypassed.
+   * Used by host-side relay of forwarded tap messages where another core
+   * owns the authoritative recognition.
    */
   tapOnset(instrument, options) {
     this.onsetTapManager.tap(instrument, options);
@@ -8611,6 +8656,7 @@ class AudioSystem {
   // do when audio is active.
   // ─────────────────────────────────────────────────────────────────────────
   startIdleTicker() {
+    if (this.destroyed) return;
     if (this.idleTickerHandle !== null) return;
     if (typeof requestAnimationFrame === "undefined") return;
     this.idleTickerLastTime = performance.now();
@@ -8625,6 +8671,7 @@ class AudioSystem {
   }
   tickIdle(now) {
     this.idleTickerHandle = null;
+    if (this.destroyed) return;
     if (this.mainChannel.audioState.isConnected) return;
     const dtMs = Math.min(100, now - this.idleTickerLastTime);
     this.idleTickerLastTime = now;
@@ -11139,13 +11186,17 @@ class VijiCore {
        * First tap switches the instrument from auto to tapping mode.
        * If a repeating pattern is recognized, it continues after tapping stops.
        *
-       * `options.skipRecognition: true` keeps the visual envelope and session
-       * timing but bypasses pattern recognition entirely (no IOI accumulation,
-       * no mode transition, no `applyPattern`, no `handlePatternTap`). Use
-       * this when relaying tap messages from another instance that owns the
-       * authoritative recognition (e.g. host receiving forwarded controller
-       * taps over WebRTC). The receiving core's mode is then driven only by
-       * `importSessionState` from the authoritative sender.
+       * `options.skipRecognition: true` opts the tap out of the **recognition
+       * pipeline only** — no `tapIOIs` accumulation, no `tryRecognizePattern`,
+       * no `applyPattern`, no `handlePatternTap`. Mode still flips
+       * `'auto' → 'tapping'` on the first tap of a session (and back to
+       * `'auto'` on the 5s timeout). The mode flip is load-bearing for
+       * `processFrame`'s drain of `pendingTapEvents`, the audio-event filter
+       * that prevents music+tap doubling, and `onModeChange` consumers. Use
+       * `skipRecognition` when relaying tap messages from another instance
+       * that owns the authoritative recognition (e.g. host receiving
+       * controller taps over WebRTC); the receiving core's pattern is then
+       * driven only by `importSessionState` from the authoritative sender.
        *
        * The `MIN_TAP_INTERVAL_MS` debounce still applies regardless of the
        * `skipRecognition` flag.
@@ -11609,7 +11660,7 @@ class VijiCore {
     }
     this.deviceAudioStreamIndices.clear();
     if (this.audioSystem) {
-      this.audioSystem.resetAudioState();
+      await this.audioSystem.resetAudioState();
       this.audioSystem = null;
     }
     this.currentAudioStream = null;
@@ -11702,7 +11753,7 @@ function validateCoreStatePayload(state) {
   }
   return null;
 }
-const VERSION = "0.5.4";
+const VERSION = "0.5.6";
 export {
   AudioSystem as A,
   VERSION as V,
@@ -11710,4 +11761,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-_PbbZgmh.js.map
+//# sourceMappingURL=index-Yg6_UX8C.js.map