@viji-dev/core 0.5.3 → 0.5.5

package/dist/{index-Bhq4eJe_.js → index-DsJxKERc.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-CPrFAj59.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-C58CPq4U.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) {
@@ -6179,9 +6179,31 @@ class OnsetTapManager {
   modeChangeListeners = /* @__PURE__ */ new Set();
   sessionEndListeners = /* @__PURE__ */ new Set();
   muteChangeListeners = /* @__PURE__ */ new Set();
-  tap(instrument) {
+  /**
+   * Record a tap on `instrument`. Drives the visual envelope, advances
+   * `lastTapTime`, flips mode to reflect activity, and (by default) feeds
+   * the pattern-recognition pipeline.
+   *
+   * `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];
     const now = performance.now();
+    const skipRecognition = options?.skipRecognition === true;
     if (s.muted) {
       s.muted = false;
       s.mutedAt = 0;
@@ -6191,18 +6213,26 @@ class OnsetTapManager {
     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();
+      if (!skipRecognition) {
+        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);
     s.sessionActive = true;
     this.scheduleSessionTimers(instrument);
+    if (skipRecognition) {
+      if (s.mode === "auto") {
+        this.setMode(instrument, "tapping");
+      }
+      return;
+    }
     if (s.mode === "auto") {
       this.setMode(instrument, "tapping");
       if (ioi > 0) {
@@ -6302,16 +6332,27 @@ class OnsetTapManager {
   /**
    * Serialize per-instrument onset state for cross-instance transfer.
    * Wall-clock fields are in this instance's `performance.now()` clock space.
+   *
+   * `options.instruments` scopes the output to the listed instruments only;
+   * omitted instruments are absent from the payload (the receiver's
+   * `applyInstrumentPayload` skips missing keys, leaving the receiver's
+   * existing state for those instruments untouched). Default = all three —
+   * the full-state-transfer used for same-process scene-switch.
+   *
+   * Cross-device commits should typically scope to the just-completed
+   * instrument so an unrelated instrument's state on the receiver isn't
+   * inadvertently overwritten.
    */
-  exportSessionState() {
+  exportSessionState(options) {
+    const list = options?.instruments ?? INSTRUMENTS;
+    const instruments = {};
+    for (const inst of list) {
+      instruments[inst] = this.serializeInstrument(inst);
+    }
     return {
       version: STATE_SCHEMA_VERSION,
       senderTime: performance.now(),
-      instruments: {
-        kick: this.serializeInstrument("kick"),
-        snare: this.serializeInstrument("snare"),
-        hat: this.serializeInstrument("hat")
-      }
+      instruments
     };
   }
   /**
@@ -8497,10 +8538,16 @@ class AudioSystem {
   // Public API Methods for Audio Analysis Configuration
   // ═══════════════════════════════════════════════════════════
   /**
-   * Record a tap for the specified instrument onset
+   * Record a tap for the specified instrument onset.
+   * `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) {
-    this.onsetTapManager.tap(instrument);
+  tapOnset(instrument, options) {
+    this.onsetTapManager.tap(instrument, options);
   }
   /**
    * Clear tap pattern for an instrument, restoring auto-detection
@@ -8550,8 +8597,8 @@ class AudioSystem {
   // audio block is for same-process scene-switch transfer (sender's audio
   // analysis state would corrupt receiver's tracking on a different source).
   // ─────────────────────────────────────────────────────────────────────────
-  exportOnsetSessionState() {
-    return this.onsetTapManager.exportSessionState();
+  exportOnsetSessionState(options) {
+    return this.onsetTapManager.exportSessionState(options);
   }
   importOnsetSessionState(state, clockOffset) {
     this.onsetTapManager.importSessionState(state, clockOffset);
@@ -11108,10 +11155,25 @@ class VijiCore {
        * 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.
+       *
+       * `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.
        */
-      tap: (instrument) => {
+      tap: (instrument, options) => {
         this.validateReady();
-        this.audioSystem?.tapOnset(instrument);
+        this.audioSystem?.tapOnset(instrument, options);
       },
       /**
        * Clear the tap pattern for an instrument, restoring auto-detection
@@ -11214,10 +11276,22 @@ class VijiCore {
        * Cross-device-safe (no audio analysis state included). Pair with
        * `importSessionState` on a receiver. Wall-clock fields are in this
        * instance's `performance.now()` clock space.
+       *
+       * `options.instruments` scopes the snapshot to the listed instruments
+       * only; omitted instruments are absent from the payload. The receiver
+       * leaves its existing state for those instruments untouched (the
+       * receiver's `applyInstrumentPayload` skips missing keys). Default =
+       * all three.
+       *
+       * Cross-device commits should typically scope to the just-completed
+       * instrument (e.g. `exportSessionState({ instruments: [ev.instrument] })`
+       * inside an `onSessionEnd` handler) so the receiver's unrelated
+       * instrument state isn't inadvertently overwritten by the sender's
+       * default values.
        */
-      exportSessionState: () => {
+      exportSessionState: (options) => {
         this.validateReady();
-        return this.audioSystem?.exportOnsetSessionState() ?? {
+        return this.audioSystem?.exportOnsetSessionState(options) ?? {
           version: 1,
           senderTime: performance.now(),
           instruments: {}
@@ -11649,7 +11723,7 @@ function validateCoreStatePayload(state) {
   }
   return null;
 }
-const VERSION = "0.5.3";
+const VERSION = "0.5.5";
 export {
   AudioSystem as A,
   VERSION as V,
@@ -11657,4 +11731,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-Bhq4eJe_.js.map
+//# sourceMappingURL=index-DsJxKERc.js.map