@playcademy/sdk 0.3.1 → 0.3.3

package/dist/internal.js

@@ -32,15 +32,15 @@ class PlaycademyMessaging {
     }
   }
   listen(type, handler) {
-    const postMessageListener = (event) => {
+    function postMessageListener(event) {
       const messageEvent = event;
       if (messageEvent.data?.type === type) {
         handler(messageEvent.data.payload || messageEvent.data);
       }
-    };
-    const customEventListener = (event) => {
+    }
+    function customEventListener(event) {
       handler(event.detail);
-    };
+    }
     if (!this.listeners.has(type)) {
       this.listeners.set(type, new Map);
     }
@@ -50,7 +50,7 @@ class PlaycademyMessaging {
       customEvent: customEventListener
     });
     window.addEventListener("message", postMessageListener);
-    window.addEventListener(type, customEventListener);
+    globalThis.addEventListener(type, customEventListener);
   }
   unlisten(type, handler) {
     const typeListeners = this.listeners.get(type);
@@ -59,14 +59,14 @@ class PlaycademyMessaging {
     }
     const listeners = typeListeners.get(handler);
     window.removeEventListener("message", listeners.postMessage);
-    window.removeEventListener(type, listeners.customEvent);
+    globalThis.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 isIframe = typeof globalThis.window !== "undefined" && globalThis.self !== window.top;
     const iframeToParentEvents = [
       "PLAYCADEMY_READY" /* READY */,
       "PLAYCADEMY_EXIT" /* EXIT */,
@@ -89,18 +89,18 @@ class PlaycademyMessaging {
     target.postMessage(messageData, origin);
   }
   sendViaCustomEvent(type, payload) {
-    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+    globalThis.dispatchEvent(new CustomEvent(type, { detail: payload }));
   }
 }
 var messaging = new PlaycademyMessaging;
 
 // src/core/static/init.ts
 async function getPlaycademyConfig(allowedParentOrigins) {
-  const preloaded = window.PLAYCADEMY;
+  const preloaded = globalThis.PLAYCADEMY;
   if (preloaded?.token) {
     return preloaded;
   }
-  if (window.self !== window.top) {
+  if (globalThis.self !== window.top) {
     return await waitForPlaycademyInit(allowedParentOrigins);
   } else {
     return createStandaloneConfig();
@@ -114,13 +114,14 @@ function getReferrerOrigin() {
   }
 }
 function buildAllowedOrigins(explicit) {
-  if (Array.isArray(explicit) && explicit.length > 0)
+  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") {
+  if (globalThis.location.hostname === "localhost" || globalThis.location.hostname === "127.0.0.1") {
     return true;
   }
   if (!allowlist || allowlist.length === 0) {
@@ -136,14 +137,16 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
     const allowlist = buildAllowedOrigins(allowedParentOrigins);
     let hasWarnedAboutUntrustedOrigin = false;
     function warnAboutUntrustedOrigin(origin) {
-      if (hasWarnedAboutUntrustedOrigin)
+      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 */)
+    function handleMessage(event) {
+      if (event.data?.type !== "PLAYCADEMY_INIT" /* INIT */) {
         return;
+      }
       if (!isOriginAllowed(event.origin, allowlist)) {
         warnAboutUntrustedOrigin(event.origin);
         return;
@@ -151,9 +154,9 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
       contextReceived = true;
       window.removeEventListener("message", handleMessage);
       clearTimeout(timeoutId);
-      window.PLAYCADEMY = event.data.payload;
+      globalThis.PLAYCADEMY = event.data.payload;
       resolve(event.data.payload);
-    };
+    }
     window.addEventListener("message", handleMessage);
     const timeoutId = setTimeout(() => {
       if (!contextReceived) {
@@ -167,16 +170,16 @@ 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,
+    gameUrl: globalThis.location.origin,
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
     realtimeUrl: undefined
   };
-  window.PLAYCADEMY = mockConfig;
+  globalThis.PLAYCADEMY = mockConfig;
   return mockConfig;
 }
 async function init(options) {
-  if (typeof window === "undefined") {
+  if (typeof globalThis.window === "undefined") {
     throw new Error("Playcademy SDK must run in a browser context");
   }
   const config = await getPlaycademyConfig(options?.allowedParentOrigins);
@@ -188,7 +191,7 @@ async function init(options) {
     gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
-    autoStartSession: window.self !== window.top,
+    autoStartSession: globalThis.self !== window.top,
     onDisconnect: options?.onDisconnect,
     enableConnectionMonitoring: options?.enableConnectionMonitoring
   });
@@ -198,23 +201,23 @@ async function init(options) {
   return client;
 }
 // ../logger/src/index.ts
-var isBrowser = () => {
+function isBrowser() {
   const g = globalThis;
   return typeof g.window !== "undefined" && typeof g.document !== "undefined";
-};
-var isProduction = () => {
+}
+function isProduction() {
   return typeof process !== "undefined" && false;
-};
-var isDevelopment = () => {
+}
+function isDevelopment() {
   return typeof process !== "undefined" && true;
-};
-var isInteractiveTTY = () => {
+}
+function isInteractiveTTY() {
   return typeof process !== "undefined" && Boolean(process.stdout && process.stdout.isTTY);
-};
-var isSilent = () => {
+}
+function isSilent() {
   return typeof process !== "undefined" && process.env.LOG_SILENT === "true";
-};
-var detectOutputFormat = () => {
+}
+function detectOutputFormat() {
   if (isBrowser()) {
     return "browser";
   }
@@ -238,7 +241,7 @@ var detectOutputFormat = () => {
     return "color-tty";
   }
   return "json-single-line";
-};
+}
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -249,21 +252,26 @@ var colors = {
   cyan: "\x1B[36m",
   gray: "\x1B[90m"
 };
-var getLevelColor = (level) => {
+function getLevelColor(level) {
   switch (level) {
-    case "debug":
+    case "debug": {
       return colors.blue;
-    case "info":
+    }
+    case "info": {
       return colors.cyan;
-    case "warn":
+    }
+    case "warn": {
       return colors.yellow;
-    case "error":
+    }
+    case "error": {
       return colors.red;
-    default:
+    }
+    default: {
       return colors.reset;
+    }
   }
-};
-var formatBrowserOutput = (level, message, context, scope) => {
+}
+function formatBrowserOutput(level, message, context, scope) {
   const timestamp = new Date().toISOString();
   const levelUpper = level.toUpperCase();
   const consoleMethod = getConsoleMethod(level);
@@ -273,8 +281,8 @@ var formatBrowserOutput = (level, message, context, scope) => {
   } else {
     consoleMethod(`[${timestamp}] ${levelUpper}`, `${scopePrefix}${message}`);
   }
-};
-var formatColorTTY = (level, message, context, scope) => {
+}
+function formatColorTTY(level, message, context, scope) {
   const timestamp = new Date().toISOString();
   const levelColor = getLevelColor(level);
   const levelUpper = level.toUpperCase().padEnd(5);
@@ -286,8 +294,8 @@ var formatColorTTY = (level, message, context, scope) => {
   } else {
     consoleMethod(`${coloredPrefix} ${scopePrefix}${message}`);
   }
-};
-var formatJSONSingleLine = (level, message, context, scope) => {
+}
+function formatJSONSingleLine(level, message, context, scope) {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
@@ -298,8 +306,8 @@ var formatJSONSingleLine = (level, message, context, scope) => {
   };
   const consoleMethod = getConsoleMethod(level);
   consoleMethod(JSON.stringify(logEntry));
-};
-var formatJSONPretty = (level, message, context, scope) => {
+}
+function formatJSONPretty(level, message, context, scope) {
   const timestamp = new Date().toISOString();
   const logEntry = {
     timestamp,
@@ -310,65 +318,76 @@ var formatJSONPretty = (level, message, context, scope) => {
   };
   const consoleMethod = getConsoleMethod(level);
   consoleMethod(JSON.stringify(logEntry, null, 2));
-};
-var getConsoleMethod = (level) => {
+}
+function getConsoleMethod(level) {
   switch (level) {
-    case "debug":
+    case "debug": {
       return console.debug;
-    case "info":
+    }
+    case "info": {
       return console.info;
-    case "warn":
+    }
+    case "warn": {
       return console.warn;
-    case "error":
+    }
+    case "error": {
       return console.error;
-    default:
+    }
+    default: {
       return console.log;
+    }
   }
-};
+}
 var levelPriority = {
   debug: 0,
   info: 1,
   warn: 2,
   error: 3
 };
-var getMinimumLogLevel = () => {
+function 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())
+}
+function shouldLog(level) {
+  if (isSilent()) {
     return false;
+  }
   const minLevel = getMinimumLogLevel();
   return levelPriority[level] >= levelPriority[minLevel];
-};
+}
 var customHandler;
-var performLog = (level, message, context, scope) => {
-  if (!shouldLog(level))
+function performLog(level, message, context, scope) {
+  if (!shouldLog(level)) {
     return;
+  }
   if (customHandler) {
     customHandler(level, message, context, scope);
     return;
   }
   const outputFormat = detectOutputFormat();
   switch (outputFormat) {
-    case "browser":
+    case "browser": {
       formatBrowserOutput(level, message, context, scope);
       break;
-    case "color-tty":
+    }
+    case "color-tty": {
       formatColorTTY(level, message, context, scope);
       break;
-    case "json-single-line":
+    }
+    case "json-single-line": {
       formatJSONSingleLine(level, message, context, scope);
       break;
-    case "json-pretty":
+    }
+    case "json-pretty": {
       formatJSONPretty(level, message, context, scope);
       break;
+    }
   }
-};
-var createLogger = (scopeName) => {
+}
+function createLogger(scopeName) {
   return {
     debug: (message, context) => performLog("debug", message, context, scopeName),
     info: (message, context) => performLog("info", message, context, scopeName),
@@ -377,7 +396,7 @@ var createLogger = (scopeName) => {
     log: (level, message, context) => performLog(level, message, context, scopeName),
     scope: (name) => createLogger(scopeName ? `${scopeName}.${name}` : name)
   };
-};
+}
 var log = createLogger();
 
 // src/core/errors.ts
@@ -388,15 +407,25 @@ class PlaycademyError extends Error {
   }
 }
 
+class ManifestError extends PlaycademyError {
+  kind;
+  constructor(message, kind) {
+    super(message);
+    this.name = "ManifestError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, ManifestError.prototype);
+  }
+}
+
 class ApiError extends Error {
-  status;
   code;
   details;
   rawBody;
+  status;
   constructor(status, code, message, details, rawBody) {
     super(message);
-    this.status = status;
     this.name = "ApiError";
+    this.status = status;
     this.code = code;
     this.details = details;
     this.rawBody = rawBody;
@@ -427,38 +456,54 @@ class ApiError extends Error {
 }
 function statusCodeToErrorCode(status) {
   switch (status) {
-    case 400:
+    case 400: {
       return "BAD_REQUEST";
-    case 401:
+    }
+    case 401: {
       return "UNAUTHORIZED";
-    case 403:
+    }
+    case 403: {
       return "FORBIDDEN";
-    case 404:
+    }
+    case 404: {
       return "NOT_FOUND";
-    case 405:
+    }
+    case 405: {
       return "METHOD_NOT_ALLOWED";
-    case 409:
+    }
+    case 409: {
       return "CONFLICT";
-    case 410:
+    }
+    case 410: {
       return "GONE";
-    case 412:
+    }
+    case 412: {
       return "PRECONDITION_FAILED";
-    case 413:
+    }
+    case 413: {
       return "PAYLOAD_TOO_LARGE";
-    case 422:
+    }
+    case 422: {
       return "VALIDATION_FAILED";
-    case 429:
+    }
+    case 429: {
       return "TOO_MANY_REQUESTS";
-    case 500:
+    }
+    case 500: {
       return "INTERNAL_ERROR";
-    case 501:
+    }
+    case 501: {
       return "NOT_IMPLEMENTED";
-    case 503:
+    }
+    case 503: {
       return "SERVICE_UNAVAILABLE";
-    case 504:
+    }
+    case 504: {
       return "TIMEOUT";
-    default:
+    }
+    default: {
       return status >= 500 ? "INTERNAL_ERROR" : "BAD_REQUEST";
+    }
   }
 }
 function extractApiErrorInfo(error) {
@@ -476,10 +521,10 @@ function extractApiErrorInfo(error) {
 // 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;
+  if (baseUrl.startsWith("/") && typeof globalThis.window !== "undefined") {
+    url = globalThis.location.origin + baseUrl;
   }
-  url = url + "/auth/login";
+  url += "/auth/login";
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -490,7 +535,7 @@ async function login(baseUrl, email, password) {
   if (!response.ok) {
     try {
       const errorData = await response.json();
-      const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
+      const errorMessage = errorData && errorData.message !== undefined ? 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 });
@@ -504,7 +549,7 @@ 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("");
+  return [...randomValues].map((byte) => charset[byte % charset.length]).join("");
 }
 
 // src/core/auth/oauth.ts
@@ -546,8 +591,9 @@ function parseOAuthState(state) {
 }
 function getOAuthConfig(provider) {
   const configGetter = OAUTH_CONFIGS[provider];
-  if (!configGetter)
+  if (!configGetter) {
     throw new Error(`Unsupported auth provider: ${provider}`);
+  }
   return configGetter();
 }
 
@@ -574,11 +620,11 @@ function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
   return window.open(url, name, features);
 }
 function isInIframe() {
-  if (typeof window === "undefined") {
+  if (typeof globalThis.window === "undefined") {
     return false;
   }
   try {
-    return window.self !== window.top;
+    return globalThis.self !== window.top;
   } catch {
     return true;
   }
@@ -631,9 +677,10 @@ async function initiatePopupFlow(options) {
 async function waitForServerMessage(popup, onStateChange) {
   return new Promise((resolve) => {
     let resolved = false;
-    const handleMessage = (event) => {
-      if (event.origin !== window.location.origin)
+    function handleMessage(event) {
+      if (event.origin !== globalThis.location.origin) {
         return;
+      }
       const data = event.data;
       if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
         resolved = true;
@@ -660,7 +707,7 @@ async function waitForServerMessage(popup, onStateChange) {
           });
         }
       }
-    };
+    }
     window.addEventListener("message", handleMessage);
     const checkClosed = setInterval(() => {
       if (popup.closed && !resolved) {
@@ -722,7 +769,7 @@ async function initiateRedirectFlow(options) {
       params.set("scope", config.scope);
     }
     const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
-    window.location.href = authUrl;
+    globalThis.location.href = authUrl;
     return new Promise(() => {});
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Authentication failed";
@@ -738,14 +785,22 @@ async function initiateRedirectFlow(options) {
 // src/core/auth/flows/unified.ts
 async function initiateUnifiedFlow(options) {
   const { mode = "auto" } = options;
-  const effectiveMode = mode === "auto" ? isInIframe() ? "popup" : "redirect" : mode;
+  let effectiveMode;
+  if (mode === "auto") {
+    effectiveMode = isInIframe() ? "popup" : "redirect";
+  } else {
+    effectiveMode = mode;
+  }
   switch (effectiveMode) {
-    case "popup":
+    case "popup": {
       return initiatePopupFlow(options);
-    case "redirect":
+    }
+    case "redirect": {
       return initiateRedirectFlow(options);
-    default:
+    }
+    default: {
       throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
+    }
   }
 }
 
@@ -767,7 +822,7 @@ async function login2(client, options) {
       provider: options.provider,
       mode: options.mode || "auto",
       callbackUrl: options.callbackUrl,
-      hasStateData: !!stateData
+      hasStateData: Boolean(stateData)
     });
     const optionsWithState = {
       ...options,
@@ -802,13 +857,13 @@ function createIdentityNamespace(client) {
 // src/namespaces/game/runtime.ts
 function createRuntimeNamespace(client) {
   const eventListeners = new Map;
-  const trackListener = (eventType, handler) => {
+  function trackListener(eventType, handler) {
     if (!eventListeners.has(eventType)) {
       eventListeners.set(eventType, new Set);
     }
     eventListeners.get(eventType).add(handler);
-  };
-  const untrackListener = (eventType, handler) => {
+  }
+  function untrackListener(eventType, handler) {
     const listeners = eventListeners.get(eventType);
     if (listeners) {
       listeners.delete(handler);
@@ -816,12 +871,9 @@ function createRuntimeNamespace(client) {
         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 (typeof globalThis.window !== "undefined" && globalThis.self !== window.top) {
+    let keyListener = function(event) {
       if (keySet.has(event.key?.toLowerCase() ?? "") || keySet.has(event.code?.toLowerCase() ?? "")) {
         messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
           key: event.key,
@@ -830,11 +882,14 @@ function createRuntimeNamespace(client) {
         });
       }
     };
-    window.addEventListener("keydown", keyListener);
-    window.addEventListener("keyup", keyListener);
+    const playcademyConfig = globalThis.PLAYCADEMY;
+    const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
+    const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
+    globalThis.addEventListener("keydown", keyListener);
+    globalThis.addEventListener("keyup", keyListener);
     trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, () => {
-      window.removeEventListener("keydown", keyListener);
-      window.removeEventListener("keyup", keyListener);
+      globalThis.removeEventListener("keydown", keyListener);
+      globalThis.removeEventListener("keyup", keyListener);
     });
   }
   return {
@@ -911,32 +966,30 @@ function createRuntimeNamespace(client) {
   };
 }
 function createAssetsNamespace(client) {
-  const fetchAsset = async (path, options) => {
+  async function fetchAsset(path, options) {
     const gameUrl = client["initPayload"]?.gameUrl;
     if (!gameUrl) {
-      const relativePath = path.startsWith("./") ? path : "./" + path;
+      const relativePath = path.startsWith("./") ? path : `./${path}`;
       return fetch(relativePath, options);
     }
     const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-    return fetch(gameUrl + cleanPath, options);
-  };
+    return fetch(`${gameUrl}${cleanPath}`, options);
+  }
   return {
     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]) : "");
-        }, "");
+        path = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
       } else {
         path = pathOrStrings;
       }
       if (!gameUrl) {
-        return path.startsWith("./") ? path : "./" + path;
+        return path.startsWith("./") ? path : `./${path}`;
       }
       const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-      return gameUrl + cleanPath;
+      return `${gameUrl}${cleanPath}`;
     },
     fetch: fetchAsset,
     json: async (path) => {
@@ -958,10 +1011,10 @@ function createAssetsNamespace(client) {
   };
 }
 // src/namespaces/game/backend.ts
+function normalizePath(path) {
+  return path.startsWith("/") ? path : `/${path}`;
+}
 function createBackendNamespace(client) {
-  function normalizePath(path) {
-    return path.startsWith("/") ? path : `/${path}`;
-  }
   return {
     async get(path, headers) {
       return client["requestGameBackend"](normalizePath(path), "GET", undefined, headers);
@@ -987,9 +1040,7 @@ function createBackendNamespace(client) {
     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]) : "");
-        }, "");
+        const path2 = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
         return `${client.gameUrl}/api${path2.startsWith("/") ? path2 : `/${path2}`}`;
       }
       const path = pathOrStrings;
@@ -1003,8 +1054,9 @@ function createPermanentCache(keyPrefix) {
   async function get(key, loader) {
     const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
     const existing = cache.get(fullKey);
-    if (existing)
+    if (existing) {
       return existing;
+    }
     const promise = loader().catch((error) => {
       cache.delete(fullKey);
       throw error;
@@ -1042,23 +1094,23 @@ function createPermanentCache(keyPrefix) {
 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))
+  async function resolveItemId(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)
+      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");
-    },
+    me: async () => client["request"]("/users/me", "GET"),
     inventory: {
       get: async () => client["request"](`/inventory`, "GET"),
       add: async (identifier, qty) => {
@@ -1185,8 +1237,15 @@ var ACHIEVEMENT_DEFINITIONS = [
   }
 ];
 // ../constants/src/typescript.ts
-var TSC_PACKAGE = "typescript";
-var USE_NATIVE_TSC = TSC_PACKAGE.includes("native-preview");
+var TypeScriptPackages = {
+  tsc: "tsc",
+  nativePreview: "@typescript/native-preview",
+  nativePreviewPinned: "@typescript/native-preview@7.0.0-dev.20260221.1"
+};
+var TYPESCRIPT_RUNNER = {
+  package: TypeScriptPackages.nativePreviewPinned,
+  bin: "tsgo"
+};
 // ../constants/src/overworld.ts
 var ITEM_SLUGS = {
   PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
@@ -1241,7 +1300,7 @@ function createSingletonCache() {
 // src/namespaces/game/credits.ts
 function createCreditsNamespace(client) {
   const creditsIdCache = createSingletonCache();
-  const getCreditsItemId = async () => {
+  async function getCreditsItemId() {
     return creditsIdCache.get(async () => {
       const queryParams = new URLSearchParams({ slug: CURRENCIES.PRIMARY });
       const creditsItem = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
@@ -1250,7 +1309,7 @@ function createCreditsNamespace(client) {
       }
       return creditsItem.id;
     });
-  };
+  }
   return {
     balance: async () => {
       const inventory = await client["request"]("/inventory", "GET");
@@ -1298,14 +1357,12 @@ function createCreditsNamespace(client) {
 // src/namespaces/game/scores.ts
 function createScoresNamespace(client) {
   return {
-    submit: async (gameId, score, metadata) => {
-      return client["request"](`/games/${gameId}/scores`, "POST", {
-        body: {
-          score,
-          metadata
-        }
-      });
-    }
+    submit: async (gameId, score, metadata) => client["request"](`/games/${gameId}/scores`, "POST", {
+      body: {
+        score,
+        metadata
+      }
+    })
   };
 }
 // src/namespaces/game/realtime.ts
@@ -1379,8 +1436,9 @@ function createTTLCache(options) {
   function has(key) {
     const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
     const cached = cache.get(fullKey);
-    if (!cached)
+    if (!cached) {
       return false;
+    }
     const now = Date.now();
     if (cached.expiresAt <= now) {
       cache.delete(fullKey);
@@ -1422,7 +1480,9 @@ function createTimebackNamespace(client) {
     ttl: 5000,
     keyPrefix: "game.timeback.xp"
   });
-  const getTimeback = () => client["initPayload"]?.timeback;
+  function getTimeback() {
+    return client["initPayload"]?.timeback;
+  }
   return {
     get user() {
       return {
@@ -1438,21 +1498,19 @@ function createTimebackNamespace(client) {
         get organizations() {
           return getTimeback()?.organizations ?? [];
         },
-        fetch: async (options) => {
-          return userCache.get("current", async () => {
-            const response = await client["request"]("/timeback/user", "GET");
-            const initPayload = client["initPayload"];
-            if (initPayload) {
-              initPayload.timeback = response;
-            }
-            return {
-              id: response.id,
-              role: response.role,
-              enrollments: response.enrollments,
-              organizations: response.organizations
-            };
-          }, options);
-        },
+        fetch: async (options) => userCache.get("current", async () => {
+          const response = await client["request"]("/timeback/user", "GET");
+          const initPayload = client["initPayload"];
+          if (initPayload) {
+            initPayload.timeback = response;
+          }
+          return {
+            id: response.id,
+            role: response.role,
+            enrollments: response.enrollments,
+            organizations: response.organizations
+          };
+        }, options),
         xp: {
           fetch: async (options) => {
             const hasGrade = options?.grade !== undefined;
@@ -1590,22 +1648,18 @@ function createAuthNamespace(client) {
       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"]
-            }
+      create: async (options) => 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");
-      },
+        }
+      }),
+      list: async () => client["request"]("/auth/api-key/list", "GET"),
       revoke: async (keyId) => {
         await client["request"]("/auth/api-key/revoke", "POST", {
           body: { id: keyId }
@@ -1648,19 +1702,139 @@ function createAdminNamespace(client) {
     }
   };
 }
-// src/namespaces/platform/dev.ts
-function createDevNamespace(client) {
-  const DEPLOY_JOB_POLL_INTERVAL_MS = 1000;
-  const DEPLOY_JOB_INACTIVITY_TIMEOUT_MS = 60 * 1000;
-  async function pollDeployJob(slug, jobId, hooks) {
+// src/core/deploy.ts
+class DeployPipeline {
+  static POLL_INTERVAL_MS = 1000;
+  static INACTIVITY_TIMEOUT_MS = 60 * 1000;
+  static GAME_FETCH_RETRIES = 3;
+  static MAX_INLINE_REQUEST_BYTES = 5.5 * 1024 * 1024;
+  static textEncoder = new TextEncoder;
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async uploadFile(file, gameId, hooks) {
+    const fileName = file instanceof File ? file.name : "game.zip";
+    const { presignedUrl, uploadToken } = await this.initiateUpload(fileName, gameId);
+    const contentType = file.type || "application/octet-stream";
+    if (hooks?.onEvent && typeof XMLHttpRequest !== "undefined") {
+      await this.uploadViaXHR(presignedUrl, file, contentType, hooks);
+    } else {
+      await this.uploadViaFetch(presignedUrl, file, contentType);
+    }
+    return uploadToken;
+  }
+  async submit(args) {
+    const { requestBody } = await this.buildRequestBody(args);
+    const { slug, hooks } = args;
+    const job = await this.client["request"](`/games/${slug}/deploy`, "POST", { body: requestBody });
+    const completedJob = await this.poll(slug, job.id, hooks);
+    if (!completedJob.result?.url) {
+      throw new Error("Deployment completed but no deployment URL was recorded");
+    }
+    return this.fetchGameWithRetry(slug);
+  }
+  async buildRequestBody(args) {
+    const game = await this.resolveGame(args.slug, args.game);
+    const requestBody = {};
+    if (args.uploadToken) {
+      requestBody.uploadToken = args.uploadToken;
+    }
+    if (args.metadata) {
+      requestBody.metadata = args.metadata;
+    }
+    if (!args.backend) {
+      return { game, requestBody };
+    }
+    const backendFields = {
+      config: args.backend.config,
+      ...args.backend.bindings ? { bindings: args.backend.bindings } : {},
+      ...args.backend.schema ? { schema: args.backend.schema } : {}
+    };
+    const inlineBody = {
+      ...requestBody,
+      ...backendFields,
+      code: args.backend.code
+    };
+    if (this.serializedSize(inlineBody) <= DeployPipeline.MAX_INLINE_REQUEST_BYTES) {
+      return { game, requestBody: inlineBody };
+    }
+    const skeletonBody = {
+      ...requestBody,
+      ...backendFields,
+      codeUploadToken: "________placeholder________"
+    };
+    if (this.serializedSize(skeletonBody) > DeployPipeline.MAX_INLINE_REQUEST_BYTES) {
+      throw new Error("Deploy request is too large even after uploading backend code");
+    }
+    skeletonBody.codeUploadToken = await this.uploadCode(game.id, args.backend.code);
+    return { game, requestBody: skeletonBody };
+  }
+  serializedSize(body) {
+    return DeployPipeline.textEncoder.encode(JSON.stringify(body)).length;
+  }
+  async initiateUpload(fileName, gameId) {
+    return this.client["request"]("/games/uploads/initiate/", "POST", { body: { fileName, gameId } });
+  }
+  async uploadCode(gameId, code) {
+    const { presignedUrl, uploadToken } = await this.initiateUpload("backend.js", gameId);
+    const res = await fetch(presignedUrl, {
+      method: "PUT",
+      body: code,
+      headers: { "Content-Type": "application/javascript" }
+    });
+    if (!res.ok) {
+      throw new Error(`Backend code upload failed: ${res.status} ${res.statusText}`);
+    }
+    return uploadToken;
+  }
+  async uploadViaFetch(url, body, contentType) {
+    const res = await fetch(url, {
+      method: "PUT",
+      body,
+      headers: { "Content-Type": contentType }
+    });
+    if (!res.ok) {
+      throw new Error(`File upload failed: ${res.status} ${res.statusText}`);
+    }
+  }
+  uploadViaXHR(url, body, contentType, hooks) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest;
+      xhr.open("PUT", url, true);
+      try {
+        xhr.setRequestHeader("Content-Type", contentType);
+      } catch {}
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          hooks.onEvent?.({
+            type: "s3Progress",
+            loaded: event.loaded,
+            total: event.total,
+            percent: event.loaded / event.total
+          });
+        }
+      });
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve();
+        } else {
+          reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
+        }
+      });
+      xhr.addEventListener("error", () => reject(new Error("File upload failed: network error")));
+      xhr.send(body);
+    });
+  }
+  async poll(slug, jobId, hooks) {
     hooks?.onEvent?.({ type: "finalizeStart" });
     let seenEvents = 0;
     let lastProgressAt = Date.now();
     while (true) {
-      if (Date.now() - lastProgressAt > DEPLOY_JOB_INACTIVITY_TIMEOUT_MS) {
+      if (Date.now() - lastProgressAt > DeployPipeline.INACTIVITY_TIMEOUT_MS) {
         throw new Error("Deployment job timed out after 1 minute without progress");
       }
-      const job = await client["request"](`/games/${slug}/deploy?jobId=${encodeURIComponent(jobId)}`, "GET");
+      const job = await this.client["request"](`/games/${slug}/deploy?jobId=${encodeURIComponent(jobId)}`, "GET");
       const newEvents = job.events.slice(seenEvents);
       seenEvents = job.events.length;
       if (newEvents.length > 0) {
@@ -1679,9 +1853,30 @@ function createDevNamespace(client) {
       if (job.status === "failed") {
         throw new ApiError(job.errorStatus ?? 500, job.errorCode ?? "INTERNAL_ERROR", job.error || "Deployment failed", job);
       }
-      await new Promise((resolve) => setTimeout(resolve, DEPLOY_JOB_POLL_INTERVAL_MS));
+      await new Promise((resolve) => setTimeout(resolve, DeployPipeline.POLL_INTERVAL_MS));
     }
   }
+  async resolveGame(slug, game) {
+    return game ?? await this.client["request"](`/games/${slug}`, "GET");
+  }
+  async fetchGameWithRetry(slug) {
+    const { GAME_FETCH_RETRIES } = DeployPipeline;
+    for (let attempt = 0;attempt < GAME_FETCH_RETRIES; attempt++) {
+      try {
+        return await this.client["request"](`/games/${slug}`, "GET");
+      } catch {
+        if (attempt < GAME_FETCH_RETRIES - 1) {
+          await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+        }
+      }
+    }
+    throw new Error(`Deploy succeeded but failed to fetch updated game after ${GAME_FETCH_RETRIES} attempts`);
+  }
+}
+
+// src/namespaces/platform/dev.ts
+function createDevNamespace(client) {
+  const deploy = new DeployPipeline(client);
   return {
     status: {
       apply: () => client["request"]("/dev/apply", "POST"),
@@ -1703,99 +1898,18 @@ function createDevNamespace(client) {
             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}`);
-            }
-          }
-        }
+        const uploadToken = file ? await deploy.uploadFile(file, game?.id || slug, hooks) : undefined;
         if (uploadToken || backend) {
-          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;
-          }
-          const job = await client["request"](`/games/${slug}/deploy`, "POST", {
-            body: requestBody
-          });
-          const completedJob = await pollDeployJob(slug, job.id, hooks);
-          if (!completedJob.result?.url) {
-            throw new Error("Deployment completed but no deployment URL was recorded");
-          }
-          for (let attempt = 0;attempt < 3; attempt++) {
-            try {
-              return await client["request"](`/games/${slug}`, "GET");
-            } catch {
-              if (attempt < 2) {
-                await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
-              }
-            }
-          }
-          throw new Error("Deploy succeeded but failed to fetch updated game after 3 attempts");
+          return deploy.submit({ slug, game, uploadToken, metadata, backend, hooks });
         }
         if (game) {
           return game;
         }
         throw new Error("No deployment actions specified (need metadata, file, or backend)");
       },
-      seed: async (slug, code, environment, secrets) => {
-        return client["request"](`/games/${slug}/seed`, "POST", {
-          body: { code, environment, secrets }
-        });
-      },
+      seed: async (slug, code, environment, secrets) => client["request"](`/games/${slug}/seed`, "POST", {
+        body: { code, environment, secrets }
+      }),
       upsert: async (slug, metadata) => client["request"](`/games/${slug}`, "PUT", { body: metadata }),
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE"),
       secrets: {
@@ -1812,11 +1926,9 @@ function createDevNamespace(client) {
         }
       },
       database: {
-        reset: async (slug, schema) => {
-          return client["request"](`/games/${slug}/database/reset`, "POST", {
-            body: { schema }
-          });
-        }
+        reset: async (slug, schema) => client["request"](`/games/${slug}/database/reset`, "POST", {
+          body: { schema }
+        })
       },
       bucket: {
         list: async (slug, prefix) => {
@@ -1868,9 +1980,7 @@ function createDevNamespace(client) {
           const result = await client["request"](`/games/${slug}/kv/${encodeURIComponent(key)}/metadata`, "GET");
           return result.metadata;
         },
-        stats: async (slug) => {
-          return client["request"](`/games/${slug}/kv/stats`, "GET");
-        },
+        stats: async (slug) => client["request"](`/games/${slug}/kv/stats`, "GET"),
         seed: async (slug, entries) => {
           const result = await client["request"](`/games/${slug}/kv/bulk`, "PUT", { body: { entries } });
           return result.count;
@@ -1881,11 +1991,9 @@ function createDevNamespace(client) {
         }
       },
       domains: {
-        add: async (slug, hostname) => {
-          return client["request"](`/games/${slug}/domains`, "POST", {
-            body: { hostname }
-          });
-        },
+        add: async (slug, hostname) => client["request"](`/games/${slug}/domains`, "POST", {
+          body: { hostname }
+        }),
         list: async (slug) => {
           const result = await client["request"](`/games/${slug}/domains`, "GET");
           return result.domains;
@@ -1899,9 +2007,7 @@ function createDevNamespace(client) {
         }
       },
       logs: {
-        getToken: async (slug, environment) => {
-          return client["request"](`/games/${slug}/logs/token`, "POST", { body: { environment } });
-        }
+        getToken: async (slug, environment) => client["request"](`/games/${slug}/logs/token`, "POST", { body: { environment } })
       }
     },
     items: {
@@ -1921,48 +2027,44 @@ function createDevNamespace(client) {
       },
       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");
-        }
+        create: (gameId, itemId, listingData) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "POST", { body: listingData }),
+        get: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "GET"),
+        update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "PATCH", { body: updates }),
+        delete: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "DELETE"),
+        list: (gameId) => client["request"](`/games/${gameId}/shop-listings`, "GET")
       }
     }
   };
 }
 // 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}`);
+var RETRY_DELAYS_MS = [500, 1500];
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var retryRuntime = { wait };
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+async function fetchWithRetry(url, init2) {
+  for (let attempt = 0;attempt <= RETRY_DELAYS_MS.length; attempt++) {
+    const retryDelayMs = RETRY_DELAYS_MS[attempt];
+    const canRetry = init2.method === "GET" && retryDelayMs !== undefined;
+    try {
+      const response = await fetch(url, init2);
+      if (canRetry && isRetryableStatus(response.status)) {
+        await retryRuntime.wait(retryDelayMs);
+      } else {
+        return response;
+      }
+    } catch (error) {
+      if (canRetry && error instanceof TypeError) {
+        await retryRuntime.wait(retryDelayMs);
+      } else {
+        throw error;
+      }
+    }
   }
+  throw new PlaycademyError("Request failed after exhausting retries");
 }
 function prepareRequestBody(body, headers) {
   if (body instanceof FormData) {
@@ -1983,6 +2085,33 @@ function prepareRequestBody(body, headers) {
   }
   return;
 }
+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}`);
+    }
+  }
+}
 async function request({
   path,
   baseUrl,
@@ -1994,7 +2123,7 @@ async function request({
   const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
   const headers = { ...extraHeaders };
   const payload = prepareRequestBody(body, headers);
-  const res = await fetch(url, {
+  const res = await fetchWithRetry(url, {
     method,
     headers,
     body: payload,
@@ -2010,18 +2139,20 @@ async function request({
     })) ?? undefined;
     throw ApiError.fromResponse(res.status, res.statusText, errorBody);
   }
-  if (res.status === 204)
+  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)
+    } catch (error) {
+      if (error instanceof SyntaxError) {
         return;
-      throw err;
+      }
+      throw error;
     }
   }
   const rawText = await res.text().catch(() => "");
@@ -2029,21 +2160,26 @@ async function request({
 }
 async function fetchManifest(deploymentUrl) {
   const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
+  let response;
+  try {
+    response = await fetchWithRetry(manifestUrl, { method: "GET" });
+  } catch (error) {
+    log.error(`[Playcademy SDK] Error fetching manifest from ${manifestUrl}:`, {
+      error
+    });
+    throw new ManifestError("Failed to load game manifest", "temporary");
+  }
+  if (!response.ok) {
+    log.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
+    throw new ManifestError(`Failed to fetch manifest: ${response.status} ${response.statusText}`, isRetryableStatus(response.status) ? "temporary" : "permanent");
+  }
   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}:`, {
+    log.error(`[Playcademy SDK] Error parsing manifest from ${manifestUrl}:`, {
       error
     });
-    throw new PlaycademyError("Failed to load or parse game manifest");
+    throw new ManifestError("Failed to parse game manifest", "permanent");
   }
 }
 
@@ -2069,12 +2205,8 @@ function createGamesNamespace(client) {
         return baseGameData;
       }, options);
     },
-    list: (options) => {
-      return gamesListCache.get("all", () => client["request"]("/games", "GET"), options);
-    },
-    getSubjects: () => {
-      return client["request"]("/games/subjects", "GET");
-    },
+    list: (options) => gamesListCache.get("all", () => client["request"]("/games", "GET"), options),
+    getSubjects: () => client["request"]("/games/subjects", "GET"),
     startSession: async (gameId) => {
       const idToUse = gameId ?? client["_ensureGameId"]();
       return client["request"](`/games/${idToUse}/sessions`, "POST", {});
@@ -2098,10 +2230,12 @@ function createGamesNamespace(client) {
     leaderboard: {
       get: async (gameId, options) => {
         const params = new URLSearchParams;
-        if (options?.limit)
+        if (options?.limit) {
           params.append("limit", String(options.limit));
-        if (options?.offset)
+        }
+        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");
@@ -2129,14 +2263,10 @@ function createCharacterNamespace(client) {
         throw error;
       }
     },
-    create: async (characterData) => {
-      return client["request"]("/character", "POST", {
-        body: characterData
-      });
-    },
-    update: async (updates) => {
-      return client["request"]("/character", "PATCH", { body: updates });
-    },
+    create: async (characterData) => client["request"]("/character", "POST", {
+      body: characterData
+    }),
+    update: async (updates) => client["request"]("/character", "PATCH", { body: updates }),
     components: {
       list: async (options) => {
         const cacheKey = options?.level === undefined ? "all" : String(options.level);
@@ -2150,12 +2280,8 @@ function createCharacterNamespace(client) {
       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");
-      },
+      equip: async (slot, componentId) => client["request"]("/character/accessories/equip", "POST", { body: { slot, accessoryComponentId: componentId } }),
+      remove: async (slot) => client["request"](`/character/accessories/${slot}`, "DELETE"),
       list: async () => {
         const character2 = await client.character.get();
         return character2?.accessories || [];
@@ -2174,14 +2300,13 @@ function createAchievementsNamespace(client) {
     keyPrefix: "achievements.history"
   });
   return {
-    list: (options) => {
-      return achievementsListCache.get("current", () => client["request"]("/achievements/current", "GET"), options);
-    },
+    list: (options) => achievementsListCache.get("current", () => client["request"]("/achievements/current", "GET"), options),
     history: {
       list: async (queryOptions, cacheOptions) => {
         const params = new URLSearchParams;
-        if (queryOptions?.limit)
+        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";
@@ -2209,9 +2334,7 @@ function createLeaderboardNamespace(client) {
       }
       return client["request"](`/leaderboard?${params}`, "GET");
     },
-    getUserRank: async (gameId, userId) => {
-      return client["request"](`/games/${gameId}/users/${userId}/rank`, "GET");
-    }
+    getUserRank: async (gameId, userId) => client["request"](`/games/${gameId}/users/${userId}/rank`, "GET")
   };
 }
 // src/core/cache/cooldown-cache.ts
@@ -2265,28 +2388,18 @@ function createCooldownCache(defaultCooldownMs) {
 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);
-    },
+    get: async () => client["request"]("/users/level", "GET"),
+    progress: async (options) => 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");
-      }
+      list: async () => client["request"]("/levels/config", "GET"),
+      get: async (level) => client["request"](`/levels/config/${level}`, "GET")
     }
   };
 }
 // src/namespaces/platform/shop.ts
 function createShopNamespace(client) {
   return {
-    view: () => {
-      return client["request"]("/shop/view", "GET");
-    }
+    view: () => client["request"]("/shop/view", "GET")
   };
 }
 // src/namespaces/platform/notifications.ts
@@ -2302,14 +2415,18 @@ function createNotificationsNamespace(client) {
   return {
     list: async (queryOptions, cacheOptions) => {
       const params = new URLSearchParams;
-      if (queryOptions?.status)
+      if (queryOptions?.status) {
         params.append("status", queryOptions.status);
-      if (queryOptions?.type)
+      }
+      if (queryOptions?.type) {
         params.append("type", queryOptions.type);
-      if (queryOptions?.limit)
+      }
+      if (queryOptions?.limit) {
         params.append("limit", String(queryOptions.limit));
-      if (queryOptions?.offset)
+      }
+      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";
@@ -2365,10 +2482,12 @@ function createNotificationsNamespace(client) {
       get: async (queryOptions, cacheOptions) => {
         const user = await client.users.me();
         const params = new URLSearchParams;
-        if (queryOptions?.from)
+        if (queryOptions?.from) {
           params.append("from", queryOptions.from);
-        if (queryOptions?.to)
+        }
+        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";
@@ -2405,11 +2524,10 @@ function createSpritesNamespace(client) {
   return {
     templates: {
       get: async (slug) => {
-        if (!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");
-        });
+        }
+        const templateMeta = await templateUrlCache.get(slug, async () => client["request"](`/sprites/templates/${slug}`, "GET"));
         if (!templateMeta.url) {
           throw new Error(`Template ${slug} has no URL in database`);
         }
@@ -2459,7 +2577,9 @@ function createTimebackNamespace2(client) {
     ttl: 30 * 1000,
     keyPrefix: "platform.timeback.students"
   });
-  const getTimeback = () => client["initPayload"]?.timeback;
+  function getTimeback() {
+    return client["initPayload"]?.timeback;
+  }
   return {
     get user() {
       return {
@@ -2475,26 +2595,22 @@ function createTimebackNamespace2(client) {
         get organizations() {
           return getTimeback()?.organizations ?? [];
         },
-        fetch: async (options) => {
-          return userCache.get("current", async () => {
-            const response = await client["request"]("/timeback/user", "GET");
-            const initPayload = client["initPayload"];
-            if (initPayload) {
-              initPayload.timeback = response;
-            }
-            return {
-              id: response.id,
-              role: response.role,
-              enrollments: response.enrollments,
-              organizations: response.organizations
-            };
-          }, options);
-        }
+        fetch: async (options) => userCache.get("current", async () => {
+          const response = await client["request"]("/timeback/user", "GET");
+          const initPayload = client["initPayload"];
+          if (initPayload) {
+            initPayload.timeback = response;
+          }
+          return {
+            id: response.id,
+            role: response.role,
+            enrollments: response.enrollments,
+            organizations: response.organizations
+          };
+        }, options)
       };
     },
-    populateStudent: async (names) => {
-      return client["request"]("/timeback/populate-student", "POST", names ? { body: names } : undefined);
-    },
+    populateStudent: async (names) => client["request"]("/timeback/populate-student", "POST", names ? { body: names } : undefined),
     startActivity: (_metadata) => {
       throw new Error(NOT_SUPPORTED);
     },
@@ -2508,44 +2624,36 @@ function createTimebackNamespace2(client) {
       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");
-      }
+      setup: (request2) => client["request"]("/timeback/setup", "POST", {
+        body: request2
+      }),
+      verify: (gameId) => client["request"](`/timeback/verify/${gameId}`, "GET"),
+      cleanup: (gameId) => client["request"](`/timeback/integrations/${gameId}`, "DELETE"),
+      get: (gameId) => client["request"](`/timeback/integrations/${gameId}`, "GET"),
+      getConfig: (gameId) => client["request"](`/timeback/config/${gameId}`, "GET")
     },
     xp: {
       today: async (options) => {
         const params = new URLSearchParams;
-        if (options?.date)
+        if (options?.date) {
           params.set("date", options.date);
-        if (options?.timezone)
+        }
+        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");
-      },
+      total: async () => client["request"]("/timeback/xp/total", "GET"),
       history: async (options) => {
         const params = new URLSearchParams;
-        if (options?.startDate)
+        if (options?.startDate) {
           params.set("startDate", options.startDate);
-        if (options?.endDate)
+        }
+        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");
@@ -2554,10 +2662,12 @@ function createTimebackNamespace2(client) {
         const [today, total] = await Promise.all([
           client["request"]((() => {
             const params = new URLSearchParams;
-            if (options?.date)
+            if (options?.date) {
               params.set("date", options.date);
-            if (options?.timezone)
+            }
+            if (options?.timezone) {
               params.set("tz", options.timezone);
+            }
             const query = params.toString();
             return query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
           })(), "GET"),
@@ -2567,11 +2677,7 @@ function createTimebackNamespace2(client) {
       }
     },
     students: {
-      get: async (timebackId, options) => {
-        return studentCache.get(timebackId, async () => {
-          return client["request"](`/timeback/user/${timebackId}`, "GET");
-        }, options);
-      },
+      get: async (timebackId, options) => studentCache.get(timebackId, async () => client["request"](`/timeback/user/${timebackId}`, "GET"), options),
       clearCache: (timebackId) => {
         studentCache.clear(timebackId);
       }
@@ -2677,24 +2783,26 @@ class ConnectionMonitor {
     this._detectInitialState();
   }
   start() {
-    if (this.isMonitoring)
+    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.enableOfflineEvents && typeof globalThis.window !== "undefined") {
+      globalThis.addEventListener("online", this._handleOnline);
+      globalThis.addEventListener("offline", this._handleOffline);
     }
     if (this.config.enableHeartbeat) {
       this._startHeartbeat();
     }
   }
   stop() {
-    if (!this.isMonitoring)
+    if (!this.isMonitoring) {
       return;
+    }
     this.isMonitoring = false;
-    if (typeof window !== "undefined") {
-      window.removeEventListener("online", this._handleOnline);
-      window.removeEventListener("offline", this._handleOffline);
+    if (typeof globalThis.window !== "undefined") {
+      globalThis.removeEventListener("online", this._handleOnline);
+      globalThis.removeEventListener("offline", this._handleOffline);
     }
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
@@ -2714,8 +2822,9 @@ class ConnectionMonitor {
   }
   reportRequestFailure(error) {
     const isNetworkError = error instanceof TypeError || error instanceof Error && error.message.includes("fetch");
-    if (!isNetworkError)
+    if (!isNetworkError) {
       return;
+    }
     this.consecutiveFailures++;
     if (this.consecutiveFailures >= this.config.failureThreshold) {
       this._setState("degraded", "Multiple consecutive request failures");
@@ -2783,8 +2892,9 @@ class ConnectionMonitor {
     }
   }
   _setState(newState, reason) {
-    if (this.state === newState)
+    if (this.state === newState) {
       return;
+    }
     const oldState = this.state;
     this.state = newState;
     console.debug(`[ConnectionMonitor] ${oldState} → ${newState}: ${reason}`);
@@ -2800,14 +2910,15 @@ class ConnectionMonitor {
 // src/core/connection/utils.ts
 function createDisplayAlert(authContext) {
   return (message, options) => {
-    if (authContext?.isInIframe && typeof window !== "undefined" && window.parent !== window) {
+    if (authContext?.isInIframe && typeof globalThis.window !== "undefined" && globalThis.window.parent !== globalThis.window) {
       window.parent.postMessage({
         type: "PLAYCADEMY_DISPLAY_ALERT",
         message,
         options
       }, "*");
     } else {
-      const prefix = options?.type === "error" ? "❌" : options?.type === "warning" ? "⚠️" : "ℹ️";
+      const prefixMap = { error: "❌", warning: "⚠️", info: "ℹ️" };
+      const prefix = (options?.type && prefixMap[options.type]) ?? "ℹ️";
       console.log(`${prefix} ${message}`);
     }
   };
@@ -2889,18 +3000,16 @@ class PlaycademyBaseClient {
   authContext;
   initPayload;
   connectionManager;
+  launchId;
   _sessionManager = {
-    startSession: async (gameId) => {
-      return this.request(`/games/${gameId}/sessions`, "POST");
-    },
-    endSession: async (sessionId, gameId) => {
-      return this.request(`/games/${gameId}/sessions/${sessionId}`, "DELETE");
-    }
+    startSession: async (gameId) => this.request(`/games/${gameId}/sessions`, "POST"),
+    endSession: async (sessionId, gameId) => 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.launchId = config?.launchId ?? undefined;
     this.config = config || {};
     this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
     this._detectAuthContext();
@@ -2909,16 +3018,16 @@ class PlaycademyBaseClient {
   }
   getBaseUrl() {
     const isRelative = this.baseUrl.startsWith("/");
-    const isBrowser2 = typeof window !== "undefined";
-    return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+    const isBrowser2 = typeof globalThis.window !== "undefined";
+    return isRelative && isBrowser2 ? `${globalThis.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;
+    const isBrowser2 = typeof globalThis.window !== "undefined";
+    const effectiveGameUrl = isRelative && isBrowser2 ? `${globalThis.location.origin}${this.gameUrl}` : this.gameUrl;
     return `${effectiveGameUrl}/api`;
   }
   ping() {
@@ -2928,6 +3037,9 @@ class PlaycademyBaseClient {
     this.authStrategy = createAuthStrategy(token, tokenType);
     this.emit("authChange", { token });
   }
+  setLaunchId(launchId) {
+    this.launchId = launchId ?? undefined;
+  }
   getTokenType() {
     return this.authStrategy.getType();
   }
@@ -2950,8 +3062,9 @@ class PlaycademyBaseClient {
     return this.connectionManager?.getState() ?? "unknown";
   }
   async checkConnection() {
-    if (!this.connectionManager)
+    if (!this.connectionManager) {
       return "unknown";
+    }
     return await this.connectionManager.checkNow();
   }
   _setAuthContext(context) {
@@ -2969,7 +3082,8 @@ class PlaycademyBaseClient {
   async request(path, method, options) {
     const effectiveHeaders = {
       ...options?.headers,
-      ...this.authStrategy.getHeaders()
+      ...this.authStrategy.getHeaders(),
+      ...this.launchId ? { "x-playcademy-launch-id": this.launchId } : {}
     };
     try {
       const result = await request({
@@ -3018,11 +3132,13 @@ class PlaycademyBaseClient {
     this.authContext = { isInIframe: isInIframe() };
   }
   _initializeConnectionMonitor() {
-    if (typeof window === "undefined")
+    if (typeof globalThis.window === "undefined") {
       return;
+    }
     const isEnabled = this.config.enableConnectionMonitoring ?? true;
-    if (!isEnabled)
+    if (!isEnabled) {
       return;
+    }
     try {
       this.connectionManager = new ConnectionManager({
         baseUrl: this.baseUrl,
@@ -3037,11 +3153,13 @@ class PlaycademyBaseClient {
     }
   }
   async _initializeInternalSession() {
-    if (!this.gameId || this.internalClientSessionId)
+    if (!this.gameId || this.internalClientSessionId) {
       return;
+    }
     const shouldAutoStart = this.config.autoStartSession ?? true;
-    if (!shouldAutoStart)
+    if (!shouldAutoStart) {
       return;
+    }
     try {
       const response = await this._sessionManager.startSession(this.gameId);
       this.internalClientSessionId = response.sessionId;
@@ -3092,6 +3210,7 @@ export {
   PlaycademyError,
   PlaycademyInternalClient as PlaycademyClient,
   MessageEvents,
+  ManifestError,
   ConnectionMonitor,
   ConnectionManager,
   ApiError