@playcademy/sdk 0.1.18 → 0.2.1

package/dist/internal.js

@@ -0,0 +1,3006 @@
+// src/namespaces/platform/auth.ts
+function createAuthNamespace(client) {
+  return {
+    login: async (credentials) => {
+      try {
+        const response = await client["request"]("/auth/sign-in/email", "POST", { body: credentials });
+        client.setToken(response.token, "session");
+        return {
+          success: true,
+          token: response.token,
+          user: response.user,
+          expiresAt: response.expiresAt
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Authentication failed"
+        };
+      }
+    },
+    logout: async () => {
+      try {
+        await client["request"]("/auth/sign-out", "POST");
+      } catch {}
+      client.setToken(null);
+    },
+    apiKeys: {
+      create: async (options) => {
+        return client["request"]("/dev/api-keys", "POST", {
+          body: {
+            name: options?.name || `SDK Key - ${new Date().toISOString()}`,
+            expiresIn: options?.expiresIn !== undefined ? options.expiresIn : null,
+            permissions: options?.permissions || {
+              games: ["read", "write", "delete"],
+              users: ["read:self", "write:self"],
+              dev: ["read", "write"]
+            }
+          }
+        });
+      },
+      list: async () => {
+        return client["request"]("/auth/api-key/list", "GET");
+      },
+      revoke: async (keyId) => {
+        await client["request"]("/auth/api-key/revoke", "POST", {
+          body: { id: keyId }
+        });
+      }
+    }
+  };
+}
+// src/namespaces/platform/admin.ts
+function createAdminNamespace(client) {
+  return {
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
+    },
+    items: {
+      create: (props) => client["request"]("/items", "POST", { body: props }),
+      get: (itemId) => client["request"](`/items/${itemId}`, "GET"),
+      list: () => client["request"]("/items", "GET"),
+      update: (itemId, props) => client["request"](`/items/${itemId}`, "PATCH", { body: props }),
+      delete: (itemId) => client["request"](`/items/${itemId}`, "DELETE")
+    },
+    currencies: {
+      create: (props) => client["request"]("/currencies", "POST", { body: props }),
+      get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
+      list: () => client["request"]("/currencies", "GET"),
+      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", { body: props }),
+      delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
+    },
+    shopListings: {
+      create: (props) => client["request"]("/shop-listings", "POST", { body: props }),
+      get: (listingId) => client["request"](`/shop-listings/${listingId}`, "GET"),
+      list: () => client["request"]("/shop-listings", "GET"),
+      update: (listingId, props) => client["request"](`/shop-listings/${listingId}`, "PATCH", {
+        body: props
+      }),
+      delete: (listingId) => client["request"](`/shop-listings/${listingId}`, "DELETE")
+    }
+  };
+}
+// src/namespaces/platform/dev.ts
+function createDevNamespace(client) {
+  return {
+    status: {
+      apply: () => client["request"]("/dev/apply", "POST"),
+      get: async () => {
+        const response = await client["request"]("/dev/status", "GET");
+        return response.status;
+      }
+    },
+    games: {
+      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 && !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 || slug
+            }
+          });
+          uploadToken = initiateResponse.uploadToken;
+          if (hooks?.onEvent && typeof XMLHttpRequest !== "undefined") {
+            await new Promise((resolve, reject) => {
+              const xhr = new XMLHttpRequest;
+              xhr.open("PUT", initiateResponse.presignedUrl, true);
+              const contentType = file.type || "application/octet-stream";
+              try {
+                xhr.setRequestHeader("Content-Type", contentType);
+              } catch {}
+              xhr.upload.onprogress = (event) => {
+                if (event.lengthComputable) {
+                  const percent = event.loaded / event.total;
+                  hooks.onEvent?.({
+                    type: "s3Progress",
+                    loaded: event.loaded,
+                    total: event.total,
+                    percent
+                  });
+                }
+              };
+              xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300)
+                  resolve();
+                else
+                  reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
+              };
+              xhr.onerror = () => reject(new Error("File upload failed: network error"));
+              xhr.send(file);
+            });
+          } else {
+            const uploadResponse = await fetch(initiateResponse.presignedUrl, {
+              method: "PUT",
+              body: file,
+              headers: {
+                "Content-Type": file.type || "application/octet-stream"
+              }
+            });
+            if (!uploadResponse.ok) {
+              throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+            }
+          }
+        }
+        if (uploadToken || backend) {
+          const deployUrl = `${client.baseUrl}/games/${slug}/deploy`;
+          const authToken = client.getToken();
+          const tokenType = client.getTokenType();
+          const headers = {
+            "Content-Type": "application/json"
+          };
+          if (authToken) {
+            if (tokenType === "apiKey") {
+              headers["x-api-key"] = authToken;
+            } else {
+              headers["Authorization"] = `Bearer ${authToken}`;
+            }
+          }
+          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(requestBody),
+            credentials: "omit"
+          });
+          if (!finalizeResponse.ok) {
+            const errText = await finalizeResponse.text().catch(() => "");
+            throw new Error(`Deploy request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
+          }
+          if (!finalizeResponse.body) {
+            throw new Error("Deploy response body missing");
+          }
+          hooks?.onEvent?.({ type: "finalizeStart" });
+          let sawAnyServerEvent = false;
+          const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (!sawAnyServerEvent) {
+                hooks?.onClose?.();
+                hooks?.onEvent?.({ type: "close" });
+              }
+              break;
+            }
+            buffer += value;
+            let eolIndex;
+            while ((eolIndex = buffer.indexOf(`
+
+`)) >= 0) {
+              const message = buffer.slice(0, eolIndex);
+              buffer = buffer.slice(eolIndex + 2);
+              const eventLine = message.match(/^event: (.*)$/m);
+              const dataLine = message.match(/^data: (.*)$/m);
+              if (eventLine && dataLine) {
+                const eventType = eventLine[1];
+                const eventData = JSON.parse(dataLine[1]);
+                sawAnyServerEvent = true;
+                switch (eventType) {
+                  case "uploadProgress": {
+                    const percent = (eventData.value ?? 0) / 100;
+                    hooks?.onEvent?.({
+                      type: "finalizeProgress",
+                      percent,
+                      currentFileLabel: eventData.currentFileLabel || ""
+                    });
+                    break;
+                  }
+                  case "status": {
+                    if (eventData.message) {
+                      hooks?.onEvent?.({
+                        type: "finalizeStatus",
+                        message: eventData.message
+                      });
+                    }
+                    break;
+                  }
+                  case "complete": {
+                    reader.cancel();
+                    return eventData;
+                  }
+                  case "error": {
+                    reader.cancel();
+                    const status = typeof eventData.status === "number" ? eventData.status : 500;
+                    const message2 = eventData.message ?? "Deployment error";
+                    const details = eventData.details;
+                    throw new ApiError(status, message2, details);
+                  }
+                }
+              }
+            }
+          }
+          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)");
+      },
+      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) => {
+          const result = await client["request"](`/games/${slug}/secrets`, "POST", { body: secrets });
+          return result.keys;
+        },
+        list: async (slug) => {
+          const result = await client["request"](`/games/${slug}/secrets`, "GET");
+          return result.keys;
+        },
+        get: async (slug) => {
+          const result = await client["request"](`/games/${slug}/secrets/values`, "GET");
+          return result.secrets;
+        },
+        delete: async (slug, key) => {
+          await client["request"](`/games/${slug}/secrets/${key}`, "DELETE");
+        }
+      },
+      database: {
+        reset: async (slug, schema) => {
+          return client["request"](`/games/${slug}/database/reset`, "POST", {
+            body: { schema }
+          });
+        }
+      },
+      bucket: {
+        list: async (slug, prefix) => {
+          const params = prefix ? `?prefix=${encodeURIComponent(prefix)}` : "";
+          const result = await client["request"](`/games/${slug}/bucket${params}`, "GET");
+          return result.files;
+        },
+        get: async (slug, key) => {
+          const res = await client["request"](`/games/${slug}/bucket/${encodeURIComponent(key)}`, "GET", { raw: true });
+          if (!res.ok) {
+            let errorMessage = res.statusText;
+            try {
+              const errorData = await res.json();
+              if (errorData.error) {
+                errorMessage = errorData.error;
+              } else if (errorData.message) {
+                errorMessage = errorData.message;
+              }
+            } catch {}
+            throw new Error(errorMessage);
+          }
+          return res.arrayBuffer();
+        },
+        put: async (slug, key, content, contentType) => {
+          await client["request"](`/games/${slug}/bucket/${encodeURIComponent(key)}`, "PUT", {
+            body: content,
+            headers: contentType ? { "Content-Type": contentType } : undefined
+          });
+        },
+        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: {
+      create: (gameId, slug, itemData) => client["request"](`/games/${gameId}/items`, "POST", {
+        body: {
+          slug,
+          ...itemData
+        }
+      }),
+      update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}`, "PATCH", {
+        body: updates
+      }),
+      list: (gameId) => client["request"](`/games/${gameId}/items`, "GET"),
+      get: (gameId, slug) => {
+        const queryParams = new URLSearchParams({ slug, gameId });
+        return client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      },
+      delete: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}`, "DELETE"),
+      shop: {
+        create: (gameId, itemId, listingData) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "POST", { body: listingData });
+        },
+        get: (gameId, itemId) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "GET");
+        },
+        update: (gameId, itemId, updates) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "PATCH", { body: updates });
+        },
+        delete: (gameId, itemId) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "DELETE");
+        },
+        list: (gameId) => {
+          return client["request"](`/games/${gameId}/shop-listings`, "GET");
+        }
+      }
+    }
+  };
+}
+// src/core/cache/ttl-cache.ts
+function createTTLCache(options) {
+  const cache = new Map;
+  const { ttl: defaultTTL, keyPrefix = "", onClear } = options;
+  async function get(key, loader, config) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const now = Date.now();
+    const effectiveTTL = config?.ttl !== undefined ? config.ttl : defaultTTL;
+    const force = config?.force || false;
+    const skipCache = config?.skipCache || false;
+    if (effectiveTTL === 0 || skipCache) {
+      return loader();
+    }
+    if (!force) {
+      const cached = cache.get(fullKey);
+      if (cached && cached.expiresAt > now) {
+        return cached.value;
+      }
+    }
+    const promise = loader().catch((error) => {
+      cache.delete(fullKey);
+      throw error;
+    });
+    cache.set(fullKey, {
+      value: promise,
+      expiresAt: now + effectiveTTL
+    });
+    return promise;
+  }
+  function clear(key) {
+    if (key === undefined) {
+      cache.clear();
+      onClear?.();
+    } else {
+      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+      cache.delete(fullKey);
+    }
+  }
+  function size() {
+    return cache.size;
+  }
+  function prune() {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (entry.expiresAt <= now) {
+        cache.delete(key);
+      }
+    }
+  }
+  function getKeys() {
+    const keys = [];
+    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
+    for (const fullKey of cache.keys()) {
+      keys.push(fullKey.substring(prefixLen));
+    }
+    return keys;
+  }
+  function has(key) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const cached = cache.get(fullKey);
+    if (!cached)
+      return false;
+    const now = Date.now();
+    if (cached.expiresAt <= now) {
+      cache.delete(fullKey);
+      return false;
+    }
+    return true;
+  }
+  return { get, clear, size, prune, getKeys, has };
+}
+
+// ../logger/src/index.ts
+var isBrowser = () => {
+  const g = globalThis;
+  return typeof g.window !== "undefined" && typeof g.document !== "undefined";
+};
+var isProduction = () => {
+  return typeof process !== "undefined" && false;
+};
+var isDevelopment = () => {
+  return typeof process !== "undefined" && true;
+};
+var isInteractiveTTY = () => {
+  return typeof process !== "undefined" && Boolean(process.stdout && process.stdout.isTTY);
+};
+var isSilent = () => {
+  return typeof process !== "undefined" && process.env.LOG_SILENT === "true";
+};
+var detectOutputFormat = () => {
+  if (isBrowser()) {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.env.LOG_FORMAT === "json") {
+    return "json-single-line";
+  }
+  if (typeof process !== "undefined" && process.env.LOG_PRETTY === "true" && isDevelopment()) {
+    return "json-pretty";
+  }
+  const colorPreference = typeof process !== "undefined" ? (process.env.LOG_COLOR ?? "auto").toLowerCase() : "auto";
+  if (colorPreference === "always" && !isProduction()) {
+    return "color-tty";
+  }
+  if (colorPreference === "never") {
+    return "json-single-line";
+  }
+  if (isProduction()) {
+    return "json-single-line";
+  }
+  if (isDevelopment() && isInteractiveTTY()) {
+    return "color-tty";
+  }
+  return "json-single-line";
+};
+var colors = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var getLevelColor = (level) => {
+  switch (level) {
+    case "debug":
+      return colors.blue;
+    case "info":
+      return colors.cyan;
+    case "warn":
+      return colors.yellow;
+    case "error":
+      return colors.red;
+    default:
+      return colors.reset;
+  }
+};
+var formatBrowserOutput = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const levelUpper = level.toUpperCase();
+  const consoleMethod = getConsoleMethod(level);
+  if (context && Object.keys(context).length > 0) {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message, context);
+  } else {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message);
+  }
+};
+var formatColorTTY = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const levelColor = getLevelColor(level);
+  const levelUpper = level.toUpperCase().padEnd(5);
+  const consoleMethod = getConsoleMethod(level);
+  const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+  if (context && Object.keys(context).length > 0) {
+    consoleMethod(`${coloredPrefix} ${message}`, context);
+  } else {
+    consoleMethod(`${coloredPrefix} ${message}`);
+  }
+};
+var formatJSONSingleLine = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    level: level.toUpperCase(),
+    message,
+    ...context && Object.keys(context).length > 0 && { context }
+  };
+  const consoleMethod = getConsoleMethod(level);
+  consoleMethod(JSON.stringify(logEntry));
+};
+var formatJSONPretty = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    level: level.toUpperCase(),
+    message,
+    ...context && Object.keys(context).length > 0 && { context }
+  };
+  const consoleMethod = getConsoleMethod(level);
+  consoleMethod(JSON.stringify(logEntry, null, 2));
+};
+var getConsoleMethod = (level) => {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+};
+var levelPriority = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var getMinimumLogLevel = () => {
+  const envLevel = typeof process !== "undefined" ? (process.env.LOG_LEVEL ?? "").toLowerCase() : "";
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return isProduction() ? "info" : "debug";
+};
+var shouldLog = (level) => {
+  if (isSilent())
+    return false;
+  const minLevel = getMinimumLogLevel();
+  return levelPriority[level] >= levelPriority[minLevel];
+};
+var customHandler;
+var performLog = (level, message, context) => {
+  if (!shouldLog(level))
+    return;
+  if (customHandler) {
+    customHandler(level, message, context);
+    return;
+  }
+  const outputFormat = detectOutputFormat();
+  switch (outputFormat) {
+    case "browser":
+      formatBrowserOutput(level, message, context);
+      break;
+    case "color-tty":
+      formatColorTTY(level, message, context);
+      break;
+    case "json-single-line":
+      formatJSONSingleLine(level, message, context);
+      break;
+    case "json-pretty":
+      formatJSONPretty(level, message, context);
+      break;
+  }
+};
+var createLogger = () => {
+  return {
+    debug: (message, context) => performLog("debug", message, context),
+    info: (message, context) => performLog("info", message, context),
+    warn: (message, context) => performLog("warn", message, context),
+    error: (message, context) => performLog("error", message, context),
+    log: performLog
+  };
+};
+var log = createLogger();
+
+// src/core/errors.ts
+class PlaycademyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlaycademyError";
+  }
+}
+
+class ApiError extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(`${status} ${message}`);
+    this.status = status;
+    this.details = details;
+    Object.setPrototypeOf(this, ApiError.prototype);
+  }
+}
+function extractApiErrorInfo(error) {
+  if (!(error instanceof ApiError)) {
+    return null;
+  }
+  const info = {
+    status: error.status,
+    statusText: error.message
+  };
+  if (error.details) {
+    info.details = error.details;
+  }
+  return info;
+}
+
+// src/core/request.ts
+function checkDevWarnings(data) {
+  if (!data || typeof data !== "object")
+    return;
+  const response = data;
+  const warningType = response.__playcademyDevWarning;
+  if (!warningType)
+    return;
+  switch (warningType) {
+    case "timeback-not-configured":
+      console.warn("%c⚠️ TimeBack Not Configured", "background: #f59e0b; color: white; padding: 6px 12px; border-radius: 4px; font-weight: bold; font-size: 13px");
+      console.log("%cTimeBack is configured in playcademy.config.js but the sandbox does not have TimeBack credentials.", "color: #f59e0b; font-weight: 500");
+      console.log("To test TimeBack locally:");
+      console.log("  Set the following environment variables:");
+      console.log("    • %cTIMEBACK_ONEROSTER_API_URL", "color: #0ea5e9; font-weight: 600; font-family: monospace");
+      console.log("    • %cTIMEBACK_CALIPER_API_URL", "color: #0ea5e9; font-weight: 600; font-family: monospace");
+      console.log("    • %cTIMEBACK_API_CLIENT_ID/SECRET", "color: #0ea5e9; font-weight: 600; font-family: monospace");
+      console.log("  Or deploy your game: %cplaycademy deploy", "color: #10b981; font-weight: 600; font-family: monospace");
+      console.log("  Or wait for %c@superbuilders/timeback-local%c (coming soon)", "color: #8b5cf6; font-weight: 600; font-family: monospace", "color: inherit");
+      break;
+    default:
+      console.warn(`[Playcademy Dev Warning] ${warningType}`);
+  }
+}
+function prepareRequestBody(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (body instanceof ArrayBuffer || body instanceof Blob || ArrayBuffer.isView(body)) {
+    if (!headers["Content-Type"]) {
+      headers["Content-Type"] = "application/octet-stream";
+    }
+    return body;
+  }
+  if (body !== undefined && body !== null) {
+    headers["Content-Type"] = "application/json";
+    return JSON.stringify(body);
+  }
+  return;
+}
+async function request({
+  path,
+  baseUrl,
+  method = "GET",
+  body,
+  extraHeaders = {},
+  raw = false
+}) {
+  const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
+  const headers = { ...extraHeaders };
+  const payload = prepareRequestBody(body, headers);
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: payload,
+    credentials: "omit"
+  });
+  if (raw) {
+    return res;
+  }
+  if (!res.ok) {
+    const clonedRes = res.clone();
+    const errorBody = await clonedRes.json().catch(() => clonedRes.text().catch(() => {
+      return;
+    })) ?? undefined;
+    throw new ApiError(res.status, res.statusText, errorBody);
+  }
+  if (res.status === 204)
+    return;
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      const parsed = await res.json();
+      checkDevWarnings(parsed);
+      return parsed;
+    } catch (err) {
+      if (err instanceof SyntaxError)
+        return;
+      throw err;
+    }
+  }
+  const rawText = await res.text().catch(() => "");
+  return rawText && rawText.length > 0 ? rawText : undefined;
+}
+async function fetchManifest(deploymentUrl) {
+  const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
+  try {
+    const response = await fetch(manifestUrl);
+    if (!response.ok) {
+      log.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
+      throw new PlaycademyError(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof PlaycademyError) {
+      throw error;
+    }
+    log.error(`[Playcademy SDK] Error fetching or parsing manifest from ${manifestUrl}:`, {
+      error
+    });
+    throw new PlaycademyError("Failed to load or parse game manifest");
+  }
+}
+
+// src/namespaces/platform/games.ts
+function createGamesNamespace(client) {
+  const gamesListCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "games.list"
+  });
+  const gameFetchCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "games.fetch"
+  });
+  return {
+    fetch: async (gameIdOrSlug, options) => {
+      const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
+      return gameFetchCache.get(gameIdOrSlug, async () => {
+        const baseGameData = await promise;
+        if (baseGameData.gameType === "hosted" && baseGameData.deploymentUrl !== null && baseGameData.deploymentUrl !== "") {
+          const manifestData = await fetchManifest(baseGameData.deploymentUrl);
+          return { ...baseGameData, manifest: manifestData };
+        }
+        return baseGameData;
+      }, options);
+    },
+    list: (options) => {
+      return gamesListCache.get("all", () => client["request"]("/games", "GET"), options);
+    },
+    saveState: async (state) => {
+      const gameId = client["_ensureGameId"]();
+      await client["request"](`/games/${gameId}/state`, "POST", { body: state });
+    },
+    loadState: async () => {
+      const gameId = client["_ensureGameId"]();
+      return client["request"](`/games/${gameId}/state`, "GET");
+    },
+    startSession: async (gameId) => {
+      const idToUse = gameId ?? client["_ensureGameId"]();
+      return client["request"](`/games/${idToUse}/sessions`, "POST", {});
+    },
+    endSession: async (sessionId, gameId) => {
+      const effectiveGameIdToEnd = gameId ?? client["_ensureGameId"]();
+      if (client["internalClientSessionId"] && sessionId === client["internalClientSessionId"] && effectiveGameIdToEnd === client["gameId"]) {
+        client["internalClientSessionId"] = undefined;
+      }
+      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
+    },
+    token: {
+      create: async (gameId, options) => {
+        const res = await client["request"](`/games/${gameId}/token`, "POST");
+        if (options?.apply) {
+          client.setToken(res.token);
+        }
+        return res;
+      }
+    },
+    leaderboard: {
+      get: async (gameId, options) => {
+        const params = new URLSearchParams;
+        if (options?.limit)
+          params.append("limit", String(options.limit));
+        if (options?.offset)
+          params.append("offset", String(options.offset));
+        const queryString = params.toString();
+        const path = queryString ? `/games/${gameId}/leaderboard?${queryString}` : `/games/${gameId}/leaderboard`;
+        return client["request"](path, "GET");
+      }
+    }
+  };
+}
+// src/namespaces/platform/character.ts
+function createCharacterNamespace(client) {
+  const componentCache = createTTLCache({
+    ttl: 5 * 60 * 1000,
+    keyPrefix: "character.components"
+  });
+  return {
+    get: async (userId) => {
+      try {
+        const path = userId ? `/character/${userId}` : "/character";
+        return await client["request"](path, "GET");
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.message.includes("404")) {
+            return null;
+          }
+        }
+        throw error;
+      }
+    },
+    create: async (characterData) => {
+      return client["request"]("/character", "POST", { body: characterData });
+    },
+    update: async (updates) => {
+      return client["request"]("/character", "PATCH", { body: updates });
+    },
+    components: {
+      list: async (options) => {
+        const cacheKey = options?.level === undefined ? "all" : String(options.level);
+        return componentCache.get(cacheKey, async () => {
+          const path = options?.level !== undefined ? `/character/components?level=${options.level}` : "/character/components";
+          const components = await client["request"](path, "GET");
+          return components || [];
+        }, options);
+      },
+      clearCache: (key) => componentCache.clear(key),
+      getCacheKeys: () => componentCache.getKeys()
+    },
+    accessories: {
+      equip: async (slot, componentId) => {
+        return client["request"]("/character/accessories/equip", "POST", { body: { slot, accessoryComponentId: componentId } });
+      },
+      remove: async (slot) => {
+        return client["request"](`/character/accessories/${slot}`, "DELETE");
+      },
+      list: async () => {
+        const character = await client.character.get();
+        return character?.accessories || [];
+      }
+    }
+  };
+}
+// src/namespaces/platform/achievements.ts
+function createAchievementsNamespace(client) {
+  const achievementsListCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "achievements.list"
+  });
+  const achievementsHistoryCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "achievements.history"
+  });
+  return {
+    list: (options) => {
+      return achievementsListCache.get("current", () => client["request"]("/achievements/current", "GET"), options);
+    },
+    history: {
+      list: async (queryOptions, cacheOptions) => {
+        const params = new URLSearchParams;
+        if (queryOptions?.limit)
+          params.append("limit", String(queryOptions.limit));
+        const qs = params.toString();
+        const path = qs ? `/achievements/history?${qs}` : "/achievements/history";
+        const cacheKey = qs ? `history-${qs}` : "history";
+        return achievementsHistoryCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+      }
+    },
+    progress: {
+      submit: async (achievementId) => client["request"]("/achievements/progress", "POST", {
+        body: { achievementId }
+      })
+    }
+  };
+}
+// src/namespaces/platform/leaderboard.ts
+function createLeaderboardNamespace(client) {
+  return {
+    fetch: async (options) => {
+      const params = new URLSearchParams({
+        timeframe: options?.timeframe || "all_time",
+        limit: String(options?.limit || 10),
+        offset: String(options?.offset || 0)
+      });
+      if (options?.gameId) {
+        params.append("gameId", options.gameId);
+      }
+      return client["request"](`/leaderboard?${params}`, "GET");
+    },
+    getUserRank: async (gameId, userId) => {
+      return client["request"](`/games/${gameId}/users/${userId}/rank`, "GET");
+    }
+  };
+}
+// src/core/cache/cooldown-cache.ts
+function createCooldownCache(defaultCooldownMs) {
+  const lastFetchTime = new Map;
+  const pendingRequests = new Map;
+  const lastResults = new Map;
+  async function get(key, loader, config) {
+    const now = Date.now();
+    const lastFetch = lastFetchTime.get(key) || 0;
+    const timeSinceLastFetch = now - lastFetch;
+    const effectiveCooldown = config?.cooldown !== undefined ? config.cooldown : defaultCooldownMs;
+    const force = config?.force || false;
+    const pending = pendingRequests.get(key);
+    if (pending) {
+      return pending;
+    }
+    if (!force && timeSinceLastFetch < effectiveCooldown) {
+      const cachedResult = lastResults.get(key);
+      if (cachedResult !== undefined) {
+        return Promise.resolve(cachedResult);
+      }
+    }
+    const promise = loader().then((result) => {
+      pendingRequests.delete(key);
+      lastFetchTime.set(key, Date.now());
+      lastResults.set(key, result);
+      return result;
+    }).catch((error) => {
+      pendingRequests.delete(key);
+      throw error;
+    });
+    pendingRequests.set(key, promise);
+    return promise;
+  }
+  function clear(key) {
+    if (key === undefined) {
+      lastFetchTime.clear();
+      pendingRequests.clear();
+      lastResults.clear();
+    } else {
+      lastFetchTime.delete(key);
+      pendingRequests.delete(key);
+      lastResults.delete(key);
+    }
+  }
+  return { get, clear };
+}
+
+// src/namespaces/platform/levels.ts
+function createLevelsNamespace(client) {
+  const progressCache = createCooldownCache(5000);
+  return {
+    get: async () => {
+      return client["request"]("/users/level", "GET");
+    },
+    progress: async (options) => {
+      return progressCache.get("user-progress", () => client["request"]("/users/level/progress", "GET"), options);
+    },
+    config: {
+      list: async () => {
+        return client["request"]("/levels/config", "GET");
+      },
+      get: async (level) => {
+        return client["request"](`/levels/config/${level}`, "GET");
+      }
+    }
+  };
+}
+// src/namespaces/platform/shop.ts
+function createShopNamespace(client) {
+  return {
+    view: () => {
+      return client["request"]("/shop/view", "GET");
+    }
+  };
+}
+// src/namespaces/platform/notifications.ts
+function createNotificationsNamespace(client) {
+  const notificationsListCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "notifications.list"
+  });
+  const notificationStatsCache = createTTLCache({
+    ttl: 30 * 1000,
+    keyPrefix: "notifications.stats"
+  });
+  return {
+    list: async (queryOptions, cacheOptions) => {
+      const params = new URLSearchParams;
+      if (queryOptions?.status)
+        params.append("status", queryOptions.status);
+      if (queryOptions?.type)
+        params.append("type", queryOptions.type);
+      if (queryOptions?.limit)
+        params.append("limit", String(queryOptions.limit));
+      if (queryOptions?.offset)
+        params.append("offset", String(queryOptions.offset));
+      const qs = params.toString();
+      const path = qs ? `/notifications?${qs}` : "/notifications";
+      const cacheKey = qs ? `list-${qs}` : "list";
+      return notificationsListCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+    },
+    markAsSeen: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        body: {
+          id: notificationId,
+          status: "seen"
+        }
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    markAsClicked: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        body: {
+          id: notificationId,
+          status: "clicked"
+        }
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    dismiss: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        body: {
+          id: notificationId,
+          status: "dismissed"
+        }
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    stats: {
+      get: async (queryOptions, cacheOptions) => {
+        const user = await client.users.me();
+        const params = new URLSearchParams;
+        if (queryOptions?.from)
+          params.append("from", queryOptions.from);
+        if (queryOptions?.to)
+          params.append("to", queryOptions.to);
+        const qs = params.toString();
+        const path = qs ? `/notifications/stats/${user.id}?${qs}` : `/notifications/stats/${user.id}`;
+        const cacheKey = qs ? `stats-${qs}` : "stats";
+        return notificationStatsCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+      }
+    }
+  };
+}
+// src/namespaces/platform/maps.ts
+function createMapsNamespace(client) {
+  const mapDataCache = createTTLCache({
+    ttl: 5 * 60 * 1000,
+    keyPrefix: "maps.data"
+  });
+  const mapElementsCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "maps.elements"
+  });
+  return {
+    get: (identifier, options) => mapDataCache.get(identifier, () => client["request"](`/maps/${identifier}`, "GET"), options),
+    elements: (mapId, options) => mapElementsCache.get(mapId, () => client["request"](`/map/elements?mapId=${mapId}`, "GET"), options),
+    objects: {
+      list: (mapId) => client["request"](`/maps/${mapId}/objects`, "GET"),
+      create: (mapId, objectData) => client["request"](`/maps/${mapId}/objects`, "POST", {
+        body: objectData
+      }),
+      delete: (mapId, objectId) => client["request"](`/maps/${mapId}/objects/${objectId}`, "DELETE")
+    }
+  };
+}
+// src/core/cache/permanent-cache.ts
+function createPermanentCache(keyPrefix) {
+  const cache = new Map;
+  async function get(key, loader) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const existing = cache.get(fullKey);
+    if (existing)
+      return existing;
+    const promise = loader().catch((error) => {
+      cache.delete(fullKey);
+      throw error;
+    });
+    cache.set(fullKey, promise);
+    return promise;
+  }
+  function clear(key) {
+    if (key === undefined) {
+      cache.clear();
+    } else {
+      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+      cache.delete(fullKey);
+    }
+  }
+  function has(key) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    return cache.has(fullKey);
+  }
+  function size() {
+    return cache.size;
+  }
+  function keys() {
+    const result = [];
+    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
+    for (const fullKey of cache.keys()) {
+      result.push(fullKey.substring(prefixLen));
+    }
+    return result;
+  }
+  return { get, clear, has, size, keys };
+}
+
+// src/namespaces/platform/sprites.ts
+function createSpritesNamespace(client) {
+  const templateUrlCache = createPermanentCache("sprite-template-urls");
+  return {
+    templates: {
+      get: async (slug) => {
+        if (!slug)
+          throw new Error("Sprite template slug is required");
+        const templateMeta = await templateUrlCache.get(slug, async () => {
+          return client["request"](`/sprites/templates/${slug}`, "GET");
+        });
+        if (!templateMeta.url) {
+          throw new Error(`Template ${slug} has no URL in database`);
+        }
+        const response = await fetch(templateMeta.url);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch template JSON from ${templateMeta.url}: ${response.statusText}`);
+        }
+        return await response.json();
+      }
+    }
+  };
+}
+// src/namespaces/platform/telemetry.ts
+function createTelemetryNamespace(client) {
+  return {
+    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", { body: metrics })
+  };
+}
+// src/namespaces/game/scores.ts
+function createScoresNamespace(client) {
+  return {
+    submit: async (gameId, score, metadata) => {
+      return client["request"](`/games/${gameId}/scores`, "POST", {
+        body: {
+          score,
+          metadata
+        }
+      });
+    }
+  };
+}
+
+// src/namespaces/platform/scores.ts
+function createScoresNamespace2(client) {
+  const publicScores = createScoresNamespace(client);
+  return {
+    ...publicScores,
+    getByUser: async (gameId, userId, options) => {
+      const params = new URLSearchParams;
+      if (options?.limit) {
+        params.append("limit", String(options.limit));
+      }
+      const queryString = params.toString();
+      const path = queryString ? `/games/${gameId}/users/${userId}/scores?${queryString}` : `/games/${gameId}/users/${userId}/scores`;
+      const response = await client["request"](path, "GET");
+      return response.map((score) => ({
+        ...score,
+        achievedAt: new Date(score.achievedAt)
+      }));
+    }
+  };
+}
+// src/namespaces/platform/timeback.ts
+var NOT_SUPPORTED = "Activity tracking is not available on the platform client. Use the game SDK instead.";
+function createTimebackNamespace(client) {
+  const enrollmentsCache = createTTLCache({
+    ttl: 30 * 1000,
+    keyPrefix: "platform.timeback.enrollments"
+  });
+  return {
+    startActivity: (_metadata) => {
+      throw new Error(NOT_SUPPORTED);
+    },
+    pauseActivity: () => {
+      throw new Error(NOT_SUPPORTED);
+    },
+    resumeActivity: () => {
+      throw new Error(NOT_SUPPORTED);
+    },
+    endActivity: async (_data) => {
+      throw new Error(NOT_SUPPORTED);
+    },
+    management: {
+      setup: (request2) => {
+        return client["request"]("/timeback/setup", "POST", {
+          body: request2
+        });
+      },
+      verify: (gameId) => {
+        return client["request"](`/timeback/verify/${gameId}`, "GET");
+      },
+      cleanup: (gameId) => {
+        return client["request"](`/timeback/integrations/${gameId}`, "DELETE");
+      },
+      get: (gameId) => {
+        return client["request"](`/timeback/integrations/${gameId}`, "GET");
+      },
+      getConfig: (gameId) => {
+        return client["request"](`/timeback/config/${gameId}`, "GET");
+      }
+    },
+    xp: {
+      today: async (options) => {
+        const params = new URLSearchParams;
+        if (options?.date)
+          params.set("date", options.date);
+        if (options?.timezone)
+          params.set("tz", options.timezone);
+        const query = params.toString();
+        const endpoint = query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
+        return client["request"](endpoint, "GET");
+      },
+      total: async () => {
+        return client["request"]("/timeback/xp/total", "GET");
+      },
+      history: async (options) => {
+        const params = new URLSearchParams;
+        if (options?.startDate)
+          params.set("startDate", options.startDate);
+        if (options?.endDate)
+          params.set("endDate", options.endDate);
+        const query = params.toString();
+        const endpoint = query ? `/timeback/xp/history?${query}` : "/timeback/xp/history";
+        return client["request"](endpoint, "GET");
+      },
+      summary: async (options) => {
+        const [today, total] = await Promise.all([
+          client["request"]((() => {
+            const params = new URLSearchParams;
+            if (options?.date)
+              params.set("date", options.date);
+            if (options?.timezone)
+              params.set("tz", options.timezone);
+            const query = params.toString();
+            return query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
+          })(), "GET"),
+          client["request"]("/timeback/xp/total", "GET")
+        ]);
+        return { today, total };
+      }
+    },
+    enrollments: {
+      get: async (timebackId, options) => {
+        return enrollmentsCache.get(timebackId, async () => {
+          const response = await client["request"](`/timeback/enrollments/${timebackId}`, "GET");
+          return response.enrollments;
+        }, options);
+      },
+      clearCache: (timebackId) => {
+        enrollmentsCache.clear(timebackId);
+      }
+    }
+  };
+}
+// src/core/auth/strategies.ts
+class ApiKeyAuth {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getToken() {
+    return this.apiKey;
+  }
+  getType() {
+    return "apiKey";
+  }
+  getHeaders() {
+    return { "x-api-key": this.apiKey };
+  }
+}
+
+class SessionAuth {
+  sessionToken;
+  constructor(sessionToken) {
+    this.sessionToken = sessionToken;
+  }
+  getToken() {
+    return this.sessionToken;
+  }
+  getType() {
+    return "session";
+  }
+  getHeaders() {
+    return { Authorization: `Bearer ${this.sessionToken}` };
+  }
+}
+
+class GameJwtAuth {
+  gameToken;
+  constructor(gameToken) {
+    this.gameToken = gameToken;
+  }
+  getToken() {
+    return this.gameToken;
+  }
+  getType() {
+    return "gameJwt";
+  }
+  getHeaders() {
+    return { Authorization: `Bearer ${this.gameToken}` };
+  }
+}
+
+class NoAuth {
+  getToken() {
+    return null;
+  }
+  getType() {
+    return "session";
+  }
+  getHeaders() {
+    return {};
+  }
+}
+function createAuthStrategy(token, tokenType) {
+  if (!token) {
+    return new NoAuth;
+  }
+  if (tokenType === "apiKey") {
+    return new ApiKeyAuth(token);
+  }
+  if (tokenType === "session") {
+    return new SessionAuth(token);
+  }
+  if (tokenType === "gameJwt") {
+    return new GameJwtAuth(token);
+  }
+  if (token.startsWith("cademy")) {
+    return new ApiKeyAuth(token);
+  }
+  return new GameJwtAuth(token);
+}
+
+// src/core/auth/utils.ts
+function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
+  const left = window.screenX + (window.outerWidth - width) / 2;
+  const top = window.screenY + (window.outerHeight - height) / 2;
+  const features = [
+    `width=${width}`,
+    `height=${height}`,
+    `left=${left}`,
+    `top=${top}`,
+    "toolbar=no",
+    "menubar=no",
+    "location=yes",
+    "status=yes",
+    "scrollbars=yes",
+    "resizable=yes"
+  ].join(",");
+  return window.open(url, name, features);
+}
+function isInIframe() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+
+// 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
+var MessageEvents;
+((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 ||= {});
+
+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 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);
+      });
+    }
+  }
+}
+// src/core/static/init.ts
+async function getPlaycademyConfig(allowedParentOrigins) {
+  const preloaded = window.PLAYCADEMY;
+  if (preloaded?.token) {
+    return preloaded;
+  }
+  if (window.self !== window.top) {
+    return await waitForPlaycademyInit(allowedParentOrigins);
+  } else {
+    return createStandaloneConfig();
+  }
+}
+function getReferrerOrigin() {
+  try {
+    return document.referrer ? new URL(document.referrer).origin : null;
+  } catch {
+    return null;
+  }
+}
+function buildAllowedOrigins(explicit) {
+  if (Array.isArray(explicit) && explicit.length > 0)
+    return explicit;
+  const ref = getReferrerOrigin();
+  return ref ? [ref] : [];
+}
+function isOriginAllowed(origin, allowlist) {
+  if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") {
+    return true;
+  }
+  if (!allowlist || allowlist.length === 0) {
+    console.error("[Playcademy SDK] No allowed origins configured. Consider passing allowedParentOrigins explicitly to init().");
+    return false;
+  }
+  return allowlist.includes(origin);
+}
+async function waitForPlaycademyInit(allowedParentOrigins) {
+  return new Promise((resolve, reject) => {
+    let contextReceived = false;
+    const timeoutDuration = 5000;
+    const allowlist = buildAllowedOrigins(allowedParentOrigins);
+    let hasWarnedAboutUntrustedOrigin = false;
+    function warnAboutUntrustedOrigin(origin) {
+      if (hasWarnedAboutUntrustedOrigin)
+        return;
+      hasWarnedAboutUntrustedOrigin = true;
+      console.warn("[Playcademy SDK] Ignoring INIT from untrusted origin:", origin);
+    }
+    const handleMessage = (event) => {
+      if (event.data?.type !== "PLAYCADEMY_INIT" /* INIT */)
+        return;
+      if (!isOriginAllowed(event.origin, allowlist)) {
+        warnAboutUntrustedOrigin(event.origin);
+        return;
+      }
+      contextReceived = true;
+      window.removeEventListener("message", handleMessage);
+      clearTimeout(timeoutId);
+      window.PLAYCADEMY = event.data.payload;
+      resolve(event.data.payload);
+    };
+    window.addEventListener("message", handleMessage);
+    const timeoutId = setTimeout(() => {
+      if (!contextReceived) {
+        window.removeEventListener("message", handleMessage);
+        reject(new Error(`${"PLAYCADEMY_INIT" /* INIT */} not received within ${timeoutDuration}ms`));
+      }
+    }, timeoutDuration);
+  });
+}
+function createStandaloneConfig() {
+  console.debug("[Playcademy SDK] Standalone mode detected, creating mock context for sandbox development");
+  const mockConfig = {
+    baseUrl: "http://localhost:4321",
+    gameUrl: window.location.origin,
+    token: "mock-game-token-for-local-dev",
+    gameId: "mock-game-id-from-template",
+    realtimeUrl: undefined
+  };
+  window.PLAYCADEMY = mockConfig;
+  return mockConfig;
+}
+async function init(options) {
+  if (typeof window === "undefined") {
+    throw new Error("Playcademy SDK must run in a browser context");
+  }
+  const config = await getPlaycademyConfig(options?.allowedParentOrigins);
+  if (options?.baseUrl) {
+    config.baseUrl = options.baseUrl;
+  }
+  const client = new this({
+    baseUrl: config.baseUrl,
+    gameUrl: config.gameUrl,
+    token: config.token,
+    gameId: config.gameId,
+    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));
+  messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+  return client;
+}
+// src/core/static/login.ts
+async function login(baseUrl, email, password) {
+  let url = baseUrl;
+  if (baseUrl.startsWith("/") && typeof window !== "undefined") {
+    url = window.location.origin + baseUrl;
+  }
+  url = url + "/auth/login";
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ email, password })
+  });
+  if (!response.ok) {
+    try {
+      const errorData = await response.json();
+      const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
+      throw new PlaycademyError(errorMessage);
+    } catch (error) {
+      log.error("[Playcademy SDK] Failed to parse error response JSON, using status text instead:", { error });
+      throw new PlaycademyError(response.statusText);
+    }
+  }
+  return response.json();
+}
+// ../utils/src/random.ts
+async function generateSecureRandomString(length) {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const randomValues = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(randomValues);
+  return Array.from(randomValues).map((byte) => charset[byte % charset.length]).join("");
+}
+
+// src/core/auth/oauth.ts
+function getTimebackConfig() {
+  return {
+    authorizationEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/authorize",
+    tokenEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/token",
+    scope: "openid email phone"
+  };
+}
+var OAUTH_CONFIGS = {
+  get TIMEBACK() {
+    return getTimebackConfig;
+  }
+};
+async function generateOAuthState(data) {
+  const csrfToken = await generateSecureRandomString(32);
+  if (data && Object.keys(data).length > 0) {
+    const jsonStr = JSON.stringify(data);
+    const base64 = btoa(jsonStr).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return `${csrfToken}.${base64}`;
+  }
+  return csrfToken;
+}
+function parseOAuthState(state) {
+  const lastDotIndex = state.lastIndexOf(".");
+  if (lastDotIndex > 0 && lastDotIndex < state.length - 1) {
+    try {
+      const csrfToken = state.substring(0, lastDotIndex);
+      const base64 = state.substring(lastDotIndex + 1);
+      const base64WithPadding = base64.replace(/-/g, "+").replace(/_/g, "/");
+      const paddedBase64 = base64WithPadding + "=".repeat((4 - base64WithPadding.length % 4) % 4);
+      const jsonStr = atob(paddedBase64);
+      const data = JSON.parse(jsonStr);
+      return { csrfToken, data };
+    } catch {}
+  }
+  return { csrfToken: state };
+}
+function getOAuthConfig(provider) {
+  const configGetter = OAUTH_CONFIGS[provider];
+  if (!configGetter)
+    throw new Error(`Unsupported auth provider: ${provider}`);
+  return configGetter();
+}
+
+// src/core/static/identity.ts
+var identity = {
+  parseOAuthState
+};
+// src/core/auth/flows/popup.ts
+async function initiatePopupFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Opening authentication window..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    const popup = openPopupWindow(authUrl, "playcademy-auth");
+    if (!popup || popup.closed) {
+      throw new Error("Popup blocked. Please enable popups and try again.");
+    }
+    onStateChange?.({
+      status: "exchanging_token",
+      message: "Waiting for authentication..."
+    });
+    return await waitForServerMessage(popup, onStateChange);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage,
+      error: error instanceof Error ? error : new Error(errorMessage)
+    });
+    throw error;
+  }
+}
+async function waitForServerMessage(popup, onStateChange) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const handleMessage = (event) => {
+      if (event.origin !== window.location.origin)
+        return;
+      const data = event.data;
+      if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
+        resolved = true;
+        window.removeEventListener("message", handleMessage);
+        if (data.authenticated && data.user) {
+          onStateChange?.({
+            status: "complete",
+            message: "Authentication successful"
+          });
+          resolve({
+            success: true,
+            user: data.user
+          });
+        } else {
+          const error = new Error(data.error || "Authentication failed");
+          onStateChange?.({
+            status: "error",
+            message: error.message,
+            error
+          });
+          resolve({
+            success: false,
+            error
+          });
+        }
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const checkClosed = setInterval(() => {
+      if (popup.closed && !resolved) {
+        clearInterval(checkClosed);
+        window.removeEventListener("message", handleMessage);
+        const error = new Error("Authentication cancelled");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 500);
+    setTimeout(() => {
+      if (!resolved) {
+        window.removeEventListener("message", handleMessage);
+        clearInterval(checkClosed);
+        const error = new Error("Authentication timeout");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 5 * 60 * 1000);
+  });
+}
+
+// src/core/auth/flows/redirect.ts
+async function initiateRedirectFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Redirecting to authentication provider..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    window.location.href = authUrl;
+    return new Promise(() => {});
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage,
+      error: error instanceof Error ? error : new Error(errorMessage)
+    });
+    throw error;
+  }
+}
+
+// src/core/auth/flows/unified.ts
+async function initiateUnifiedFlow(options) {
+  const { mode = "auto" } = options;
+  const effectiveMode = mode === "auto" ? isInIframe() ? "popup" : "redirect" : mode;
+  switch (effectiveMode) {
+    case "popup":
+      return initiatePopupFlow(options);
+    case "redirect":
+      return initiateRedirectFlow(options);
+    default:
+      throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
+  }
+}
+
+// src/core/auth/login.ts
+async function login2(client, options) {
+  try {
+    let stateData = options.stateData;
+    if (!stateData) {
+      try {
+        const currentUser = await client.users.me();
+        if (currentUser?.id) {
+          stateData = { playcademy_user_id: currentUser.id };
+        }
+      } catch {
+        log.debug("[Playcademy SDK] No current user available for state data");
+      }
+    }
+    log.debug("[Playcademy SDK] Starting OAuth login", {
+      provider: options.provider,
+      mode: options.mode || "auto",
+      callbackUrl: options.callbackUrl,
+      hasStateData: !!stateData
+    });
+    const optionsWithState = {
+      ...options,
+      stateData
+    };
+    const result = await initiateUnifiedFlow(optionsWithState);
+    if (result.success && result.user) {
+      log.debug("[Playcademy SDK] OAuth login successful", {
+        userId: result.user.sub
+      });
+    }
+    return result;
+  } catch (error) {
+    log.error("[Playcademy SDK] OAuth login failed", { error });
+    const authError = error instanceof Error ? error : new Error("Authentication failed");
+    return {
+      success: false,
+      error: authError
+    };
+  }
+}
+
+// src/namespaces/game/identity.ts
+function createIdentityNamespace(client) {
+  return {
+    connect: (options) => login2(client, options),
+    _getContext: () => ({
+      isInIframe: client["authContext"]?.isInIframe ?? false
+    })
+  };
+}
+// src/namespaces/game/runtime.ts
+function createRuntimeNamespace(client) {
+  const eventListeners = new Map;
+  const trackListener = (eventType, handler) => {
+    if (!eventListeners.has(eventType)) {
+      eventListeners.set(eventType, new Set);
+    }
+    eventListeners.get(eventType).add(handler);
+  };
+  const untrackListener = (eventType, handler) => {
+    const listeners = eventListeners.get(eventType);
+    if (listeners) {
+      listeners.delete(handler);
+      if (listeners.size === 0) {
+        eventListeners.delete(eventType);
+      }
+    }
+  };
+  if (typeof window !== "undefined" && window.self !== window.top) {
+    const playcademyConfig = window.PLAYCADEMY;
+    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() ?? "")) {
+        messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
+          key: event.key,
+          code: event.code,
+          type: event.type
+        });
+      }
+    };
+    window.addEventListener("keydown", keyListener);
+    window.addEventListener("keyup", keyListener);
+    trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, () => {
+      window.removeEventListener("keydown", keyListener);
+      window.removeEventListener("keyup", keyListener);
+    });
+  }
+  return {
+    getGameToken: async (gameId, options) => {
+      const res = await client["request"](`/games/${gameId}/token`, "POST");
+      if (options?.apply) {
+        client.setToken(res.token);
+      }
+      return res;
+    },
+    exit: async () => {
+      if (client["internalClientSessionId"] && client["gameId"]) {
+        try {
+          await client["_sessionManager"].endSession(client["internalClientSessionId"], client["gameId"]);
+        } catch (error) {
+          log.error("[Playcademy SDK] Failed to auto-end session:", {
+            sessionId: client["internalClientSessionId"],
+            error
+          });
+        }
+      }
+      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
+    },
+    onInit: (handler) => {
+      messaging.listen("PLAYCADEMY_INIT" /* INIT */, handler);
+      trackListener("PLAYCADEMY_INIT" /* INIT */, handler);
+    },
+    onTokenRefresh: (handler) => {
+      messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+      trackListener("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+    },
+    onPause: (handler) => {
+      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+      trackListener("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+    },
+    onResume: (handler) => {
+      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, handler);
+      trackListener("PLAYCADEMY_RESUME" /* RESUME */, handler);
+    },
+    onForceExit: (handler) => {
+      messaging.listen("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+      trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+    },
+    onOverlay: (handler) => {
+      messaging.listen("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+      trackListener("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+    },
+    ready: () => {
+      messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+    },
+    sendTelemetry: (data) => {
+      messaging.send("PLAYCADEMY_TELEMETRY" /* TELEMETRY */, data);
+    },
+    removeListener: (eventType, handler) => {
+      messaging.unlisten(eventType, handler);
+      untrackListener(eventType, handler);
+    },
+    removeAllListeners: () => {
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        for (const handler of handlers) {
+          messaging.unlisten(eventType, handler);
+        }
+      }
+      eventListeners.clear();
+    },
+    getListenerCounts: () => {
+      const counts = {};
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        counts[eventType] = handlers.size;
+      }
+      return counts;
+    },
+    assets: {
+      url(pathOrStrings, ...values) {
+        const gameUrl = client["initPayload"]?.gameUrl;
+        let path;
+        if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
+          const strings = pathOrStrings;
+          path = strings.reduce((acc, str, i) => {
+            return acc + str + (values[i] != null ? String(values[i]) : "");
+          }, "");
+        } else {
+          path = pathOrStrings;
+        }
+        if (!gameUrl) {
+          return path.startsWith("./") ? path : "./" + path;
+        }
+        const cleanPath = path.startsWith("./") ? path.slice(2) : path;
+        return gameUrl + cleanPath;
+      },
+      fetch: async (path, options) => {
+        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(gameUrl + cleanPath, options);
+      },
+      json: async (path) => {
+        const response = await client.runtime.assets.fetch(path);
+        return response.json();
+      },
+      blob: async (path) => {
+        const response = await client.runtime.assets.fetch(path);
+        return response.blob();
+      },
+      text: async (path) => {
+        const response = await client.runtime.assets.fetch(path);
+        return response.text();
+      },
+      arrayBuffer: async (path) => {
+        const response = await client.runtime.assets.fetch(path);
+        return response.arrayBuffer();
+      }
+    }
+  };
+}
+// src/namespaces/game/backend.ts
+function createBackendNamespace(client) {
+  function normalizePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+  return {
+    async get(path, headers) {
+      return client["requestGameBackend"](normalizePath(path), "GET", undefined, headers);
+    },
+    async post(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "POST", body, headers);
+    },
+    async put(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "PUT", body, headers);
+    },
+    async patch(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "PATCH", body, headers);
+    },
+    async delete(path, headers) {
+      return client["requestGameBackend"](normalizePath(path), "DELETE", undefined, headers);
+    },
+    async request(path, method, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), method, body, headers);
+    },
+    async download(path, method = "GET", body, headers) {
+      return client["requestGameBackend"](normalizePath(path), method, body, headers, true);
+    },
+    url(pathOrStrings, ...values) {
+      if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
+        const strings = pathOrStrings;
+        const path2 = strings.reduce((acc, str, i) => {
+          return acc + str + (values[i] != null ? String(values[i]) : "");
+        }, "");
+        return `${client.gameUrl}/api${path2.startsWith("/") ? path2 : `/${path2}`}`;
+      }
+      const path = pathOrStrings;
+      return `${client.gameUrl}/api${path.startsWith("/") ? path : `/${path}`}`;
+    }
+  };
+}
+// src/namespaces/game/users.ts
+function createUsersNamespace(client) {
+  const itemIdCache = createPermanentCache("items");
+  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const resolveItemId = async (identifier) => {
+    if (UUID_REGEX.test(identifier))
+      return identifier;
+    const gameId = client["gameId"];
+    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
+    return itemIdCache.get(cacheKey, async () => {
+      const queryParams = new URLSearchParams({ slug: identifier });
+      if (gameId)
+        queryParams.append("gameId", gameId);
+      const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      return item.id;
+    });
+  };
+  return {
+    me: async () => {
+      return client["request"]("/users/me", "GET");
+    },
+    inventory: {
+      get: async () => client["request"](`/inventory`, "GET"),
+      add: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/add`, "POST", { body: { itemId, qty } });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      remove: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/remove`, "POST", { body: { itemId, qty } });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: -qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      quantity: async (identifier) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        return item?.quantity ?? 0;
+      },
+      has: async (identifier, minQuantity = 1) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        const qty = item?.quantity ?? 0;
+        return qty >= minQuantity;
+      }
+    }
+  };
+}
+// ../constants/src/overworld.ts
+var ITEM_SLUGS = {
+  PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
+  PLAYCADEMY_XP: "PLAYCADEMY_XP",
+  FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
+  EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
+  FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
+  COMMON_SWORD: "COMMON_SWORD",
+  SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
+  SMALL_BACKPACK: "SMALL_BACKPACK",
+  LAVA_LAMP: "LAVA_LAMP",
+  BOOMBOX: "BOOMBOX",
+  CABIN_BED: "CABIN_BED"
+};
+var CURRENCIES = {
+  PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+  XP: ITEM_SLUGS.PLAYCADEMY_XP
+};
+var BADGES = {
+  FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+  EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+  FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
+};
+// ../constants/src/timeback.ts
+var TIMEBACK_ROUTES = {
+  END_ACTIVITY: "/integrations/timeback/end-activity"
+};
+// src/core/cache/singleton-cache.ts
+function createSingletonCache() {
+  let cachedValue;
+  let hasValue = false;
+  async function get(loader) {
+    if (hasValue) {
+      return cachedValue;
+    }
+    const value = await loader();
+    cachedValue = value;
+    hasValue = true;
+    return value;
+  }
+  function clear() {
+    cachedValue = undefined;
+    hasValue = false;
+  }
+  function has() {
+    return hasValue;
+  }
+  return { get, clear, has };
+}
+
+// src/namespaces/game/credits.ts
+function createCreditsNamespace(client) {
+  const creditsIdCache = createSingletonCache();
+  const getCreditsItemId = async () => {
+    return creditsIdCache.get(async () => {
+      const queryParams = new URLSearchParams({ slug: CURRENCIES.PRIMARY });
+      const creditsItem = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      if (!creditsItem || !creditsItem.id) {
+        throw new Error("Playcademy Credits item not found in catalog");
+      }
+      return creditsItem.id;
+    });
+  };
+  return {
+    balance: async () => {
+      const inventory = await client["request"]("/inventory", "GET");
+      const primaryCurrencyInventoryItem = inventory.find((item) => item.item?.slug === CURRENCIES.PRIMARY);
+      return primaryCurrencyInventoryItem?.quantity ?? 0;
+    },
+    add: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/add", "POST", {
+        body: {
+          itemId: creditsItemId,
+          qty: amount
+        }
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    },
+    spend: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/remove", "POST", {
+        body: {
+          itemId: creditsItemId,
+          qty: amount
+        }
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: -amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    }
+  };
+}
+// src/namespaces/game/realtime.client.ts
+var CLOSE_CODES = {
+  NORMAL_CLOSURE: 1000,
+  TOKEN_REFRESH: 4000
+};
+
+class RealtimeChannelClient {
+  gameId;
+  _channelName;
+  getToken;
+  baseUrl;
+  ws;
+  listeners = new Set;
+  isClosing = false;
+  tokenRefreshUnsubscribe;
+  constructor(gameId, _channelName, getToken, baseUrl) {
+    this.gameId = gameId;
+    this._channelName = _channelName;
+    this.getToken = getToken;
+    this.baseUrl = baseUrl;
+  }
+  async connect() {
+    try {
+      const token = await this.getToken();
+      let wsBase;
+      if (/^ws(s)?:\/\//.test(this.baseUrl)) {
+        wsBase = this.baseUrl;
+      } else if (/^http(s)?:\/\//.test(this.baseUrl)) {
+        wsBase = this.baseUrl.replace(/^http/, "ws");
+      } else {
+        const isBrowser2 = typeof window !== "undefined";
+        if (isBrowser2) {
+          const proto = window.location.protocol === "https:" ? "wss" : "ws";
+          wsBase = `${proto}://${window.location.host}${this.baseUrl}`;
+        } else {
+          wsBase = `ws://${this.baseUrl.replace(/^\//, "")}`;
+        }
+      }
+      const url = new URL(wsBase);
+      url.searchParams.set("token", token);
+      url.searchParams.set("c", this._channelName);
+      this.ws = new WebSocket(url);
+      this.setupEventHandlers();
+      this.setupTokenRefreshListener();
+      await new Promise((resolve, reject) => {
+        if (!this.ws) {
+          reject(new Error("WebSocket creation failed"));
+          return;
+        }
+        const onOpen = () => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (event) => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          reject(new Error(`WebSocket connection failed: ${event}`));
+        };
+        this.ws.addEventListener("open", onOpen);
+        this.ws.addEventListener("error", onError);
+      });
+      log.debug("[RealtimeChannelClient] Connected to channel", {
+        gameId: this.gameId,
+        channel: this._channelName
+      });
+      return this;
+    } catch (error) {
+      log.error("[RealtimeChannelClient] Connection failed", {
+        gameId: this.gameId,
+        channel: this._channelName,
+        error
+      });
+      throw error;
+    }
+  }
+  setupEventHandlers() {
+    if (!this.ws)
+      return;
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.listeners.forEach((callback) => {
+          try {
+            callback(data);
+          } catch (error) {
+            log.warn("[RealtimeChannelClient] Message listener error", {
+              channel: this._channelName,
+              error
+            });
+          }
+        });
+      } catch (error) {
+        log.warn("[RealtimeChannelClient] Failed to parse message", {
+          channel: this._channelName,
+          message: event.data,
+          error
+        });
+      }
+    };
+    this.ws.onclose = (event) => {
+      log.debug("[RealtimeChannelClient] Connection closed", {
+        channel: this._channelName,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (!this.isClosing && event.code !== CLOSE_CODES.TOKEN_REFRESH) {
+        log.warn("[RealtimeChannelClient] Unexpected disconnection", {
+          channel: this._channelName,
+          code: event.code,
+          reason: event.reason
+        });
+      }
+    };
+    this.ws.onerror = (event) => {
+      log.error("[RealtimeChannelClient] WebSocket error", {
+        channel: this._channelName,
+        event
+      });
+    };
+  }
+  setupTokenRefreshListener() {
+    const tokenRefreshHandler = async ({ token }) => {
+      log.debug("[RealtimeChannelClient] Token refresh received, reconnecting", {
+        channel: this._channelName
+      });
+      try {
+        await this.reconnectWithNewToken(token);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Token refresh reconnection failed", {
+          channel: this._channelName,
+          error
+        });
+      }
+    };
+    messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    this.tokenRefreshUnsubscribe = () => {
+      messaging.unlisten("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    };
+  }
+  async reconnectWithNewToken(_token) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.close(CLOSE_CODES.TOKEN_REFRESH, "token_refresh");
+      await new Promise((resolve) => {
+        const checkClosed = () => {
+          if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            resolve();
+          } else {
+            setTimeout(checkClosed, 10);
+          }
+        };
+        checkClosed();
+      });
+    }
+    await this.connect();
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      try {
+        const message = JSON.stringify(data);
+        this.ws.send(message);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Failed to send message", {
+          channel: this._channelName,
+          error,
+          data
+        });
+      }
+    } else {
+      log.warn("[RealtimeChannelClient] Cannot send message - connection not open", {
+        channel: this._channelName,
+        readyState: this.ws?.readyState
+      });
+    }
+  }
+  onMessage(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  close() {
+    this.isClosing = true;
+    if (this.tokenRefreshUnsubscribe) {
+      this.tokenRefreshUnsubscribe();
+      this.tokenRefreshUnsubscribe = undefined;
+    }
+    if (this.ws) {
+      this.ws.close(CLOSE_CODES.NORMAL_CLOSURE, "client_close");
+      this.ws = undefined;
+    }
+    this.listeners.clear();
+    log.debug("[RealtimeChannelClient] Channel closed", {
+      channel: this._channelName
+    });
+  }
+  get channelName() {
+    return this._channelName;
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+}
+
+// src/namespaces/game/realtime.ts
+function createRealtimeNamespace(client) {
+  return {
+    token: {
+      get: async () => {
+        const endpoint = client["gameId"] ? `/games/${client["gameId"]}/realtime/token` : "/realtime/token";
+        return client["request"](endpoint, "POST");
+      }
+    },
+    async open(channel = "default", url) {
+      if (!client["gameId"]) {
+        throw new Error("gameId is required for realtime channels");
+      }
+      let wsBaseUrl = url;
+      if (!wsBaseUrl && typeof window !== "undefined") {
+        const ctx = window.PLAYCADEMY;
+        if (ctx?.realtimeUrl) {
+          wsBaseUrl = ctx.realtimeUrl;
+        }
+      }
+      const realtimeClient = new RealtimeChannelClient(client["gameId"], channel, () => client.realtime.token.get().then((r) => r.token), wsBaseUrl ?? client.getBaseUrl());
+      return realtimeClient.connect();
+    }
+  };
+}
+// src/namespaces/game/timeback.ts
+function createTimebackNamespace2(client) {
+  let currentActivity = null;
+  return {
+    startActivity: (metadata) => {
+      currentActivity = {
+        startTime: Date.now(),
+        metadata,
+        pausedTime: 0,
+        pauseStartTime: null
+      };
+    },
+    pauseActivity: () => {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before pauseActivity().");
+      }
+      if (currentActivity.pauseStartTime !== null) {
+        throw new Error("Activity is already paused.");
+      }
+      currentActivity.pauseStartTime = Date.now();
+    },
+    resumeActivity: () => {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before resumeActivity().");
+      }
+      if (currentActivity.pauseStartTime === null) {
+        throw new Error("Activity is not paused.");
+      }
+      const pauseDuration = Date.now() - currentActivity.pauseStartTime;
+      currentActivity.pausedTime += pauseDuration;
+      currentActivity.pauseStartTime = null;
+    },
+    endActivity: async (data) => {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before endActivity().");
+      }
+      if (currentActivity.pauseStartTime !== null) {
+        const pauseDuration = Date.now() - currentActivity.pauseStartTime;
+        currentActivity.pausedTime += pauseDuration;
+        currentActivity.pauseStartTime = null;
+      }
+      const endTime = Date.now();
+      const totalElapsed = endTime - currentActivity.startTime;
+      const activeTime = totalElapsed - currentActivity.pausedTime;
+      const durationSeconds = Math.floor(activeTime / 1000);
+      const { correctQuestions, totalQuestions } = data;
+      const request2 = {
+        activityData: currentActivity.metadata,
+        scoreData: {
+          correctQuestions,
+          totalQuestions
+        },
+        timingData: {
+          durationSeconds
+        },
+        xpEarned: data.xpAwarded,
+        masteredUnits: data.masteredUnits
+      };
+      try {
+        const response = await client["requestGameBackend"](TIMEBACK_ROUTES.END_ACTIVITY, "POST", request2);
+        currentActivity = null;
+        return response;
+      } catch (error) {
+        currentActivity = null;
+        throw error;
+      }
+    }
+  };
+}
+// src/clients/public.ts
+class PlaycademyClient {
+  baseUrl;
+  gameUrl;
+  authStrategy;
+  gameId;
+  config;
+  listeners = {};
+  internalClientSessionId;
+  authContext;
+  initPayload;
+  connectionManager;
+  _sessionManager = {
+    startSession: async (gameId) => {
+      return this.request(`/games/${gameId}/sessions`, "POST");
+    },
+    endSession: async (sessionId, gameId) => {
+      return this.request(`/games/${gameId}/sessions/${sessionId}`, "DELETE");
+    }
+  };
+  constructor(config) {
+    this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
+    this.gameUrl = config?.gameUrl;
+    this.gameId = config?.gameId;
+    this.config = config || {};
+    this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
+    this._detectAuthContext();
+    this._initializeInternalSession().catch(() => {});
+    this._initializeConnectionMonitor();
+  }
+  getBaseUrl() {
+    const isRelative = this.baseUrl.startsWith("/");
+    const isBrowser2 = typeof window !== "undefined";
+    return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+  }
+  getGameBackendUrl() {
+    if (!this.gameUrl) {
+      throw new PlaycademyError("Game backend URL not configured. gameUrl must be set to use game backend features.");
+    }
+    const isRelative = this.gameUrl.startsWith("/");
+    const isBrowser2 = typeof window !== "undefined";
+    const effectiveGameUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.gameUrl}` : this.gameUrl;
+    return `${effectiveGameUrl}/api`;
+  }
+  ping() {
+    return "pong";
+  }
+  setToken(token, tokenType) {
+    this.authStrategy = createAuthStrategy(token, tokenType);
+    this.emit("authChange", { token });
+  }
+  getTokenType() {
+    return this.authStrategy.getType();
+  }
+  getToken() {
+    return this.authStrategy.getToken();
+  }
+  isAuthenticated() {
+    return this.authStrategy.getToken() !== null;
+  }
+  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;
+  }
+  on(event, callback) {
+    this.listeners[event] = this.listeners[event] ?? [];
+    this.listeners[event].push(callback);
+  }
+  emit(event, payload) {
+    (this.listeners[event] ?? []).forEach((listener) => {
+      listener(payload);
+    });
+  }
+  async request(path, method, options) {
+    const effectiveHeaders = {
+      ...options?.headers,
+      ...this.authStrategy.getHeaders()
+    };
+    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()
+    };
+    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) {
+      throw new PlaycademyError("This operation requires a gameId, but none was provided when initializing the client.");
+    }
+    return this.gameId;
+  }
+  _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;
+    const shouldAutoStart = this.config.autoStartSession ?? true;
+    if (!shouldAutoStart)
+      return;
+    try {
+      const response = await this._sessionManager.startSession(this.gameId);
+      this.internalClientSessionId = response.sessionId;
+      log.debug("[Playcademy SDK] Auto-started game session", {
+        gameId: this.gameId,
+        sessionId: this.internalClientSessionId
+      });
+    } catch (error) {
+      log.error("[Playcademy SDK] Auto-starting session failed for game", {
+        gameId: this.gameId,
+        error
+      });
+    }
+  }
+  identity = createIdentityNamespace(this);
+  runtime = createRuntimeNamespace(this);
+  users = createUsersNamespace(this);
+  timeback = createTimebackNamespace2(this);
+  credits = createCreditsNamespace(this);
+  scores = createScoresNamespace(this);
+  realtime = createRealtimeNamespace(this);
+  backend = createBackendNamespace(this);
+  static init = init;
+  static login = login;
+  static identity = identity;
+}
+
+// src/clients/internal.ts
+class PlaycademyInternalClient extends PlaycademyClient {
+  auth = createAuthNamespace(this);
+  admin = createAdminNamespace(this);
+  dev = createDevNamespace(this);
+  games = createGamesNamespace(this);
+  character = createCharacterNamespace(this);
+  achievements = createAchievementsNamespace(this);
+  leaderboard = createLeaderboardNamespace(this);
+  levels = createLevelsNamespace(this);
+  shop = createShopNamespace(this);
+  notifications = createNotificationsNamespace(this);
+  maps = createMapsNamespace(this);
+  sprites = createSpritesNamespace(this);
+  telemetry = createTelemetryNamespace(this);
+  scores = createScoresNamespace2(this);
+  timeback = createTimebackNamespace(this);
+}
+export {
+  messaging,
+  extractApiErrorInfo,
+  PlaycademyInternalClient,
+  PlaycademyError,
+  PlaycademyInternalClient as PlaycademyClient,
+  MessageEvents,
+  ConnectionMonitor,
+  ConnectionManager,
+  ApiError
+};