@smoregg/sdk 1.3.0 → 2.1.0

package/dist/esm/testing.js

@@ -1,39 +1,30 @@
 import { validateEventName } from './events.js';
+import { SmoreSDKError } from './errors.js';
 
 function createMockScreen(options = {}) {
   const {
     roomCode = "TEST",
     controllers: initialControllers = [],
-    autoReady = true,
-    onControllerJoin: onJoinCb,
-    onControllerLeave: onLeaveCb,
-    onControllerDisconnect: onDisconnectCb,
-    onControllerReconnect: onReconnectCb,
-    onCharacterUpdated: onCharacterUpdatedCb,
-    onRateLimited: onRateLimitedCb,
-    onReady: onReadyCb,
-    onError: onErrorCb
+    autoReady = true
   } = options;
   let _controllers = [...initialControllers];
   let _isReady = false;
+  let _isConnected = false;
   let _isDestroyed = false;
   const listeners = /* @__PURE__ */ new Map();
-  let onControllerJoinCallback;
-  let onControllerLeaveCallback;
-  let onControllerDisconnectCallback;
-  let onControllerReconnectCallback;
-  let onCharacterUpdatedCallback;
-  let onRateLimitedCallback;
-  let onReadyCallback;
-  let onErrorCallback;
-  onControllerJoinCallback = onJoinCb;
-  onControllerLeaveCallback = onLeaveCb;
-  onControllerDisconnectCallback = onDisconnectCb;
-  onControllerReconnectCallback = onReconnectCb;
-  onCharacterUpdatedCallback = onCharacterUpdatedCb;
-  onRateLimitedCallback = onRateLimitedCb;
-  onReadyCallback = onReadyCb;
-  onErrorCallback = onErrorCb;
+  const _onAllReadyCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerJoinCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerLeaveCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerDisconnectCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerReconnectCallbacks = /* @__PURE__ */ new Set();
+  const _onCharacterUpdatedCallbacks = /* @__PURE__ */ new Set();
+  const _onErrorCallbacks = /* @__PURE__ */ new Set();
+  const _onConnectionChangeCallbacks = /* @__PURE__ */ new Set();
+  let _allReadyFired = false;
+  let _readyResolve;
+  const _readyPromise = new Promise((resolve) => {
+    _readyResolve = resolve;
+  });
   const broadcasts = [];
   const sends = [];
   const screen = {
@@ -50,75 +41,131 @@ function createMockScreen(options = {}) {
     get isDestroyed() {
       return _isDestroyed;
     },
-    // === Communication Methods ===
-    broadcast(event, data) {
-      if (_isDestroyed) {
-        throw new Error("Cannot broadcast: screen is destroyed");
-      }
-      if (!_isReady) {
-        throw new Error("Cannot broadcast: screen is not ready");
+    get isConnected() {
+      return _isConnected;
+    },
+    get protocolVersion() {
+      return 1;
+    },
+    get ready() {
+      return _readyPromise;
+    },
+    // === Lifecycle Methods ===
+    onAllReady(callback) {
+      if (_allReadyFired) {
+        callback();
       }
-      validateEventName(event);
-      broadcasts.push({ event, data });
+      _onAllReadyCallbacks.add(callback);
+      return () => {
+        _onAllReadyCallbacks.delete(callback);
+      };
+    },
+    onControllerJoin(callback) {
+      _onControllerJoinCallbacks.add(callback);
+      return () => {
+        _onControllerJoinCallbacks.delete(callback);
+      };
+    },
+    onControllerLeave(callback) {
+      _onControllerLeaveCallbacks.add(callback);
+      return () => {
+        _onControllerLeaveCallbacks.delete(callback);
+      };
+    },
+    onControllerDisconnect(callback) {
+      _onControllerDisconnectCallbacks.add(callback);
+      return () => {
+        _onControllerDisconnectCallbacks.delete(callback);
+      };
+    },
+    onControllerReconnect(callback) {
+      _onControllerReconnectCallbacks.add(callback);
+      return () => {
+        _onControllerReconnectCallbacks.delete(callback);
+      };
+    },
+    onCharacterUpdated(callback) {
+      _onCharacterUpdatedCallbacks.add(callback);
+      return () => {
+        _onCharacterUpdatedCallbacks.delete(callback);
+      };
+    },
+    onError(callback) {
+      _onErrorCallbacks.add(callback);
+      return () => {
+        _onErrorCallbacks.delete(callback);
+      };
     },
-    broadcastRaw(event, data) {
+    onConnectionChange(callback) {
+      _onConnectionChangeCallbacks.add(callback);
+      return () => {
+        _onConnectionChangeCallbacks.delete(callback);
+      };
+    },
+    // === Communication Methods ===
+    broadcast(event, data) {
       if (_isDestroyed) {
-        throw new Error("Cannot broadcast: screen is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call broadcast() after destroy()");
       }
       if (!_isReady) {
-        throw new Error("Cannot broadcast: screen is not ready");
+        throw new SmoreSDKError("NOT_READY", "Cannot call broadcast() before screen is ready");
       }
       validateEventName(event);
       broadcasts.push({ event, data });
     },
     sendToController(playerIndex, event, data) {
       if (_isDestroyed) {
-        throw new Error("Cannot send: screen is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call sendToController() after destroy()");
       }
       if (!_isReady) {
-        throw new Error("Cannot send: screen is not ready");
+        throw new SmoreSDKError("NOT_READY", "Cannot call sendToController() before screen is ready");
       }
       validateEventName(event);
       if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
-        throw new Error(`Invalid player index: ${playerIndex}`);
-      }
-      sends.push({ playerIndex, event, data });
-    },
-    sendToControllerRaw(playerIndex, event, data) {
-      if (_isDestroyed) {
-        throw new Error("Cannot send: screen is destroyed");
-      }
-      if (!_isReady) {
-        throw new Error("Cannot send: screen is not ready");
-      }
-      validateEventName(event);
-      if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
-        throw new Error(`Invalid player index: ${playerIndex}`);
+        throw new SmoreSDKError("INVALID_PLAYER", `No controller found with player index ${playerIndex}`);
       }
       sends.push({ playerIndex, event, data });
     },
     // === Game Lifecycle ===
     gameOver(results) {
       if (_isDestroyed) {
-        throw new Error("Cannot call gameOver: screen is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call gameOver() after destroy()");
       }
       if (!_isReady) {
-        throw new Error("Cannot call gameOver: screen is not ready");
+        throw new SmoreSDKError("NOT_READY", "Cannot call gameOver() before screen is ready");
       }
       broadcasts.push({ event: "smore:game-over", data: { results } });
     },
     signalReady() {
       if (_isDestroyed) {
-        throw new Error("Cannot call signalReady: screen is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call signalReady() after destroy()");
       }
       if (!_isReady) {
-        throw new Error("Cannot call signalReady: screen is not ready");
+        throw new SmoreSDKError("NOT_READY", "Cannot call signalReady() before screen is ready");
       }
     },
     // === Event Subscription ===
     on(event, handler) {
-      validateEventName(event);
       const eventStr = event;
+      if (eventStr.startsWith("$")) {
+        switch (eventStr) {
+          case "$controller-join":
+            return screen.onControllerJoin(handler);
+          case "$controller-leave":
+            return screen.onControllerLeave(handler);
+          case "$controller-disconnect":
+            return screen.onControllerDisconnect(handler);
+          case "$controller-reconnect":
+            return screen.onControllerReconnect(handler);
+          case "$character-updated":
+            return screen.onCharacterUpdated(handler);
+          case "$all-ready":
+            return screen.onAllReady(handler);
+          case "$error":
+            return screen.onError(handler);
+        }
+      }
+      validateEventName(event);
       if (!listeners.has(eventStr)) {
         listeners.set(eventStr, /* @__PURE__ */ new Set());
       }
@@ -144,6 +191,13 @@ function createMockScreen(options = {}) {
         listeners.get(eventStr)?.delete(handler);
       }
     },
+    removeAllListeners(event) {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    },
     // === Utilities ===
     getController(playerIndex) {
       return _controllers.find((c) => c.playerIndex === playerIndex);
@@ -151,9 +205,6 @@ function createMockScreen(options = {}) {
     getControllerCount() {
       return _controllers.filter((c) => c.connected).length;
     },
-    hasAnyConnectedControllers() {
-      return _controllers.some((c) => c.connected);
-    },
     // === Cleanup ===
     /**
      * Note: destroy() clears recorded broadcast/event arrays. Call getBroadcasts() before destroy() if assertions are needed.
@@ -177,86 +228,59 @@ function createMockScreen(options = {}) {
     },
     simulateControllerJoin(info) {
       _controllers.push(info);
-      if (onControllerJoinCallback) {
-        onControllerJoinCallback(info.playerIndex, info);
-      }
+      _onControllerJoinCallbacks.forEach((cb) => cb(info.playerIndex, info));
     },
     simulateControllerLeave(playerIndex) {
       _controllers = _controllers.filter((c) => c.playerIndex !== playerIndex);
-      if (onControllerLeaveCallback) {
-        onControllerLeaveCallback(playerIndex);
-      }
+      _onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
     },
     /**
      * Simulate a controller network disconnect (player still in room but unreachable).
-     *
-     * @example
-     * ```ts
-     * screen.simulateControllerDisconnect(0);
-     * expect(screen.getController(0)?.connected).toBe(false);
-     * ```
      */
     simulateControllerDisconnect(playerIndex) {
       const controller = _controllers.find((c) => c.playerIndex === playerIndex);
       if (!controller) {
-        throw new Error(`Controller ${playerIndex} not found`);
+        throw new SmoreSDKError("INVALID_PLAYER", `Controller ${playerIndex} not found`);
       }
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
       );
-      if (onControllerDisconnectCallback) {
-        onControllerDisconnectCallback(playerIndex);
-      }
+      _onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
     },
     /**
      * Simulate a controller network reconnect after disconnect.
-     *
-     * @example
-     * ```ts
-     * screen.simulateControllerDisconnect(0);
-     * screen.simulateControllerReconnect(0);
-     * expect(screen.getController(0)?.connected).toBe(true);
-     * ```
      */
     simulateControllerReconnect(playerIndex) {
       const controller = _controllers.find((c) => c.playerIndex === playerIndex);
       if (!controller) {
-        throw new Error(`Controller ${playerIndex} not found`);
+        throw new SmoreSDKError("INVALID_PLAYER", `Controller ${playerIndex} not found`);
       }
       const reconnectedController = { ...controller, connected: true };
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? reconnectedController : c
       );
-      if (onControllerReconnectCallback) {
-        onControllerReconnectCallback(playerIndex, reconnectedController);
-      }
+      _onControllerReconnectCallbacks.forEach((cb) => cb(playerIndex, reconnectedController));
     },
     simulateCharacterUpdate(playerIndex, appearance) {
       const controller = _controllers.find((c) => c.playerIndex === playerIndex);
       if (!controller) {
-        throw new Error(`Controller ${playerIndex} not found`);
+        throw new SmoreSDKError("INVALID_PLAYER", `Controller ${playerIndex} not found`);
       }
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? { ...c, appearance } : c
       );
-      if (onCharacterUpdatedCallback) {
-        onCharacterUpdatedCallback(playerIndex, appearance);
-      }
-    },
-    simulateRateLimited(event) {
-      if (onRateLimitedCallback) {
-        onRateLimitedCallback(event);
-      }
+      _onCharacterUpdatedCallbacks.forEach((cb) => cb(playerIndex, appearance));
     },
     simulateAllReady() {
-      if (onReadyCallback) {
-        onReadyCallback();
-      }
+      _allReadyFired = true;
+      _onAllReadyCallbacks.forEach((cb) => cb());
     },
     simulateError(error) {
-      if (onErrorCallback) {
-        onErrorCallback(error);
-      }
+      _onErrorCallbacks.forEach((cb) => cb(error));
+    },
+    simulateConnectionChange(connected) {
+      _isConnected = connected;
+      _onConnectionChangeCallbacks.forEach((cb) => cb(connected));
     },
     getBroadcasts() {
       return [...broadcasts];
@@ -270,6 +294,8 @@ function createMockScreen(options = {}) {
     },
     triggerReady() {
       _isReady = true;
+      _isConnected = true;
+      _readyResolve();
     }
   };
   if (autoReady) {
@@ -280,42 +306,33 @@ function createMockScreen(options = {}) {
 function createMockController(options = {}) {
   const {
     roomCode = "TEST",
-    myIndex = 0,
-    autoReady = true,
-    onControllerJoin: onJoinCb,
-    onControllerLeave: onLeaveCb,
-    onControllerDisconnect: onDisconnectCb,
-    onControllerReconnect: onReconnectCb,
-    onCharacterUpdated: onCharacterUpdatedCb,
-    onRateLimited: onRateLimitedCb,
-    onReady: onReadyCb,
-    onError: onErrorCb
+    myPlayerIndex = 0,
+    autoReady = true
   } = options;
   let _isReady = false;
+  let _isConnected = false;
   let _isDestroyed = false;
   let _controllers = options.controllers ?? [];
   const listeners = /* @__PURE__ */ new Map();
-  let onControllerJoinCallback;
-  let onControllerLeaveCallback;
-  let onControllerDisconnectCallback;
-  let onControllerReconnectCallback;
-  let onCharacterUpdatedCallback;
-  let onRateLimitedCallback;
-  let onReadyCallback;
-  let onErrorCallback;
-  onControllerJoinCallback = onJoinCb;
-  onControllerLeaveCallback = onLeaveCb;
-  onControllerDisconnectCallback = onDisconnectCb;
-  onControllerReconnectCallback = onReconnectCb;
-  onCharacterUpdatedCallback = onCharacterUpdatedCb;
-  onRateLimitedCallback = onRateLimitedCb;
-  onReadyCallback = onReadyCb;
-  onErrorCallback = onErrorCb;
+  const _onAllReadyCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerJoinCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerLeaveCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerDisconnectCallbacks = /* @__PURE__ */ new Set();
+  const _onControllerReconnectCallbacks = /* @__PURE__ */ new Set();
+  const _onCharacterUpdatedCallbacks = /* @__PURE__ */ new Set();
+  const _onErrorCallbacks = /* @__PURE__ */ new Set();
+  const _onGameOverCallbacks = /* @__PURE__ */ new Set();
+  const _onConnectionChangeCallbacks = /* @__PURE__ */ new Set();
+  let _allReadyFired = false;
+  let _readyResolve;
+  const _readyPromise = new Promise((resolve) => {
+    _readyResolve = resolve;
+  });
   const sentEvents = [];
   const controller = {
     // === Properties ===
-    get myIndex() {
-      return myIndex;
+    get myPlayerIndex() {
+      return myPlayerIndex;
     },
     get roomCode() {
       return roomCode;
@@ -326,39 +343,122 @@ function createMockController(options = {}) {
     get isDestroyed() {
       return _isDestroyed;
     },
+    get isConnected() {
+      return _isConnected;
+    },
+    get protocolVersion() {
+      return 1;
+    },
     get controllers() {
       return [..._controllers];
     },
+    get ready() {
+      return _readyPromise;
+    },
+    // === Lifecycle Methods ===
+    onAllReady(callback) {
+      if (_allReadyFired) {
+        callback();
+      }
+      _onAllReadyCallbacks.add(callback);
+      return () => {
+        _onAllReadyCallbacks.delete(callback);
+      };
+    },
+    onControllerJoin(callback) {
+      _onControllerJoinCallbacks.add(callback);
+      return () => {
+        _onControllerJoinCallbacks.delete(callback);
+      };
+    },
+    onControllerLeave(callback) {
+      _onControllerLeaveCallbacks.add(callback);
+      return () => {
+        _onControllerLeaveCallbacks.delete(callback);
+      };
+    },
+    onControllerDisconnect(callback) {
+      _onControllerDisconnectCallbacks.add(callback);
+      return () => {
+        _onControllerDisconnectCallbacks.delete(callback);
+      };
+    },
+    onControllerReconnect(callback) {
+      _onControllerReconnectCallbacks.add(callback);
+      return () => {
+        _onControllerReconnectCallbacks.delete(callback);
+      };
+    },
+    onCharacterUpdated(callback) {
+      _onCharacterUpdatedCallbacks.add(callback);
+      return () => {
+        _onCharacterUpdatedCallbacks.delete(callback);
+      };
+    },
+    onError(callback) {
+      _onErrorCallbacks.add(callback);
+      return () => {
+        _onErrorCallbacks.delete(callback);
+      };
+    },
+    onConnectionChange(callback) {
+      _onConnectionChangeCallbacks.add(callback);
+      return () => {
+        _onConnectionChangeCallbacks.delete(callback);
+      };
+    },
+    onGameOver(callback) {
+      _onGameOverCallbacks.add(callback);
+      return () => {
+        _onGameOverCallbacks.delete(callback);
+      };
+    },
     getControllerCount() {
       return _controllers.filter((c) => c.connected).length;
     },
+    getController(playerIndex) {
+      return _controllers.find((c) => c.playerIndex === playerIndex);
+    },
     // === Communication Methods ===
     send(event, data) {
       if (_isDestroyed) {
-        throw new Error("Cannot send: controller is destroyed");
-      }
-      validateEventName(event);
-      sentEvents.push({ event, data });
-    },
-    sendRaw(event, data) {
-      if (_isDestroyed) {
-        throw new Error("Cannot send: controller is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call send() after destroy()");
       }
       validateEventName(event);
       sentEvents.push({ event, data });
     },
     signalReady() {
       if (_isDestroyed) {
-        throw new Error("Cannot call signalReady: controller is destroyed");
+        throw new SmoreSDKError("DESTROYED", "Cannot call signalReady() after destroy()");
       }
       if (!_isReady) {
-        throw new Error("Cannot call signalReady: controller is not ready");
+        throw new SmoreSDKError("NOT_READY", "Cannot call signalReady() before controller is ready");
       }
     },
     // === Event Subscription ===
     on(event, handler) {
-      validateEventName(event);
       const eventStr = event;
+      if (eventStr.startsWith("$")) {
+        switch (eventStr) {
+          case "$controller-join":
+            return controller.onControllerJoin(handler);
+          case "$controller-leave":
+            return controller.onControllerLeave(handler);
+          case "$controller-disconnect":
+            return controller.onControllerDisconnect(handler);
+          case "$controller-reconnect":
+            return controller.onControllerReconnect(handler);
+          case "$character-updated":
+            return controller.onCharacterUpdated(handler);
+          case "$all-ready":
+            return controller.onAllReady(handler);
+          case "$error":
+            return controller.onError(handler);
+          case "$game-over":
+            return controller.onGameOver(handler);
+        }
+      }
+      validateEventName(event);
       if (!listeners.has(eventStr)) {
         listeners.set(eventStr, /* @__PURE__ */ new Set());
       }
@@ -384,6 +484,13 @@ function createMockController(options = {}) {
         listeners.get(eventStr)?.delete(handler);
       }
     },
+    removeAllListeners(event) {
+      if (event) {
+        listeners.delete(event);
+      } else {
+        listeners.clear();
+      }
+    },
     // === Cleanup ===
     destroy() {
       _isDestroyed = true;
@@ -409,102 +516,67 @@ function createMockController(options = {}) {
     },
     triggerReady() {
       _isReady = true;
+      _isConnected = true;
+      _readyResolve();
     },
     /**
      * Simulate a new player joining the room.
      * Stores full ControllerInfo (nickname, appearance, etc.) for later retrieval.
-     *
-     * @example
-     * ```ts
-     * controller.simulatePlayerJoin(2, { playerIndex: 2, nickname: 'Alice', connected: true });
-     * expect(controller.getControllerCount()).toBe(3);
-     * expect(controller.controllers.find(c => c.playerIndex === 2)?.nickname).toBe('Alice');
-     * ```
      */
     simulatePlayerJoin(playerIndex, info) {
       if (!_controllers.some((c) => c.playerIndex === playerIndex)) {
         _controllers = [..._controllers, { ...info, connected: info.connected ?? true }];
       }
-      if (onControllerJoinCallback) {
-        onControllerJoinCallback(playerIndex, info);
-      }
+      _onControllerJoinCallbacks.forEach((cb) => cb(playerIndex, info));
     },
     /**
      * Simulate a player leaving the room (fully removed).
-     *
-     * @example
-     * ```ts
-     * controller.simulatePlayerLeave(1);
-     * expect(controller.controllers.some(c => c.playerIndex === 1)).toBe(false);
-     * ```
      */
     simulatePlayerLeave(playerIndex) {
       _controllers = _controllers.filter((c) => c.playerIndex !== playerIndex);
-      if (onControllerLeaveCallback) {
-        onControllerLeaveCallback(playerIndex);
-      }
+      _onControllerLeaveCallbacks.forEach((cb) => cb(playerIndex));
     },
     /**
      * Simulate a player network disconnect (player still in room but unreachable).
-     *
-     * @example
-     * ```ts
-     * controller.simulatePlayerDisconnect(1);
-     * expect(controller.controllers.find(c => c.playerIndex === 1)?.connected).toBe(false);
-     * ```
      */
     simulatePlayerDisconnect(playerIndex) {
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? { ...c, connected: false } : c
       );
-      if (onControllerDisconnectCallback) {
-        onControllerDisconnectCallback(playerIndex);
-      }
+      _onControllerDisconnectCallbacks.forEach((cb) => cb(playerIndex));
     },
     /**
      * Simulate a player network reconnect after disconnect.
-     *
-     * @example
-     * ```ts
-     * controller.simulatePlayerDisconnect(1);
-     * controller.simulatePlayerReconnect(1, { playerIndex: 1, nickname: 'Bob', connected: true });
-     * expect(controller.controllers.find(c => c.playerIndex === 1)?.connected).toBe(true);
-     * ```
      */
     simulatePlayerReconnect(playerIndex, info) {
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? { ...info, connected: true } : c
       );
-      if (onControllerReconnectCallback) {
-        onControllerReconnectCallback(playerIndex, info);
-      }
+      _onControllerReconnectCallbacks.forEach((cb) => cb(playerIndex, info));
     },
     simulateCharacterUpdate(playerIndex, appearance) {
-      const controller2 = _controllers.find((c) => c.playerIndex === playerIndex);
-      if (!controller2) {
-        throw new Error(`Controller ${playerIndex} not found`);
+      const ctrl = _controllers.find((c) => c.playerIndex === playerIndex);
+      if (!ctrl) {
+        throw new SmoreSDKError("INVALID_PLAYER", `Controller ${playerIndex} not found`);
       }
       _controllers = _controllers.map(
         (c) => c.playerIndex === playerIndex ? { ...c, appearance } : c
       );
-      if (onCharacterUpdatedCallback) {
-        onCharacterUpdatedCallback(playerIndex, appearance);
-      }
-    },
-    simulateRateLimited(event) {
-      if (onRateLimitedCallback) {
-        onRateLimitedCallback(event);
-      }
+      _onCharacterUpdatedCallbacks.forEach((cb) => cb(playerIndex, appearance));
     },
     simulateAllReady() {
-      if (onReadyCallback) {
-        onReadyCallback();
-      }
+      _allReadyFired = true;
+      _onAllReadyCallbacks.forEach((cb) => cb());
     },
     simulateError(error) {
-      if (onErrorCallback) {
-        onErrorCallback(error);
-      }
+      _onErrorCallbacks.forEach((cb) => cb(error));
+    },
+    simulateGameOver(results) {
+      _onGameOverCallbacks.forEach((cb) => cb(results));
+    },
+    simulateConnectionChange(connected) {
+      _isConnected = connected;
+      _onConnectionChangeCallbacks.forEach((cb) => cb(connected));
     }
   };
   if (autoReady) {