@wvdsh/sdk-js 1.3.25 → 1.3.27

package/dist/index.d.ts

@@ -21,47 +21,21 @@ declare abstract class WavedashManager {
 }
 
 /**
- * AudioManager
+ * Mutes & unmutes the game in response to MUTE_CHANGED iframe messages, with no
+ * game-side code required.
  *
- * Mutes & unmutes the game in response to MUTE_CHANGED iframe messages, without
- * the game needing to handle it itself.
+ * Globals like `AudioContext` are per-frame, so we shim the SDK's own window
+ * (where the game usually runs) plus any same-origin iframes the game adds.
  *
- * Web Audio: subclass `AudioContext` so `ctx.destination` resolves to a master
- * GainNode that we control. The master gain wires to the real native destination,
- * so `node.connect(ctx.destination)` and any other game code is unaffected.
- *
- * HTML Media (`<audio>`/`<video>`): override `HTMLMediaElement.prototype.muted`
- * to record the game's intended state, but write `true` to the underlying element
- * whenever the SDK is muted. Tracked elements come from four sources:
- *  1. Pre-existing DOM media (`querySelectorAll`)
- *  2. `new Audio()` constructor shim (covers detached SFX)
- *  3. MutationObserver for any media added to the DOM later (covers innerHTML,
- *     framework rendering, createElement + append, etc.)
- *  4. `HTMLMediaElement.prototype.play()` shim — the universal point where an
- *     element starts producing audio. Catches anything driven purely via
- *     `.play()`/`.volume` (never assigning `.muted`, never entering the DOM,
- *     e.g. a PIXI/GDevelop intro video), force-muting it before playback begins
- *     regardless of how it was created — the one path the DOM-based sources and
- *     the `muted` setter all miss.
- *
- * Speech synthesis (`window.speechSynthesis`): bypasses both Web Audio and HTML
- * media entirely, so it gets its own shim — `speak()` forces the utterance's
- * native volume to 0 while muted.
+ * Each frame's shimming lives in {@link AudioFrameShim}; this class owns the
+ * mute state and fans it out to every attached frame.
  */
 declare class AudioManager extends WavedashManager {
     private _isMuted;
-    private contexts;
-    private elements;
-    private intendedMuted;
-    private intendedUtteranceVolume;
-    private originalAudioContext;
-    private originalWebKitAudioContext;
-    private originalAudio;
-    private originalMutedDescriptor;
-    private originalPlay;
-    private originalSpeak;
-    private originalUtteranceVolumeDescriptor;
-    private mutationObserver;
+    private frames;
+    private iframeBindings;
+    private iframeLoadHandlers;
+    private boundIframes;
     constructor(sdk: WavedashSDK);
     isMuted(): boolean;
     /**
@@ -79,25 +53,24 @@ declare class AudioManager extends WavedashManager {
      */
     toggleMute(): Promise<boolean>;
     private handleMute;
+    /** Shim a window we can reach. Same-origin only (cross-origin access throws). */
+    private attachWindow;
     /**
-     * Track a media element and (if SDK is currently muted) silence it.
-     * Idempotent — safe to call multiple times for the same element.
+     * Start tracking an iframe: attach now (already-loaded frames) and on every
+     * `load` (about:blank → game, and later src swaps). Idempotent.
      */
-    private trackElement;
-    private installShims;
+    bindIframe(iframe: HTMLIFrameElement): void;
+    /** Stop tracking an iframe and tear down its frame (iframe removed from DOM). */
+    unbindIframe(iframe: HTMLIFrameElement): void;
     /**
-     * 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).
-     */
-    private shimSpeechSynthesis;
-    private shimAudioContextClass;
+     * 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).
+     */
+    private attachIframe;
+    /** Remove and uninstall the shim bound to an iframe's (previous) document. */
+    private teardownFrame;
     destroy(): void;
 }
 
@@ -818,7 +791,7 @@ declare class P2PManager extends WavedashManager {
 declare class PaidContentManager extends WavedashManager {
     private paywallOpen;
     private restorePointerLock;
-    isEntitled(contentId: string): Promise<boolean>;
+    isEntitled(contentIdentifier: string): Promise<boolean>;
     getEntitlements(): Promise<string[]>;
     triggerPaywall(contentIdentifier: string): Promise<boolean>;
     isPaywallOpen(): boolean;
@@ -1307,13 +1280,13 @@ declare class WavedashSDK extends EventTarget {
      * doesn't actually unlock anything. Pair with triggerPaywall() to drive
      * in-game UI.
      */
-    isEntitled(contentId: string): Promise<WavedashResponse<boolean>>;
-    isEntitled_EXPERIMENTAL(contentId: string): Promise<WavedashResponse<boolean>>;
+    isEntitled(contentIdentifier: string): Promise<WavedashResponse<boolean>>;
+    isEntitled_EXPERIMENTAL(contentIdentifier: string): Promise<WavedashResponse<boolean>>;
     /**
-     * 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.
      */
     getEntitlements(): Promise<WavedashResponse<string[]>>;
     getEntitlements_EXPERIMENTAL(): Promise<WavedashResponse<string[]>>;