@wvdsh/sdk-js 1.3.25 → 1.3.27

package/dist/index.js

@@ -94,69 +94,30 @@ var WavedashManager = class {
 };
 
 // src/services/audio.ts
-var WeakRefSet = class {
-  constructor() {
-    this.set = /* @__PURE__ */ new Set();
-  }
-  add(value) {
-    for (const ref of this.set) {
-      if (ref.deref() === value) return;
-    }
-    this.set.add(new WeakRef(value));
-  }
-  forEach(callback) {
-    for (const ref of this.set) {
-      const v = ref.deref();
-      if (v === void 0) this.set.delete(ref);
-      else callback(v);
-    }
-  }
-  clear() {
-    this.set.clear();
-  }
-};
 var AudioManager = class extends WavedashManager {
   constructor(sdk) {
     super(sdk);
     this._isMuted = false;
-    // Web Audio contexts and their master gain nodes
-    this.contexts = /* @__PURE__ */ new Map();
-    // HTML media elements we know about + their game-intended muted state
-    this.elements = new WeakRefSet();
-    this.intendedMuted = /* @__PURE__ */ new WeakMap();
-    // Speech synthesis utterances + their game-intended volume
-    this.intendedUtteranceVolume = /* @__PURE__ */ new WeakMap();
-    // Originals (restored on destroy)
-    this.originalAudioContext = null;
-    this.originalWebKitAudioContext = null;
-    this.originalAudio = null;
-    this.originalMutedDescriptor = null;
-    this.originalPlay = null;
-    this.originalSpeak = null;
-    this.originalUtteranceVolumeDescriptor = null;
-    this.mutationObserver = null;
+    // One shim per frame we've attached to.
+    this.frames = /* @__PURE__ */ new Set();
+    // Per-iframe state so we can re-shim across navigations/swaps and tear down
+    // the right frame when an iframe is removed or re-navigates. Keyed on the
+    // Document (replaced on every navigation), not contentWindow (a stable
+    // WindowProxy that survives navigations and so can't reveal a realm change).
+    this.iframeBindings = /* @__PURE__ */ new WeakMap();
+    this.iframeLoadHandlers = /* @__PURE__ */ new Map();
+    this.boundIframes = /* @__PURE__ */ new Set();
     this.handleMute = (data) => {
       if (this._isMuted === data.isMuted) return;
       this._isMuted = data.isMuted;
-      const target = this._isMuted ? 0 : 1;
-      this.contexts.forEach((gain, ctx) => {
-        const now = ctx.currentTime;
-        gain.gain.cancelScheduledValues(now);
-        gain.gain.setValueAtTime(gain.gain.value, now);
-        gain.gain.linearRampToValueAtTime(target, now + 0.05);
-      });
-      const setMutedNative = this.originalMutedDescriptor?.set;
-      if (setMutedNative) {
-        this.elements.forEach((el) => {
-          const intended = this.intendedMuted.get(el) ?? false;
-          setMutedNative.call(el, this._isMuted ? true : intended);
-        });
-      }
+      this.frames.forEach((shim) => shim.applyMute(this._isMuted));
       this.sdk.gameEventManager.notifyGame(WavedashEvents.MUTE_CHANGED, {
         isMuted: this._isMuted
       });
     };
-    this.installShims();
+    if (typeof window !== "undefined") {
+      this.attachWindow(window);
+    }
     this.sdk.iframeMessenger.addEventListener(
       IFRAME_MESSAGE_TYPE.MUTE_CHANGED,
       this.handleMute
@@ -190,10 +151,148 @@ var AudioManager = class extends WavedashManager {
     );
     return response.success;
   }
+  /** Shim a window we can reach. Same-origin only (cross-origin access throws). */
+  attachWindow(win) {
+    try {
+      void win.document;
+    } catch {
+      return;
+    }
+    const shim = new AudioFrameShim(this, win);
+    this.frames.add(shim);
+  }
+  /**
+   * Start tracking an iframe: attach now (already-loaded frames) and on every
+   * `load` (about:blank → game, and later src swaps). Idempotent.
+   */
+  bindIframe(iframe) {
+    if (!this.boundIframes.has(iframe)) {
+      this.boundIframes.add(iframe);
+      const onLoad = () => this.attachIframe(iframe);
+      this.iframeLoadHandlers.set(iframe, onLoad);
+      iframe.addEventListener("load", onLoad);
+    }
+    this.attachIframe(iframe);
+  }
+  /** Stop tracking an iframe and tear down its frame (iframe removed from DOM). */
+  unbindIframe(iframe) {
+    const handler = this.iframeLoadHandlers.get(iframe);
+    if (handler) {
+      iframe.removeEventListener("load", handler);
+      this.iframeLoadHandlers.delete(iframe);
+    }
+    this.boundIframes.delete(iframe);
+    this.teardownFrame(iframe);
+  }
   /**
-   * Track a media element and (if SDK is currently muted) silence it.
-   * Idempotent — safe to call multiple times for the same element.
+   * Install (or re-install) a shim for an iframe's current document. No-ops
+   * while not yet navigated or already shimmed; replaces the previous shim when
+   * the iframe navigates to a fresh document, and drops it when it goes
+   * cross-origin (we can no longer reach it).
    */
+  attachIframe(iframe) {
+    let win = null;
+    let doc = null;
+    try {
+      const cw = iframe.contentWindow;
+      if (cw) {
+        doc = cw.document;
+        win = cw;
+      }
+    } catch {
+    }
+    if (!win || !doc) {
+      this.teardownFrame(iframe);
+      return;
+    }
+    const existing = this.iframeBindings.get(iframe);
+    if (existing) {
+      if (existing.doc === doc) return;
+      this.teardownFrame(iframe);
+    }
+    const shim = new AudioFrameShim(this, win);
+    this.frames.add(shim);
+    this.iframeBindings.set(iframe, { doc, shim });
+    if (this._isMuted) shim.applyMute(true);
+  }
+  /** Remove and uninstall the shim bound to an iframe's (previous) document. */
+  teardownFrame(iframe) {
+    const binding = this.iframeBindings.get(iframe);
+    if (!binding) return;
+    this.frames.delete(binding.shim);
+    binding.shim.uninstall();
+    this.iframeBindings.delete(iframe);
+  }
+  destroy() {
+    this.sdk.iframeMessenger.removeEventListener(
+      IFRAME_MESSAGE_TYPE.MUTE_CHANGED,
+      this.handleMute
+    );
+    this.boundIframes.forEach((iframe) => {
+      const handler = this.iframeLoadHandlers.get(iframe);
+      if (handler) iframe.removeEventListener("load", handler);
+    });
+    this.boundIframes.clear();
+    this.iframeLoadHandlers.clear();
+    this.frames.forEach((shim) => shim.uninstall());
+    this.frames.clear();
+    super.destroy();
+  }
+};
+var AudioFrameShim = class {
+  constructor(manager, win) {
+    this.contexts = /* @__PURE__ */ new Map();
+    // Tracked media elements + the game's intended muted value (what it last set).
+    this.elements = new WeakRefSet();
+    this.intendedMuted = /* @__PURE__ */ new WeakMap();
+    // Utterances + the game's intended volume.
+    this.intendedUtteranceVolume = /* @__PURE__ */ new WeakMap();
+    // Child iframes discovered in this frame's document. Tracked so we can
+    // cascade-unbind them when this frame is torn down — their own removal events
+    // never fire when the containing document is discarded wholesale.
+    this.boundChildren = /* @__PURE__ */ new Set();
+    // Originals, restored on uninstall.
+    this.originalAudioContext = null;
+    this.originalWebKitAudioContext = null;
+    this.originalAudio = null;
+    this.originalMutedDescriptor = null;
+    this.originalPlay = null;
+    this.originalSpeak = null;
+    this.originalUtteranceVolumeDescriptor = null;
+    this.mutationObserver = null;
+    this.manager = manager;
+    this.win = win;
+    this.doc = win.document ?? null;
+    this.installShims();
+  }
+  /** Push the current mute state onto everything this frame is tracking. */
+  applyMute(isMuted) {
+    const target = isMuted ? 0 : 1;
+    this.contexts.forEach((gain, ctx) => {
+      const now = ctx.currentTime;
+      gain.gain.cancelScheduledValues(now);
+      gain.gain.setValueAtTime(gain.gain.value, now);
+      gain.gain.linearRampToValueAtTime(target, now + 0.05);
+    });
+    const setMutedNative = this.originalMutedDescriptor?.set;
+    if (setMutedNative) {
+      this.elements.forEach((el) => {
+        const intended = this.intendedMuted.get(el) ?? false;
+        setMutedNative.call(el, isMuted ? true : intended);
+      });
+    }
+  }
+  /** Hand a discovered child iframe to the manager, remembering it for teardown. */
+  bindChild(iframe) {
+    this.boundChildren.add(iframe);
+    this.manager.bindIframe(iframe);
+  }
+  /** Stop tracking a child iframe that was removed from this document. */
+  unbindChild(iframe) {
+    this.boundChildren.delete(iframe);
+    this.manager.unbindIframe(iframe);
+  }
+  /** Track a media element and silence it if currently muted. Idempotent. */
   trackElement(el) {
     if (this.intendedMuted.has(el)) return;
     const getMuted = this.originalMutedDescriptor?.get;
@@ -201,139 +300,161 @@ var AudioManager = class extends WavedashManager {
     const current = getMuted ? getMuted.call(el) : el.muted;
     this.intendedMuted.set(el, current);
     this.elements.add(el);
-    if (this._isMuted && !current && setMuted) {
+    if (this.manager.isMuted() && !current && setMuted) {
       setMuted.call(el, true);
     }
   }
   installShims() {
-    if (typeof window === "undefined") return;
-    if (window.AudioContext) {
-      this.originalAudioContext = window.AudioContext;
-      window.AudioContext = this.shimAudioContextClass(window.AudioContext);
-    }
-    const win = window;
-    if (win.webkitAudioContext) {
-      this.originalWebKitAudioContext = win.webkitAudioContext;
-      win.webkitAudioContext = this.shimAudioContextClass(
-        win.webkitAudioContext
-      );
-    }
-    if (window.Audio) {
-      const OriginalAudio = window.Audio;
+    const win = this.win;
+    const doc = this.doc;
+    if (win.AudioContext) {
+      this.originalAudioContext = win.AudioContext;
+      win.AudioContext = this.shimAudioContextClass(win.AudioContext);
+    }
+    const w = win;
+    if (w.webkitAudioContext) {
+      this.originalWebKitAudioContext = w.webkitAudioContext;
+      w.webkitAudioContext = this.shimAudioContextClass(w.webkitAudioContext);
+    }
+    if (win.Audio) {
+      const OriginalAudio = win.Audio;
       this.originalAudio = OriginalAudio;
-      ((manager) => {
+      ((shim) => {
         const Shimmed = function(src) {
           const audio = new OriginalAudio(src);
-          manager.trackElement(audio);
+          shim.trackElement(audio);
           return audio;
         };
         Shimmed.prototype = OriginalAudio.prototype;
-        window.Audio = Shimmed;
+        win.Audio = Shimmed;
       })(this);
     }
-    if (typeof document !== "undefined") {
-      document.querySelectorAll("audio, video").forEach((el) => {
+    if (doc) {
+      const HTMLMediaElementCtor = win.HTMLMediaElement;
+      const HTMLIFrameElementCtor = win.HTMLIFrameElement;
+      const HTMLElementCtor = win.HTMLElement;
+      doc.querySelectorAll("audio, video").forEach((el) => {
         this.trackElement(el);
       });
-      this.mutationObserver = new MutationObserver((mutations) => {
+      doc.querySelectorAll("iframe").forEach((el) => {
+        this.bindChild(el);
+      });
+      this.mutationObserver = new win.MutationObserver((mutations) => {
         for (const m of mutations) {
           m.addedNodes.forEach((node) => {
-            if (node instanceof HTMLMediaElement) {
+            if (node instanceof HTMLMediaElementCtor) {
               this.trackElement(node);
-            } else if (node instanceof HTMLElement) {
-              node.querySelectorAll("audio, video").forEach((el) => {
-                this.trackElement(el);
+            } else if (node instanceof HTMLIFrameElementCtor) {
+              this.bindChild(node);
+            } else if (node instanceof HTMLElementCtor) {
+              const el = node;
+              el.querySelectorAll("audio, video").forEach((m2) => {
+                this.trackElement(m2);
+              });
+              el.querySelectorAll("iframe").forEach((f) => {
+                this.bindChild(f);
+              });
+            }
+          });
+          m.removedNodes.forEach((node) => {
+            if (node instanceof HTMLIFrameElementCtor) {
+              this.unbindChild(node);
+            } else if (node instanceof HTMLElementCtor) {
+              node.querySelectorAll("iframe").forEach((f) => {
+                this.unbindChild(f);
               });
             }
           });
         }
       });
-      this.mutationObserver.observe(document.documentElement, {
+      this.mutationObserver.observe(doc.documentElement, {
         childList: true,
         subtree: true
       });
     }
-    this.originalMutedDescriptor = Object.getOwnPropertyDescriptor(HTMLMediaElement.prototype, "muted") ?? null;
+    this.originalMutedDescriptor = Object.getOwnPropertyDescriptor(
+      win.HTMLMediaElement.prototype,
+      "muted"
+    ) ?? null;
     const original = this.originalMutedDescriptor;
     if (original?.get && original?.set) {
-      ((manager) => {
-        Object.defineProperty(HTMLMediaElement.prototype, "muted", {
+      ((shim) => {
+        Object.defineProperty(win.HTMLMediaElement.prototype, "muted", {
           configurable: true,
           get() {
-            const intended = manager.intendedMuted.get(this);
+            const intended = shim.intendedMuted.get(this);
             return intended !== void 0 ? intended : original.get.call(this);
           },
           set(value) {
-            manager.intendedMuted.set(this, value);
-            manager.elements.add(this);
-            original.set.call(this, manager._isMuted ? true : value);
+            shim.intendedMuted.set(this, value);
+            shim.elements.add(this);
+            original.set.call(this, shim.manager.isMuted() ? true : value);
           }
         });
       })(this);
     }
-    const originalPlay = HTMLMediaElement.prototype.play;
+    const originalPlay = win.HTMLMediaElement.prototype.play;
     this.originalPlay = originalPlay;
-    ((manager) => {
-      HTMLMediaElement.prototype.play = function() {
-        manager.trackElement(this);
+    ((shim) => {
+      win.HTMLMediaElement.prototype.play = function() {
+        shim.trackElement(this);
         return originalPlay.call(this);
       };
     })(this);
     this.shimSpeechSynthesis();
   }
   /**
-   * Shim `window.speechSynthesis` so speech respects the SDK mute state.
-   *
-   * Never swallows speak(): utterances have a lifecycle the game may sequence
-   * off (onstart/onend, synth.speaking/pending checks), so every call is
-   * delegated and silenced via volume instead. Volume is sampled at speak()
-   * time, so forcing the native value to 0 right before delegating silences
-   * anything spoken while muted; in-flight speech at the mute edge is
-   * deliberately left to finish (can't be softened mid-utterance, and
-   * cancel() would discard the pending queue).
+   * Shim `speechSynthesis`. We never swallow `speak()` (games sequence off its
+   * lifecycle) — instead we sample volume at call time and force it to 0 while
+   * muted. Speech already in flight at the mute edge is left to finish.
    */
   shimSpeechSynthesis() {
-    if (!window.speechSynthesis || typeof SpeechSynthesisUtterance === "undefined") {
+    const win = this.win;
+    if (!win.speechSynthesis || typeof win.SpeechSynthesisUtterance === "undefined") {
       return;
     }
     this.originalUtteranceVolumeDescriptor = Object.getOwnPropertyDescriptor(
-      SpeechSynthesisUtterance.prototype,
+      win.SpeechSynthesisUtterance.prototype,
       "volume"
     ) ?? null;
     const volDesc = this.originalUtteranceVolumeDescriptor;
     if (volDesc?.get && volDesc?.set) {
-      ((manager) => {
-        Object.defineProperty(SpeechSynthesisUtterance.prototype, "volume", {
-          configurable: true,
-          get() {
-            const intended = manager.intendedUtteranceVolume.get(this);
-            return intended !== void 0 ? intended : volDesc.get.call(this);
-          },
-          set(value) {
-            manager.intendedUtteranceVolume.set(this, value);
-            volDesc.set.call(this, value);
+      ((shim) => {
+        Object.defineProperty(
+          win.SpeechSynthesisUtterance.prototype,
+          "volume",
+          {
+            configurable: true,
+            get() {
+              const intended = shim.intendedUtteranceVolume.get(this);
+              return intended !== void 0 ? intended : volDesc.get.call(this);
+            },
+            set(value) {
+              shim.intendedUtteranceVolume.set(this, value);
+              volDesc.set.call(this, value);
+            }
           }
-        });
+        );
       })(this);
     }
-    const speechSynthesis = window.speechSynthesis;
+    const speechSynthesis = win.speechSynthesis;
     const originalSpeak = speechSynthesis.speak;
     this.originalSpeak = originalSpeak;
-    ((manager) => {
+    ((shim) => {
       speechSynthesis.speak = function(utterance) {
-        if (manager._isMuted) {
-          if (!manager.intendedUtteranceVolume.has(utterance)) {
+        if (shim.manager.isMuted()) {
+          if (!shim.intendedUtteranceVolume.has(utterance)) {
             const current = volDesc?.get ? volDesc.get.call(utterance) : utterance.volume;
-            manager.intendedUtteranceVolume.set(utterance, current);
+            shim.intendedUtteranceVolume.set(utterance, current);
           }
           if (volDesc?.set) volDesc.set.call(utterance, 0);
           else utterance.volume = 0;
         } else {
-          const intended = manager.intendedUtteranceVolume.get(utterance);
+          const intended = shim.intendedUtteranceVolume.get(utterance);
           if (intended !== void 0) {
             if (volDesc?.set) volDesc.set.call(utterance, intended);
             else utterance.volume = intended;
-            manager.intendedUtteranceVolume.delete(utterance);
+            shim.intendedUtteranceVolume.delete(utterance);
           }
         }
         return originalSpeak.call(speechSynthesis, utterance);
@@ -341,13 +462,13 @@ var AudioManager = class extends WavedashManager {
     })(this);
   }
   shimAudioContextClass(Original) {
-    return /* @__PURE__ */ ((manager) => class extends Original {
+    return /* @__PURE__ */ ((shim) => class extends Original {
       constructor(opts) {
         super(opts);
         const masterGain = this.createGain();
         masterGain.connect(this.destination);
         masterGain.gain.setValueAtTime(
-          manager._isMuted ? 0 : 1,
+          shim.manager.isMuted() ? 0 : 1,
           this.currentTime
         );
         Object.defineProperty(this, "destination", {
@@ -356,60 +477,101 @@ var AudioManager = class extends WavedashManager {
             return masterGain;
           }
         });
-        manager.contexts.set(this, masterGain);
+        shim.contexts.set(this, masterGain);
       }
       close() {
-        manager.contexts.delete(this);
+        shim.contexts.delete(this);
         return super.close();
       }
     })(this);
   }
-  destroy() {
-    this.sdk.iframeMessenger.removeEventListener(
-      IFRAME_MESSAGE_TYPE.MUTE_CHANGED,
-      this.handleMute
-    );
-    if (this.mutationObserver) {
-      this.mutationObserver.disconnect();
-      this.mutationObserver = null;
+  /**
+   * Restore the globals we patched. Best-effort per statement: a frame reached
+   * through an iframe may have navigated away (globals gone) before teardown.
+   */
+  uninstall() {
+    const win = this.win;
+    try {
+      if (this.mutationObserver) {
+        this.mutationObserver.disconnect();
+        this.mutationObserver = null;
+      }
+    } catch {
     }
-    if (typeof window !== "undefined") {
-      if (this.originalAudioContext) {
-        window.AudioContext = this.originalAudioContext;
+    this.boundChildren.forEach((child) => this.manager.unbindIframe(child));
+    this.boundChildren.clear();
+    const restore = (fn) => {
+      try {
+        fn();
+      } catch {
+      }
+    };
+    restore(() => {
+      if (this.originalAudioContext)
+        win.AudioContext = this.originalAudioContext;
+    });
+    restore(() => {
+      const w = win;
+      if (this.originalWebKitAudioContext && w.webkitAudioContext) {
+        w.webkitAudioContext = this.originalWebKitAudioContext;
       }
-      const win = window;
-      if (this.originalWebKitAudioContext && win.webkitAudioContext) {
-        win.webkitAudioContext = this.originalWebKitAudioContext;
+    });
+    restore(() => {
+      if (this.originalAudio) win.Audio = this.originalAudio;
+    });
+    restore(() => {
+      if (this.originalSpeak && win.speechSynthesis) {
+        win.speechSynthesis.speak = this.originalSpeak;
       }
-      if (this.originalAudio) {
-        window.Audio = this.originalAudio;
+    });
+    restore(() => {
+      if (this.originalUtteranceVolumeDescriptor && typeof win.SpeechSynthesisUtterance !== "undefined") {
+        Object.defineProperty(
+          win.SpeechSynthesisUtterance.prototype,
+          "volume",
+          this.originalUtteranceVolumeDescriptor
+        );
       }
-      if (this.originalSpeak && window.speechSynthesis) {
-        window.speechSynthesis.speak = this.originalSpeak;
+    });
+    restore(() => {
+      if (this.originalPlay) {
+        win.HTMLMediaElement.prototype.play = this.originalPlay;
       }
-    }
-    if (this.originalUtteranceVolumeDescriptor && typeof SpeechSynthesisUtterance !== "undefined") {
-      Object.defineProperty(
-        SpeechSynthesisUtterance.prototype,
-        "volume",
-        this.originalUtteranceVolumeDescriptor
-      );
-    }
-    if (this.originalPlay) {
-      HTMLMediaElement.prototype.play = this.originalPlay;
-    }
-    if (this.originalMutedDescriptor) {
-      Object.defineProperty(
-        HTMLMediaElement.prototype,
-        "muted",
-        this.originalMutedDescriptor
-      );
-    }
+    });
+    restore(() => {
+      if (this.originalMutedDescriptor) {
+        Object.defineProperty(
+          win.HTMLMediaElement.prototype,
+          "muted",
+          this.originalMutedDescriptor
+        );
+      }
+    });
     this.contexts.clear();
     this.elements.clear();
     this.intendedMuted = /* @__PURE__ */ new WeakMap();
     this.intendedUtteranceVolume = /* @__PURE__ */ new WeakMap();
-    super.destroy();
+  }
+};
+var WeakRefSet = class {
+  constructor() {
+    this.set = /* @__PURE__ */ new Set();
+  }
+  add(value) {
+    for (const ref of this.set) {
+      if (ref.deref() === value) return;
+    }
+    this.set.add(new WeakRef(value));
+  }
+  forEach(callback) {
+    for (const ref of this.set) {
+      const v = ref.deref();
+      if (v === void 0) this.set.delete(ref);
+      else callback(v);
+    }
+  }
+  clear() {
+    this.set.clear();
   }
 };
 
@@ -3328,9 +3490,9 @@ var PaidContentManager = class extends WavedashManager {
     super(...arguments);
     this.paywallOpen = false;
   }
-  async isEntitled(contentId) {
+  async isEntitled(contentIdentifier) {
     const jwt = await this.sdk.ensureGameplayJwt();
-    return readEntitlementsFromJwt(jwt).includes(contentId);
+    return readEntitlementsFromJwt(jwt).includes(contentIdentifier);
   }
   async getEntitlements() {
     const jwt = await this.sdk.ensureGameplayJwt();
@@ -4954,23 +5116,23 @@ var WavedashSDK = class extends EventTarget {
    * doesn't actually unlock anything. Pair with triggerPaywall() to drive
    * in-game UI.
    */
-  async isEntitled(contentId) {
+  async isEntitled(contentIdentifier) {
     return this.apiCall(
       this.paidContentManager,
       "isEntitled",
-      [["contentId", vString]],
-      contentId
+      [["contentIdentifier", vString]],
+      contentIdentifier
     );
   }
   // Kept for backwards compatibility
-  async isEntitled_EXPERIMENTAL(contentId) {
-    return this.isEntitled(contentId);
+  async isEntitled_EXPERIMENTAL(contentIdentifier) {
+    return this.isEntitled(contentIdentifier);
   }
   /**
-   * Returns the full list of paid-content IDs the player owns for this game.
+   * Returns the full list of paid-content identifiers the player owns for this game.
    * Reads the `entitlements` claim from the gameplay JWT — this is a UX hint,
    * not a security check (see {@link isEntitled}). Useful
-   * for access gating multiple items at once without a call per content ID.
+   * for access gating multiple items at once without a call per content identifier.
    */
   async getEntitlements() {
     return this.apiCall(this.paidContentManager, "getEntitlements", []);