@playcademy/sdk 0.3.1 → 0.3.3

package/dist/index.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;
@@ -1662,24 +1720,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);
@@ -1699,8 +1759,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");
@@ -1768,8 +1829,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}`);
@@ -1785,14 +1847,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}`);
     }
   };
@@ -1863,28 +1926,34 @@ class ConnectionManager {
   }
 }
 // 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) {
@@ -1905,6 +1974,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,
@@ -1916,7 +2012,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,
@@ -1932,18 +2028,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(() => "");
@@ -1951,21 +2049,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");
   }
 }
 
@@ -1981,18 +2084,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();
@@ -2001,16 +2102,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() {
@@ -2020,6 +2121,9 @@ class PlaycademyBaseClient {
     this.authStrategy = createAuthStrategy(token, tokenType);
     this.emit("authChange", { token });
   }
+  setLaunchId(launchId) {
+    this.launchId = launchId ?? undefined;
+  }
   getTokenType() {
     return this.authStrategy.getType();
   }
@@ -2042,8 +2146,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) {
@@ -2061,7 +2166,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({
@@ -2110,11 +2216,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,
@@ -2129,11 +2237,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;