@wvdsh/sdk-js 1.3.19 → 1.3.21

package/dist/index.d.ts

@@ -43,17 +43,24 @@ declare abstract class WavedashManager {
  *     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.
  */
 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;
     constructor(sdk: WavedashSDK);
     isMuted(): boolean;
@@ -78,6 +85,18 @@ declare class AudioManager extends WavedashManager {
      */
     private trackElement;
     private installShims;
+    /**
+     * 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;
     destroy(): void;
 }
@@ -665,16 +684,18 @@ declare class LobbyManager extends WavedashManager {
  * Owns the iframe ↔ parent interactions for the Wavedash overlay UI:
  * - Shift+Tab inside the iframe toggles the overlay on the host page
  *   (the host owns the overlay, so we postMessage up).
- * - When the parent closes the overlay it sends TAKE_FOCUS so keyboard
- *   input goes back to the game; we walk the DOM for a focusable target.
- * - `takeFocus()` is also called after load completes so the game starts
- *   with keyboard focus without the player clicking first.
+ * - When the parent closes the overlay it sends TAKE_FOCUS, which hands
+ *   keyboard focus back to the game (see `takeFocus`).
+ * - While the overlay is open we suspend pointer lock (the host broadcasts
+ *   OVERLAY_CHANGED) so a game can't hold/re-grab the cursor behind it.
  */
 declare class OverlayManager extends WavedashManager {
+    private restorePointerLock;
     constructor(sdk: WavedashSDK);
+    private setOpen;
     toggleOverlay(): void;
-    takeFocus(): void;
     private handleKeyDown;
+    destroy(): void;
 }
 
 /**
@@ -795,9 +816,13 @@ declare class P2PManager extends WavedashManager {
 }
 
 declare class PaidContentManager extends WavedashManager {
+    private paywallOpen;
+    private restorePointerLock;
     isEntitled(contentId: string): Promise<boolean>;
     getEntitlements(): Promise<string[]>;
     triggerPaywall(contentIdentifier: string): Promise<boolean>;
+    isPaywallOpen(): boolean;
+    destroy(): void;
 }
 
 declare class StatsManager extends WavedashManager {

package/dist/index.js

@@ -124,12 +124,16 @@ var AudioManager = class extends WavedashManager {
     // 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;
     this.handleMute = (data) => {
       if (this._isMuted === data.isMuted) return;
@@ -275,6 +279,66 @@ var AudioManager = class extends WavedashManager {
         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).
+   */
+  shimSpeechSynthesis() {
+    if (!window.speechSynthesis || typeof SpeechSynthesisUtterance === "undefined") {
+      return;
+    }
+    this.originalUtteranceVolumeDescriptor = Object.getOwnPropertyDescriptor(
+      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);
+          }
+        });
+      })(this);
+    }
+    const speechSynthesis = window.speechSynthesis;
+    const originalSpeak = speechSynthesis.speak;
+    this.originalSpeak = originalSpeak;
+    ((manager) => {
+      speechSynthesis.speak = function(utterance) {
+        if (manager._isMuted) {
+          if (!manager.intendedUtteranceVolume.has(utterance)) {
+            const current = volDesc?.get ? volDesc.get.call(utterance) : utterance.volume;
+            manager.intendedUtteranceVolume.set(utterance, current);
+          }
+          if (volDesc?.set) volDesc.set.call(utterance, 0);
+          else utterance.volume = 0;
+        } else {
+          const intended = manager.intendedUtteranceVolume.get(utterance);
+          if (intended !== void 0) {
+            if (volDesc?.set) volDesc.set.call(utterance, intended);
+            else utterance.volume = intended;
+            manager.intendedUtteranceVolume.delete(utterance);
+          }
+        }
+        return originalSpeak.call(speechSynthesis, utterance);
+      };
+    })(this);
   }
   shimAudioContextClass(Original) {
     return /* @__PURE__ */ ((manager) => class extends Original {
@@ -320,6 +384,16 @@ var AudioManager = class extends WavedashManager {
       if (this.originalAudio) {
         window.Audio = this.originalAudio;
       }
+      if (this.originalSpeak && window.speechSynthesis) {
+        window.speechSynthesis.speak = this.originalSpeak;
+      }
+    }
+    if (this.originalUtteranceVolumeDescriptor && typeof SpeechSynthesisUtterance !== "undefined") {
+      Object.defineProperty(
+        SpeechSynthesisUtterance.prototype,
+        "volume",
+        this.originalUtteranceVolumeDescriptor
+      );
     }
     if (this.originalPlay) {
       HTMLMediaElement.prototype.play = this.originalPlay;
@@ -334,6 +408,7 @@ var AudioManager = class extends WavedashManager {
     this.contexts.clear();
     this.elements.clear();
     this.intendedMuted = /* @__PURE__ */ new WeakMap();
+    this.intendedUtteranceVolume = /* @__PURE__ */ new WeakMap();
     super.destroy();
   }
 };
@@ -1849,6 +1924,44 @@ var LobbyManager = _LobbyManager;
 
 // src/services/overlay.ts
 import { IFRAME_MESSAGE_TYPE as IFRAME_MESSAGE_TYPE5 } from "@wvdsh/api";
+
+// src/utils/focus.ts
+function takeFocus() {
+  if (typeof document === "undefined") return;
+  const gameFocusTargets = document.getElementsByClassName("game-focus-target");
+  if (gameFocusTargets.length > 0) {
+    gameFocusTargets[0].focus();
+    return;
+  }
+  const focusableElement = document.querySelector(
+    "canvas, input, button, [tabindex]:not([tabindex='-1'])"
+  );
+  focusableElement?.focus();
+}
+
+// src/utils/pointerLock.ts
+var hasDom = typeof Element !== "undefined" && typeof document !== "undefined";
+var nativeRequestPointerLock = hasDom ? Element.prototype.requestPointerLock : void 0;
+var depth = 0;
+function suspendPointerLock() {
+  if (!hasDom || !nativeRequestPointerLock) return () => {
+  };
+  if (++depth === 1) {
+    Element.prototype.requestPointerLock = function() {
+      return Promise.resolve();
+    };
+  }
+  document.exitPointerLock();
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    if (--depth === 0)
+      Element.prototype.requestPointerLock = nativeRequestPointerLock;
+  };
+}
+
+// src/services/overlay.ts
 var OverlayManager = class extends WavedashManager {
   constructor(sdk) {
     super(sdk);
@@ -1860,29 +1973,36 @@ var OverlayManager = class extends WavedashManager {
     };
     this.sdk.iframeMessenger.addEventListener(
       IFRAME_MESSAGE_TYPE5.TAKE_FOCUS,
-      () => this.takeFocus()
+      takeFocus
+    );
+    this.sdk.iframeMessenger.addEventListener(
+      IFRAME_MESSAGE_TYPE5.OVERLAY_CHANGED,
+      ({ isOpen }) => this.setOpen(isOpen)
     );
     if (typeof window !== "undefined") {
       window.addEventListener("keydown", this.handleKeyDown);
     }
   }
+  setOpen(open) {
+    if (open) {
+      this.restorePointerLock ?? (this.restorePointerLock = suspendPointerLock());
+    } else {
+      this.restorePointerLock?.();
+      this.restorePointerLock = void 0;
+    }
+  }
   toggleOverlay() {
     this.sdk.iframeMessenger.postToParent(
       IFRAME_MESSAGE_TYPE5.TOGGLE_OVERLAY,
       {}
     );
   }
-  takeFocus() {
-    if (typeof document === "undefined") return;
-    const gameFocusTargets = document.getElementsByClassName("game-focus-target");
-    if (gameFocusTargets.length > 0) {
-      gameFocusTargets[0].focus();
-      return;
+  destroy() {
+    this.restorePointerLock?.();
+    this.restorePointerLock = void 0;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("keydown", this.handleKeyDown);
     }
-    const focusableElement = document.querySelector(
-      "canvas, input, button, [tabindex]:not([tabindex='-1'])"
-    );
-    focusableElement?.focus();
   }
 };
 
@@ -3204,6 +3324,10 @@ function readEntitlementsFromJwt(jwt) {
   return ents.filter((e) => typeof e === "string");
 }
 var PaidContentManager = class extends WavedashManager {
+  constructor() {
+    super(...arguments);
+    this.paywallOpen = false;
+  }
   async isEntitled(contentId) {
     const jwt = await this.sdk.ensureGameplayJwt();
     return readEntitlementsFromJwt(jwt).includes(contentId);
@@ -3214,15 +3338,34 @@ var PaidContentManager = class extends WavedashManager {
   }
   async triggerPaywall(contentIdentifier) {
     if (await this.isEntitled(contentIdentifier)) return true;
-    const response = await this.sdk.iframeMessenger.requestFromParent(
-      IFRAME_MESSAGE_TYPE6.TRIGGER_PAYWALL,
-      { contentIdentifier },
-      PAYWALL_TIMEOUT_MS
-    );
+    if (this.paywallOpen) {
+      throw new Error("Paywall already in progress");
+    }
+    this.paywallOpen = true;
+    this.restorePointerLock = suspendPointerLock();
+    let response;
+    try {
+      response = await this.sdk.iframeMessenger.requestFromParent(
+        IFRAME_MESSAGE_TYPE6.TRIGGER_PAYWALL,
+        { contentIdentifier },
+        PAYWALL_TIMEOUT_MS
+      );
+    } finally {
+      this.restorePointerLock?.();
+      this.restorePointerLock = void 0;
+      this.paywallOpen = false;
+    }
     if (!response.purchased) return false;
     await this.sdk.ensureGameplayJwt(true);
     return true;
   }
+  isPaywallOpen() {
+    return this.paywallOpen;
+  }
+  destroy() {
+    this.restorePointerLock?.();
+    this.restorePointerLock = void 0;
+  }
 };
 
 // src/services/stats.ts
@@ -4033,7 +4176,6 @@ var WavedashSDK = class extends EventTarget {
     this.gameFinishedLoading = true;
     this.heartbeatManager.start();
     iframeMessenger.postToParent(IFRAME_MESSAGE_TYPE7.LOADING_COMPLETE, {});
-    this.overlayManager.takeFocus();
   }
   get gameLoaded() {
     return this.gameFinishedLoading;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wvdsh/sdk-js",
-  "version": "1.3.19",
+  "version": "1.3.21",
   "type": "module",
   "description": "Wavedash JavaScript SDK",
   "main": "./dist/client.js",
@@ -49,7 +49,7 @@
     "typescript-eslint": "^8.52.0"
   },
   "dependencies": {
-    "@wvdsh/api": "^0.1.34",
+    "@wvdsh/api": "^0.1.36",
     "convex": "^1.39.1",
     "lodash.throttle": "^4.1.1"
   }