@playcademy/sdk 0.1.13 → 0.1.15

package/dist/index.js

@@ -123,9 +123,13 @@ var isBrowser = () => {
     return false;
   const minLevel = getMinimumLogLevel();
   return levelPriority[level] >= levelPriority[minLevel];
-}, performLog = (level, message, context) => {
+}, customHandler, performLog = (level, message, context) => {
   if (!shouldLog(level))
     return;
+  if (customHandler) {
+    customHandler(level, message, context);
+    return;
+  }
   const outputFormat = detectOutputFormat();
   switch (outputFormat) {
     case "browser":
@@ -277,7 +281,356 @@ function isInIframe() {
   }
 }
 
+// src/core/connection/monitor.ts
+class ConnectionMonitor {
+  state = "online";
+  callbacks = new Set;
+  heartbeatInterval;
+  consecutiveFailures = 0;
+  isMonitoring = false;
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      heartbeatInterval: config.heartbeatInterval ?? 1e4,
+      heartbeatTimeout: config.heartbeatTimeout ?? 5000,
+      failureThreshold: config.failureThreshold ?? 2,
+      enableHeartbeat: config.enableHeartbeat ?? true,
+      enableOfflineEvents: config.enableOfflineEvents ?? true
+    };
+    this._detectInitialState();
+  }
+  start() {
+    if (this.isMonitoring)
+      return;
+    this.isMonitoring = true;
+    if (this.config.enableOfflineEvents && typeof window !== "undefined") {
+      window.addEventListener("online", this._handleOnline);
+      window.addEventListener("offline", this._handleOffline);
+    }
+    if (this.config.enableHeartbeat) {
+      this._startHeartbeat();
+    }
+  }
+  stop() {
+    if (!this.isMonitoring)
+      return;
+    this.isMonitoring = false;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this._handleOnline);
+      window.removeEventListener("offline", this._handleOffline);
+    }
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = undefined;
+    }
+  }
+  onChange(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  getState() {
+    return this.state;
+  }
+  async checkNow() {
+    await this._performHeartbeat();
+    return this.state;
+  }
+  reportRequestFailure(error) {
+    const isNetworkError = error instanceof TypeError || error instanceof Error && error.message.includes("fetch");
+    if (!isNetworkError)
+      return;
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= this.config.failureThreshold) {
+      this._setState("degraded", "Multiple consecutive request failures");
+    }
+  }
+  reportRequestSuccess() {
+    if (this.consecutiveFailures > 0) {
+      this.consecutiveFailures = 0;
+      if (this.state === "degraded") {
+        this._setState("online", "Requests succeeding again");
+      }
+    }
+  }
+  _detectInitialState() {
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      this.state = "offline";
+    }
+  }
+  _handleOnline = () => {
+    this.consecutiveFailures = 0;
+    this._setState("online", "Browser online event");
+  };
+  _handleOffline = () => {
+    this._setState("offline", "Browser offline event");
+  };
+  _startHeartbeat() {
+    this._performHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this._performHeartbeat();
+    }, this.config.heartbeatInterval);
+  }
+  async _performHeartbeat() {
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      return;
+    }
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), this.config.heartbeatTimeout);
+      const response = await fetch(`${this.config.baseUrl}/ping`, {
+        method: "GET",
+        signal: controller.signal,
+        cache: "no-store"
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        this.consecutiveFailures = 0;
+        if (this.state !== "online") {
+          this._setState("online", "Heartbeat successful");
+        }
+      } else {
+        this._handleHeartbeatFailure("Heartbeat returned non-OK status");
+      }
+    } catch (error) {
+      this._handleHeartbeatFailure(error instanceof Error ? error.message : "Heartbeat failed");
+    }
+  }
+  _handleHeartbeatFailure(reason) {
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= this.config.failureThreshold) {
+      if (typeof navigator !== "undefined" && !navigator.onLine) {
+        this._setState("offline", reason);
+      } else {
+        this._setState("degraded", reason);
+      }
+    }
+  }
+  _setState(newState, reason) {
+    if (this.state === newState)
+      return;
+    const oldState = this.state;
+    this.state = newState;
+    console.debug(`[ConnectionMonitor] ${oldState} → ${newState}: ${reason}`);
+    this.callbacks.forEach((callback) => {
+      try {
+        callback(newState, reason);
+      } catch (error) {
+        console.error("[ConnectionMonitor] Error in callback:", error);
+      }
+    });
+  }
+}
+
+// src/messaging.ts
+class PlaycademyMessaging {
+  listeners = new Map;
+  send(type, payload, options) {
+    if (options?.target) {
+      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
+      return;
+    }
+    const context = this.getMessagingContext(type);
+    if (context.shouldUsePostMessage) {
+      this.sendViaPostMessage(type, payload, context.target, context.origin);
+    } else {
+      this.sendViaCustomEvent(type, payload);
+    }
+  }
+  listen(type, handler) {
+    const postMessageListener = (event) => {
+      const messageEvent = event;
+      if (messageEvent.data?.type === type) {
+        handler(messageEvent.data.payload || messageEvent.data);
+      }
+    };
+    const customEventListener = (event) => {
+      handler(event.detail);
+    };
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Map);
+    }
+    const listenerMap = this.listeners.get(type);
+    listenerMap.set(handler, {
+      postMessage: postMessageListener,
+      customEvent: customEventListener
+    });
+    window.addEventListener("message", postMessageListener);
+    window.addEventListener(type, customEventListener);
+  }
+  unlisten(type, handler) {
+    const typeListeners = this.listeners.get(type);
+    if (!typeListeners || !typeListeners.has(handler)) {
+      return;
+    }
+    const listeners = typeListeners.get(handler);
+    window.removeEventListener("message", listeners.postMessage);
+    window.removeEventListener(type, listeners.customEvent);
+    typeListeners.delete(handler);
+    if (typeListeners.size === 0) {
+      this.listeners.delete(type);
+    }
+  }
+  getMessagingContext(eventType) {
+    const isIframe = typeof window !== "undefined" && window.self !== window.top;
+    const iframeToParentEvents = [
+      "PLAYCADEMY_READY" /* READY */,
+      "PLAYCADEMY_EXIT" /* EXIT */,
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
+      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */,
+      "PLAYCADEMY_DISPLAY_ALERT" /* DISPLAY_ALERT */
+    ];
+    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    return {
+      shouldUsePostMessage,
+      target: shouldUsePostMessage ? window.parent : undefined,
+      origin: "*"
+    };
+  }
+  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
+    const messageData = { type };
+    if (payload !== undefined) {
+      messageData.payload = payload;
+    }
+    target.postMessage(messageData, origin);
+  }
+  sendViaCustomEvent(type, payload) {
+    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  }
+}
+var MessageEvents, messaging;
+var init_messaging = __esm(() => {
+  ((MessageEvents2) => {
+    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
+    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
+    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
+    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
+    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
+    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
+    MessageEvents2["CONNECTION_STATE"] = "PLAYCADEMY_CONNECTION_STATE";
+    MessageEvents2["READY"] = "PLAYCADEMY_READY";
+    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
+    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
+    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
+    MessageEvents2["DISPLAY_ALERT"] = "PLAYCADEMY_DISPLAY_ALERT";
+    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
+    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
+  })(MessageEvents ||= {});
+  messaging = new PlaycademyMessaging;
+});
+
+// src/core/connection/utils.ts
+function createDisplayAlert(authContext) {
+  return (message, options) => {
+    if (authContext?.isInIframe && typeof window !== "undefined" && window.parent !== window) {
+      window.parent.postMessage({
+        type: "PLAYCADEMY_DISPLAY_ALERT",
+        message,
+        options
+      }, "*");
+    } else {
+      const prefix = options?.type === "error" ? "❌" : options?.type === "warning" ? "⚠️" : "ℹ️";
+      console.log(`${prefix} ${message}`);
+    }
+  };
+}
+
+// src/core/connection/manager.ts
+class ConnectionManager {
+  monitor;
+  authContext;
+  disconnectHandler;
+  connectionChangeCallback;
+  currentState = "online";
+  additionalDisconnectHandlers = new Set;
+  constructor(config) {
+    this.authContext = config.authContext;
+    this.disconnectHandler = config.onDisconnect;
+    this.connectionChangeCallback = config.onConnectionChange;
+    if (config.authContext?.isInIframe) {
+      this._setupPlatformListener();
+    }
+  }
+  getState() {
+    return this.monitor?.getState() ?? this.currentState;
+  }
+  async checkNow() {
+    if (!this.monitor) {
+      return this.currentState;
+    }
+    return await this.monitor.checkNow();
+  }
+  reportRequestSuccess() {
+    this.monitor?.reportRequestSuccess();
+  }
+  reportRequestFailure(error) {
+    this.monitor?.reportRequestFailure(error);
+  }
+  onDisconnect(callback) {
+    this.additionalDisconnectHandlers.add(callback);
+    return () => {
+      this.additionalDisconnectHandlers.delete(callback);
+    };
+  }
+  stop() {
+    this.monitor?.stop();
+  }
+  _setupPlatformListener() {
+    messaging.listen("PLAYCADEMY_CONNECTION_STATE" /* CONNECTION_STATE */, ({ state, reason }) => {
+      this.currentState = state;
+      this._handleConnectionChange(state, reason);
+    });
+  }
+  _handleConnectionChange(state, reason) {
+    this.connectionChangeCallback?.(state, reason);
+    if (state === "offline" || state === "degraded") {
+      const context = {
+        state,
+        reason,
+        timestamp: Date.now(),
+        displayAlert: createDisplayAlert(this.authContext)
+      };
+      if (this.disconnectHandler) {
+        this.disconnectHandler(context);
+      }
+      this.additionalDisconnectHandlers.forEach((handler) => {
+        handler(context);
+      });
+    }
+  }
+}
+var init_manager = __esm(() => {
+  init_messaging();
+});
+
+// src/core/connection/index.ts
+var init_connection = __esm(() => {
+  init_manager();
+});
+
 // src/core/errors.ts
+function extractApiErrorInfo(error) {
+  if (!(error instanceof ApiError)) {
+    return null;
+  }
+  const info = {
+    status: error.status,
+    statusText: error.message
+  };
+  if (error.details && typeof error.details === "object") {
+    const details = error.details;
+    if ("error" in details && typeof details.error === "string") {
+      info.error = details.error;
+    }
+    if ("message" in details && typeof details.message === "string") {
+      info.message = details.message;
+    }
+    if (!info.error && !info.message) {
+      info.details = error.details;
+    }
+  }
+  return info;
+}
 var PlaycademyError, ApiError;
 var init_errors = __esm(() => {
   PlaycademyError = class PlaycademyError extends Error {
@@ -638,100 +991,6 @@ var init_identity = __esm(() => {
   init_login();
 });
 
-// src/messaging.ts
-class PlaycademyMessaging {
-  listeners = new Map;
-  send(type, payload, options) {
-    if (options?.target) {
-      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
-      return;
-    }
-    const context = this.getMessagingContext(type);
-    if (context.shouldUsePostMessage) {
-      this.sendViaPostMessage(type, payload, context.target, context.origin);
-    } else {
-      this.sendViaCustomEvent(type, payload);
-    }
-  }
-  listen(type, handler) {
-    const postMessageListener = (event) => {
-      const messageEvent = event;
-      if (messageEvent.data?.type === type) {
-        handler(messageEvent.data.payload || messageEvent.data);
-      }
-    };
-    const customEventListener = (event) => {
-      handler(event.detail);
-    };
-    if (!this.listeners.has(type)) {
-      this.listeners.set(type, new Map);
-    }
-    const listenerMap = this.listeners.get(type);
-    listenerMap.set(handler, {
-      postMessage: postMessageListener,
-      customEvent: customEventListener
-    });
-    window.addEventListener("message", postMessageListener);
-    window.addEventListener(type, customEventListener);
-  }
-  unlisten(type, handler) {
-    const typeListeners = this.listeners.get(type);
-    if (!typeListeners || !typeListeners.has(handler)) {
-      return;
-    }
-    const listeners = typeListeners.get(handler);
-    window.removeEventListener("message", listeners.postMessage);
-    window.removeEventListener(type, listeners.customEvent);
-    typeListeners.delete(handler);
-    if (typeListeners.size === 0) {
-      this.listeners.delete(type);
-    }
-  }
-  getMessagingContext(eventType) {
-    const isIframe = typeof window !== "undefined" && window.self !== window.top;
-    const iframeToParentEvents = [
-      "PLAYCADEMY_READY" /* READY */,
-      "PLAYCADEMY_EXIT" /* EXIT */,
-      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
-      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */
-    ];
-    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
-    return {
-      shouldUsePostMessage,
-      target: shouldUsePostMessage ? window.parent : undefined,
-      origin: "*"
-    };
-  }
-  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
-    const messageData = { type };
-    if (payload !== undefined) {
-      messageData.payload = payload;
-    }
-    target.postMessage(messageData, origin);
-  }
-  sendViaCustomEvent(type, payload) {
-    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
-  }
-}
-var MessageEvents, messaging;
-var init_messaging = __esm(() => {
-  ((MessageEvents2) => {
-    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
-    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
-    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
-    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
-    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
-    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
-    MessageEvents2["READY"] = "PLAYCADEMY_READY";
-    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
-    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
-    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
-    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
-    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
-  })(MessageEvents ||= {});
-  messaging = new PlaycademyMessaging;
-});
-
 // src/core/namespaces/runtime.ts
 function createRuntimeNamespace(client) {
   const eventListeners = new Map;
@@ -755,7 +1014,7 @@ function createRuntimeNamespace(client) {
     const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
     const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
     const keyListener = (event) => {
-      if (keySet.has(event.key.toLowerCase()) || keySet.has(event.code.toLowerCase())) {
+      if (keySet.has(event.key?.toLowerCase() ?? "") || keySet.has(event.code?.toLowerCase() ?? "")) {
         messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
           key: event.key,
           code: event.code,
@@ -842,7 +1101,7 @@ function createRuntimeNamespace(client) {
     },
     cdn: {
       url(pathOrStrings, ...values) {
-        const cdnBase = client["initPayload"]?.cdnBase;
+        const gameUrl = client["initPayload"]?.gameUrl;
         let path;
         if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
           const strings = pathOrStrings;
@@ -852,20 +1111,20 @@ function createRuntimeNamespace(client) {
         } else {
           path = pathOrStrings;
         }
-        if (!cdnBase) {
+        if (!gameUrl) {
           return path.startsWith("./") ? path : "./" + path;
         }
         const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-        return cdnBase + cleanPath;
+        return gameUrl + cleanPath;
       },
       fetch: async (path, options) => {
-        const cdnBase = client["initPayload"]?.cdnBase;
-        if (!cdnBase) {
+        const gameUrl = client["initPayload"]?.gameUrl;
+        if (!gameUrl) {
           const relativePath = path.startsWith("./") ? path : "./" + path;
           return fetch(relativePath, options);
         }
         const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-        return fetch(cdnBase + cleanPath, options);
+        return fetch(gameUrl + cleanPath, options);
       },
       json: async (path) => {
         const response = await client.runtime.cdn.fetch(path);
@@ -1047,8 +1306,8 @@ async function request({
   const rawText = await res.text().catch(() => "");
   return rawText && rawText.length > 0 ? rawText : undefined;
 }
-async function fetchManifest(assetBundleBase) {
-  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
+async function fetchManifest(deploymentUrl) {
+  const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
   try {
     const response = await fetch(manifestUrl);
     if (!response.ok) {
@@ -1086,8 +1345,8 @@ function createGamesNamespace(client) {
       const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
       return gameFetchCache.get(gameIdOrSlug, async () => {
         const baseGameData = await promise;
-        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null && baseGameData.assetBundleBase !== "") {
-          const manifestData = await fetchManifest(baseGameData.assetBundleBase);
+        if (baseGameData.gameType === "hosted" && baseGameData.deploymentUrl !== null && baseGameData.deploymentUrl !== "") {
+          const manifestData = await fetchManifest(baseGameData.deploymentUrl);
           return { ...baseGameData, manifest: manifestData };
         }
         return baseGameData;
@@ -1276,22 +1535,28 @@ function createDevNamespace(client) {
       }
     },
     games: {
-      deploy: {
-        frontend: async (slug, metadata, file, hooks) => {
-          hooks?.onEvent?.({ type: "init" });
-          const game = await client["request"](`/games/${slug}`, "PUT", {
+      deploy: async (slug, options) => {
+        const { metadata, file, backend, hooks } = options;
+        hooks?.onEvent?.({ type: "init" });
+        let game;
+        if (metadata) {
+          game = await client["request"](`/games/${slug}`, "PUT", {
             body: metadata
           });
-          if (metadata.gameType === "external" || file === null) {
+          if (metadata.gameType === "external" && !file && !backend) {
             return game;
           }
+        }
+        let uploadToken;
+        if (file) {
           const fileName = file instanceof File ? file.name : "game.zip";
           const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
             body: {
               fileName,
-              gameId: game.id
+              gameId: game?.id || slug
             }
           });
+          uploadToken = initiateResponse.uploadToken;
           if (hooks?.onEvent && typeof XMLHttpRequest !== "undefined") {
             await new Promise((resolve, reject) => {
               const xhr = new XMLHttpRequest;
@@ -1332,7 +1597,9 @@ function createDevNamespace(client) {
               throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
             }
           }
-          const finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
+        }
+        if (uploadToken || backend) {
+          const deployUrl = `${client.baseUrl}/games/${slug}/deploy`;
           const authToken = client.getToken();
           const tokenType = client.getTokenType();
           const headers = {
@@ -1345,25 +1612,33 @@ function createDevNamespace(client) {
               headers["Authorization"] = `Bearer ${authToken}`;
             }
           }
-          const finalizeResponse = await fetch(finalizeUrl, {
+          const requestBody = {};
+          if (uploadToken)
+            requestBody.uploadToken = uploadToken;
+          if (metadata)
+            requestBody.metadata = metadata;
+          if (backend) {
+            requestBody.code = backend.code;
+            requestBody.config = backend.config;
+            if (backend.bindings)
+              requestBody.bindings = backend.bindings;
+            if (backend.schema)
+              requestBody.schema = backend.schema;
+            if (backend.secrets)
+              requestBody.secrets = backend.secrets;
+          }
+          const finalizeResponse = await fetch(deployUrl, {
             method: "POST",
             headers,
-            body: JSON.stringify({
-              tempS3Key: initiateResponse.tempS3Key,
-              gameId: initiateResponse.gameId,
-              version: initiateResponse.version,
-              slug,
-              metadata,
-              originalFileName: fileName
-            }),
+            body: JSON.stringify(requestBody),
             credentials: "omit"
           });
           if (!finalizeResponse.ok) {
             const errText = await finalizeResponse.text().catch(() => "");
-            throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
+            throw new Error(`Deploy request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
           }
           if (!finalizeResponse.body) {
-            throw new Error("Finalize response body missing");
+            throw new Error("Deploy response body missing");
           }
           hooks?.onEvent?.({ type: "finalizeStart" });
           let sawAnyServerEvent = false;
@@ -1418,20 +1693,19 @@ function createDevNamespace(client) {
               }
             }
           }
-          throw new Error("Upload completed but no final game data received");
-        },
-        backend: async (slug, bundle) => {
-          return client["request"](`/games/${slug}/backend/deploy`, "POST", { body: bundle });
-        },
-        seed: async (slug, code, environment) => {
-          return client["request"](`/games/${slug}/seed`, "POST", {
-            body: { code, environment }
-          });
+          throw new Error("Deployment completed but no final game data received");
+        }
+        if (game) {
+          return game;
         }
+        throw new Error("No deployment actions specified (need metadata, file, or backend)");
       },
-      upsert: async (slug, metadata) => {
-        return client.dev.games.deploy.frontend(slug, metadata, null);
+      seed: async (slug, code, environment) => {
+        return client["request"](`/games/${slug}/seed`, "POST", {
+          body: { code, environment }
+        });
       },
+      upsert: async (slug, metadata) => client["request"](`/games/${slug}`, "PUT", { body: metadata }),
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE"),
       secrets: {
         set: async (slug, secrets) => {
@@ -1488,6 +1762,24 @@ function createDevNamespace(client) {
         delete: async (slug, key) => {
           await client["request"](`/games/${slug}/bucket/${encodeURIComponent(key)}`, "DELETE");
         }
+      },
+      domains: {
+        add: async (slug, hostname) => {
+          return client["request"](`/games/${slug}/domains`, "POST", {
+            body: { hostname }
+          });
+        },
+        list: async (slug) => {
+          const result = await client["request"](`/games/${slug}/domains`, "GET");
+          return result.domains;
+        },
+        status: async (slug, hostname, refresh) => {
+          const params = refresh ? "?refresh=true" : "";
+          return client["request"](`/games/${slug}/domains/${hostname}${params}`, "GET");
+        },
+        delete: async (slug, hostname) => {
+          await client["request"](`/games/${slug}/domains/${hostname}`, "DELETE");
+        }
       }
     },
     items: {
@@ -2534,10 +2826,10 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
   });
 }
 function createStandaloneConfig() {
-  console.warn("[Playcademy SDK] Standalone mode detected, creating mock context for local development");
+  console.debug("[Playcademy SDK] Standalone mode detected, creating mock context for sandbox development");
   const mockConfig = {
     baseUrl: "http://localhost:4321",
-    gameUrl: "http://localhost:8788",
+    gameUrl: window.location.origin,
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
     realtimeUrl: undefined
@@ -2559,7 +2851,9 @@ async function init(options) {
     gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
-    autoStartSession: window.self !== window.top
+    autoStartSession: window.self !== window.top,
+    onDisconnect: options?.onDisconnect,
+    enableConnectionMonitoring: options?.enableConnectionMonitoring
   });
   client["initPayload"] = config;
   messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
@@ -2628,6 +2922,7 @@ __export(exports_client, {
 var PlaycademyClient;
 var init_client = __esm(() => {
   init_src();
+  init_connection();
   init_errors();
   init_namespaces();
   init_request();
@@ -2642,6 +2937,7 @@ var init_client = __esm(() => {
     internalClientSessionId;
     authContext;
     initPayload;
+    connectionManager;
     constructor(config) {
       this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
       this.gameUrl = config?.gameUrl;
@@ -2650,6 +2946,7 @@ var init_client = __esm(() => {
       this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
       this._detectAuthContext();
       this._initializeInternalSession().catch(() => {});
+      this._initializeConnectionMonitor();
     }
     getBaseUrl() {
       const isRelative = this.baseUrl.startsWith("/");
@@ -2684,6 +2981,20 @@ var init_client = __esm(() => {
     onAuthChange(callback) {
       this.on("authChange", (payload) => callback(payload.token));
     }
+    onDisconnect(callback) {
+      if (!this.connectionManager) {
+        return () => {};
+      }
+      return this.connectionManager.onDisconnect(callback);
+    }
+    getConnectionState() {
+      return this.connectionManager?.getState() ?? "unknown";
+    }
+    async checkConnection() {
+      if (!this.connectionManager)
+        return "unknown";
+      return await this.connectionManager.checkNow();
+    }
     _setAuthContext(context) {
       this.authContext = context;
     }
@@ -2701,28 +3012,42 @@ var init_client = __esm(() => {
         ...options?.headers,
         ...this.authStrategy.getHeaders()
       };
-      return request({
-        path,
-        method,
-        body: options?.body,
-        baseUrl: this.baseUrl,
-        extraHeaders: effectiveHeaders,
-        raw: options?.raw
-      });
+      try {
+        const result = await request({
+          path,
+          method,
+          body: options?.body,
+          baseUrl: this.baseUrl,
+          extraHeaders: effectiveHeaders,
+          raw: options?.raw
+        });
+        this.connectionManager?.reportRequestSuccess();
+        return result;
+      } catch (error) {
+        this.connectionManager?.reportRequestFailure(error);
+        throw error;
+      }
     }
     async requestGameBackend(path, method, body, headers, raw) {
       const effectiveHeaders = {
         ...headers,
         ...this.authStrategy.getHeaders()
       };
-      return request({
-        path,
-        method,
-        body,
-        baseUrl: this.getGameBackendUrl(),
-        extraHeaders: effectiveHeaders,
-        raw
-      });
+      try {
+        const result = await request({
+          path,
+          method,
+          body,
+          baseUrl: this.getGameBackendUrl(),
+          extraHeaders: effectiveHeaders,
+          raw
+        });
+        this.connectionManager?.reportRequestSuccess();
+        return result;
+      } catch (error) {
+        this.connectionManager?.reportRequestFailure(error);
+        throw error;
+      }
     }
     _ensureGameId() {
       if (!this.gameId) {
@@ -2733,6 +3058,25 @@ var init_client = __esm(() => {
     _detectAuthContext() {
       this.authContext = { isInIframe: isInIframe() };
     }
+    _initializeConnectionMonitor() {
+      if (typeof window === "undefined")
+        return;
+      const isEnabled = this.config.enableConnectionMonitoring ?? true;
+      if (!isEnabled)
+        return;
+      try {
+        this.connectionManager = new ConnectionManager({
+          baseUrl: this.baseUrl,
+          authContext: this.authContext,
+          onDisconnect: this.config.onDisconnect,
+          onConnectionChange: (state, reason) => {
+            this.emit("connectionChange", { state, reason });
+          }
+        });
+      } catch (error) {
+        log.error("[Playcademy SDK] Failed to initialize connection manager:", { error });
+      }
+    }
     async _initializeInternalSession() {
       if (!this.gameId || this.internalClientSessionId)
         return;
@@ -2782,9 +3126,16 @@ var init_client = __esm(() => {
 
 // src/index.ts
 init_client();
+init_errors();
+init_connection();
 init_messaging();
 export {
   messaging,
+  extractApiErrorInfo,
+  PlaycademyError,
   PlaycademyClient,
-  MessageEvents
+  MessageEvents,
+  ConnectionMonitor,
+  ConnectionManager,
+  ApiError
 };