@playcademy/sdk 0.0.1-beta.3 → 0.0.1-beta.30

package/dist/index.js

@@ -0,0 +1,1924 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../logger/src/index.ts
+var isBrowser = () => {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}, colors, getLevelColor = (level) => {
+  switch (level) {
+    case "debug":
+      return colors.blue;
+    case "info":
+      return colors.cyan;
+    case "warn":
+      return colors.yellow;
+    case "error":
+      return colors.red;
+    default:
+      return colors.reset;
+  }
+}, logInBrowser = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const levelUpper = level.toUpperCase();
+  const consoleMethod = getConsoleMethod(level);
+  if (context && Object.keys(context).length > 0) {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message, context);
+  } else {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message);
+  }
+}, logOnServer = (level, message, context) => {
+  const consoleMethod = getConsoleMethod(level);
+  if (true) {
+    const timestamp = new Date().toISOString();
+    const levelColor = getLevelColor(level);
+    const levelUpper = level.toUpperCase().padEnd(5);
+    const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(`${coloredPrefix} ${message}`, context);
+    } else {
+      consoleMethod(`${coloredPrefix} ${message}`);
+    }
+  } else {}
+}, getConsoleMethod = (level) => {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+}, performLog = (level, message, context) => {
+  if (level === "debug" && false) {}
+  if (isBrowser()) {
+    logInBrowser(level, message, context);
+  } else {
+    logOnServer(level, message, context);
+  }
+}, createLogger = () => {
+  return {
+    debug: (message, context) => performLog("debug", message, context),
+    info: (message, context) => performLog("info", message, context),
+    warn: (message, context) => performLog("warn", message, context),
+    error: (message, context) => performLog("error", message, context),
+    log: performLog
+  };
+}, log;
+var init_src = __esm(() => {
+  colors = {
+    reset: "\x1B[0m",
+    dim: "\x1B[2m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    cyan: "\x1B[36m",
+    gray: "\x1B[90m"
+  };
+  log = createLogger();
+});
+
+// src/core/errors.ts
+var PlaycademyError, ApiError;
+var init_errors = __esm(() => {
+  PlaycademyError = class PlaycademyError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "PlaycademyError";
+    }
+  };
+  ApiError = class ApiError extends Error {
+    status;
+    details;
+    constructor(status, message, details) {
+      super(`${status} ${message}`);
+      this.status = status;
+      this.details = details;
+      Object.setPrototypeOf(this, ApiError.prototype);
+    }
+  };
+});
+
+// src/core/namespaces/auth.ts
+function createAuthNamespace(client) {
+  return {
+    logout: async () => {
+      await client["request"](`/auth/logout`, "DELETE");
+      client.setToken(null);
+    }
+  };
+}
+
+// src/messaging.ts
+class PlaycademyMessaging {
+  listeners = new Map;
+  send(type, payload, options) {
+    if (options?.target) {
+      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
+      return;
+    }
+    const context = this.getMessagingContext(type);
+    if (context.shouldUsePostMessage) {
+      this.sendViaPostMessage(type, payload, context.target, context.origin);
+    } else {
+      this.sendViaCustomEvent(type, payload);
+    }
+  }
+  listen(type, handler) {
+    const postMessageListener = (event) => {
+      const messageEvent = event;
+      if (messageEvent.data?.type === type) {
+        handler(messageEvent.data.payload || messageEvent.data);
+      }
+    };
+    const customEventListener = (event) => {
+      handler(event.detail);
+    };
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Map);
+    }
+    const listenerMap = this.listeners.get(type);
+    listenerMap.set(handler, {
+      postMessage: postMessageListener,
+      customEvent: customEventListener
+    });
+    window.addEventListener("message", postMessageListener);
+    window.addEventListener(type, customEventListener);
+  }
+  unlisten(type, handler) {
+    const typeListeners = this.listeners.get(type);
+    if (!typeListeners || !typeListeners.has(handler)) {
+      return;
+    }
+    const listeners = typeListeners.get(handler);
+    window.removeEventListener("message", listeners.postMessage);
+    window.removeEventListener(type, listeners.customEvent);
+    typeListeners.delete(handler);
+    if (typeListeners.size === 0) {
+      this.listeners.delete(type);
+    }
+  }
+  getMessagingContext(eventType) {
+    const isIframe = typeof window !== "undefined" && window.self !== window.top;
+    const iframeToParentEvents = [
+      "PLAYCADEMY_READY" /* READY */,
+      "PLAYCADEMY_EXIT" /* EXIT */,
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
+      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */
+    ];
+    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    return {
+      shouldUsePostMessage,
+      target: shouldUsePostMessage ? window.parent : undefined,
+      origin: "*"
+    };
+  }
+  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
+    const messageData = { type };
+    if (payload !== undefined) {
+      messageData.payload = payload;
+    }
+    target.postMessage(messageData, origin);
+  }
+  sendViaCustomEvent(type, payload) {
+    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  }
+}
+var MessageEvents, messaging;
+var init_messaging = __esm(() => {
+  ((MessageEvents2) => {
+    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
+    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
+    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
+    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
+    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
+    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
+    MessageEvents2["READY"] = "PLAYCADEMY_READY";
+    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
+    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
+    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
+  })(MessageEvents ||= {});
+  messaging = new PlaycademyMessaging;
+});
+
+// src/core/namespaces/runtime.ts
+function createRuntimeNamespace(client) {
+  const eventListeners = new Map;
+  const trackListener = (eventType, handler) => {
+    if (!eventListeners.has(eventType)) {
+      eventListeners.set(eventType, new Set);
+    }
+    eventListeners.get(eventType).add(handler);
+  };
+  const untrackListener = (eventType, handler) => {
+    const listeners = eventListeners.get(eventType);
+    if (listeners) {
+      listeners.delete(handler);
+      if (listeners.size === 0) {
+        eventListeners.delete(eventType);
+      }
+    }
+  };
+  if (typeof window !== "undefined" && window.self !== window.top) {
+    const playcademyConfig = window.PLAYCADEMY;
+    const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
+    const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
+    const keyListener = (event) => {
+      if (keySet.has(event.key.toLowerCase()) || keySet.has(event.code.toLowerCase())) {
+        messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
+          key: event.key,
+          code: event.code,
+          type: event.type
+        });
+      }
+    };
+    window.addEventListener("keydown", keyListener);
+    window.addEventListener("keyup", keyListener);
+    trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, () => {
+      window.removeEventListener("keydown", keyListener);
+      window.removeEventListener("keyup", keyListener);
+    });
+  }
+  return {
+    getGameToken: async (gameId, options) => {
+      const res = await client["request"](`/games/${gameId}/token`, "POST");
+      if (options?.apply) {
+        client.setToken(res.token);
+      }
+      return res;
+    },
+    exit: async () => {
+      if (client["internalClientSessionId"] && client["gameId"]) {
+        try {
+          await client.games.endSession(client["internalClientSessionId"], client["gameId"]);
+        } catch (error) {
+          log.error("[Playcademy SDK] Failed to auto-end session:", {
+            sessionId: client["internalClientSessionId"],
+            error
+          });
+        }
+      }
+      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
+    },
+    onInit: (handler) => {
+      messaging.listen("PLAYCADEMY_INIT" /* INIT */, handler);
+      trackListener("PLAYCADEMY_INIT" /* INIT */, handler);
+    },
+    onTokenRefresh: (handler) => {
+      messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+      trackListener("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+    },
+    onPause: (handler) => {
+      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+      trackListener("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+    },
+    onResume: (handler) => {
+      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, handler);
+      trackListener("PLAYCADEMY_RESUME" /* RESUME */, handler);
+    },
+    onForceExit: (handler) => {
+      messaging.listen("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+      trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+    },
+    onOverlay: (handler) => {
+      messaging.listen("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+      trackListener("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+    },
+    ready: () => {
+      messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+    },
+    sendTelemetry: (data) => {
+      messaging.send("PLAYCADEMY_TELEMETRY" /* TELEMETRY */, data);
+    },
+    removeListener: (eventType, handler) => {
+      messaging.unlisten(eventType, handler);
+      untrackListener(eventType, handler);
+    },
+    removeAllListeners: () => {
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        for (const handler of handlers) {
+          messaging.unlisten(eventType, handler);
+        }
+      }
+      eventListeners.clear();
+    },
+    getListenerCounts: () => {
+      const counts = {};
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        counts[eventType] = handlers.size;
+      }
+      return counts;
+    }
+  };
+}
+var init_runtime = __esm(() => {
+  init_src();
+  init_messaging();
+});
+
+// src/core/request.ts
+async function request({
+  path,
+  baseUrl,
+  token,
+  method = "GET",
+  body,
+  extraHeaders = {}
+}) {
+  const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
+  const headers = { ...extraHeaders };
+  let payload;
+  if (body instanceof FormData) {
+    payload = body;
+  } else if (body !== undefined && body !== null) {
+    payload = JSON.stringify(body);
+    headers["Content-Type"] = "application/json";
+  }
+  if (token)
+    headers["Authorization"] = `Bearer ${token}`;
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: payload,
+    credentials: "omit"
+  });
+  if (!res.ok) {
+    const clonedRes = res.clone();
+    const errorBody = await clonedRes.json().catch(() => clonedRes.text().catch(() => {
+      return;
+    })) ?? undefined;
+    throw new ApiError(res.status, res.statusText, errorBody);
+  }
+  if (res.status === 204)
+    return;
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return await res.json();
+  }
+  return await res.text();
+}
+async function fetchManifest(assetBundleBase) {
+  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
+  try {
+    const response = await fetch(manifestUrl);
+    if (!response.ok) {
+      log.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
+      throw new PlaycademyError(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof PlaycademyError) {
+      throw error;
+    }
+    log.error(`[Playcademy SDK] Error fetching or parsing manifest from ${manifestUrl}:`, {
+      error
+    });
+    throw new PlaycademyError("Failed to load or parse game manifest");
+  }
+}
+var init_request = __esm(() => {
+  init_src();
+  init_errors();
+});
+
+// src/core/namespaces/games.ts
+function createGamesNamespace(client) {
+  return {
+    fetch: async (gameIdOrSlug) => {
+      const baseGameData = await client["request"](`/games/${gameIdOrSlug}`, "GET");
+      const manifestData = await fetchManifest(baseGameData.assetBundleBase);
+      return {
+        ...baseGameData,
+        manifest: manifestData
+      };
+    },
+    list: () => client["request"]("/games", "GET"),
+    saveState: async (state) => {
+      const gameId = client["_ensureGameId"]();
+      await client["request"](`/games/${gameId}/state`, "POST", state);
+    },
+    loadState: async () => {
+      const gameId = client["_ensureGameId"]();
+      return client["request"](`/games/${gameId}/state`, "GET");
+    },
+    startSession: async (gameId) => {
+      const idToUse = gameId ?? client["_ensureGameId"]();
+      return client["request"](`/games/${idToUse}/sessions`, "POST", {});
+    },
+    endSession: async (sessionId, gameId) => {
+      const effectiveGameIdToEnd = gameId ?? client["_ensureGameId"]();
+      if (client["internalClientSessionId"] && sessionId === client["internalClientSessionId"] && effectiveGameIdToEnd === client["gameId"]) {
+        client["internalClientSessionId"] = undefined;
+      }
+      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
+    },
+    token: {
+      create: async (gameId, options) => {
+        const res = await client["request"](`/games/${gameId}/token`, "POST");
+        if (options?.apply) {
+          client.setToken(res.token);
+        }
+        return res;
+      }
+    },
+    leaderboard: {
+      get: async (gameId, options) => {
+        const params = new URLSearchParams;
+        if (options?.limit)
+          params.append("limit", String(options.limit));
+        if (options?.offset)
+          params.append("offset", String(options.offset));
+        const queryString = params.toString();
+        const path = queryString ? `/games/${gameId}/leaderboard?${queryString}` : `/games/${gameId}/leaderboard`;
+        return client["request"](path, "GET");
+      }
+    }
+  };
+}
+var init_games = __esm(() => {
+  init_request();
+});
+
+// src/core/namespaces/users.ts
+function createUsersNamespace(client) {
+  const itemIdCache = new Map;
+  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const resolveItemId = async (identifier) => {
+    if (UUID_REGEX.test(identifier))
+      return identifier;
+    const gameId = client["gameId"];
+    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
+    if (itemIdCache.has(cacheKey)) {
+      return itemIdCache.get(cacheKey);
+    }
+    const queryParams = new URLSearchParams({ slug: identifier });
+    if (gameId)
+      queryParams.append("gameId", gameId);
+    const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+    itemIdCache.set(cacheKey, item.id);
+    return item.id;
+  };
+  return {
+    me: async () => {
+      return client["request"]("/users/me", "GET");
+    },
+    inventory: {
+      get: async () => client["request"](`/inventory`, "GET"),
+      add: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/add`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      remove: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/remove`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: -qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      quantity: async (identifier) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        return item?.quantity ?? 0;
+      },
+      has: async (identifier, minQuantity = 1) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        const qty = item?.quantity ?? 0;
+        return qty >= minQuantity;
+      }
+    },
+    scores: {
+      get: async (userIdOrOptions, options) => {
+        let userId;
+        let queryOptions;
+        if (typeof userIdOrOptions === "string") {
+          userId = userIdOrOptions;
+          queryOptions = options || {};
+        } else {
+          queryOptions = userIdOrOptions || {};
+          const user = await client["request"]("/users/me", "GET");
+          userId = user.id;
+        }
+        const params = new URLSearchParams({
+          limit: String(queryOptions.limit || 50)
+        });
+        if (queryOptions.gameId) {
+          params.append("gameId", queryOptions.gameId);
+        }
+        return client["request"](`/users/${userId}/scores?${params}`, "GET");
+      }
+    }
+  };
+}
+
+// src/core/namespaces/dev.ts
+function createDevNamespace(client) {
+  return {
+    auth: {
+      applyForDeveloper: () => client["request"]("/dev/apply", "POST"),
+      getStatus: async () => {
+        const response = await client["request"]("/dev/status", "GET");
+        return response.status;
+      }
+    },
+    games: {
+      upsert: async (slug, metadata, file) => {
+        const game = await client["request"](`/games/${slug}`, "PUT", metadata);
+        const fileName = file instanceof File ? file.name : "game.zip";
+        const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
+          fileName,
+          gameId: game.id
+        });
+        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 finalizeResponse = await client["request"]("/games/uploads/finalize/", "POST", {
+          tempS3Key: initiateResponse.tempS3Key,
+          gameId: initiateResponse.gameId,
+          version: initiateResponse.version,
+          slug,
+          metadata,
+          originalFileName: fileName
+        });
+        if (!finalizeResponse.body) {
+          throw new Error("Finalize response body missing");
+        }
+        const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += value;
+          let eolIndex;
+          while ((eolIndex = buffer.indexOf(`
+
+`)) >= 0) {
+            const message = buffer.slice(0, eolIndex);
+            buffer = buffer.slice(eolIndex + 2);
+            const eventLine = message.match(/^event: (.*)$/m);
+            const dataLine = message.match(/^data: (.*)$/m);
+            if (eventLine && dataLine) {
+              const eventType = eventLine[1];
+              const eventData = JSON.parse(dataLine[1]);
+              if (eventType === "complete") {
+                reader.cancel();
+                return eventData;
+              } else if (eventType === "error") {
+                reader.cancel();
+                throw new Error(eventData.message);
+              }
+            }
+          }
+        }
+        throw new Error("Upload completed but no final game data received");
+      },
+      update: (gameId, props) => client["request"](`/games/${gameId}`, "PATCH", props),
+      delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE")
+    },
+    keys: {
+      create: (label) => client["request"](`/dev/keys`, "POST", { label }),
+      list: () => client["request"](`/dev/keys`, "GET"),
+      revoke: (keyId) => client["request"](`/dev/keys/${keyId}`, "DELETE")
+    },
+    items: {
+      create: (gameId, slug, itemData) => client["request"](`/games/${gameId}/items`, "POST", {
+        slug,
+        ...itemData
+      }),
+      update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}`, "PATCH", updates),
+      list: (gameId) => client["request"](`/games/${gameId}/items`, "GET"),
+      get: (gameId, slug) => {
+        const queryParams = new URLSearchParams({ slug, gameId });
+        return client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      },
+      delete: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}`, "DELETE"),
+      shop: {
+        create: (gameId, itemId, listingData) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "POST", 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", updates);
+        },
+        delete: (gameId, itemId) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "DELETE");
+        },
+        list: (gameId) => {
+          return client["request"](`/games/${gameId}/shop-listings`, "GET");
+        }
+      }
+    }
+  };
+}
+
+// src/core/namespaces/maps.ts
+function createMapsNamespace(client) {
+  return {
+    get: (identifier) => client["request"](`/maps/${identifier}`, "GET"),
+    elements: (mapId) => client["request"](`/map/elements?mapId=${mapId}`, "GET"),
+    objects: {
+      list: (mapId) => client["request"](`/maps/${mapId}/objects`, "GET"),
+      create: (mapId, objectData) => client["request"](`/maps/${mapId}/objects`, "POST", objectData),
+      delete: (mapId, objectId) => client["request"](`/maps/${mapId}/objects/${objectId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/admin.ts
+function createAdminNamespace(client) {
+  return {
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
+    },
+    items: {
+      create: (props) => client["request"]("/items", "POST", props),
+      get: (itemId) => client["request"](`/items/${itemId}`, "GET"),
+      list: () => client["request"]("/items", "GET"),
+      update: (itemId, props) => client["request"](`/items/${itemId}`, "PATCH", props),
+      delete: (itemId) => client["request"](`/items/${itemId}`, "DELETE")
+    },
+    currencies: {
+      create: (props) => client["request"]("/currencies", "POST", props),
+      get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
+      list: () => client["request"]("/currencies", "GET"),
+      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", props),
+      delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
+    },
+    shopListings: {
+      create: (props) => client["request"]("/shop-listings", "POST", props),
+      get: (listingId) => client["request"](`/shop-listings/${listingId}`, "GET"),
+      list: () => client["request"]("/shop-listings", "GET"),
+      update: (listingId, props) => client["request"](`/shop-listings/${listingId}`, "PATCH", props),
+      delete: (listingId) => client["request"](`/shop-listings/${listingId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/shop.ts
+function createShopNamespace(client) {
+  return {
+    view: () => {
+      return client["request"]("/shop/view", "GET");
+    }
+  };
+}
+
+// src/core/namespaces/telemetry.ts
+function createTelemetryNamespace(client) {
+  return {
+    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", metrics)
+  };
+}
+
+// src/core/namespaces/levels.ts
+function createLevelsNamespace(client) {
+  return {
+    get: async () => {
+      return client["request"]("/users/level", "GET");
+    },
+    progress: async () => {
+      return client["request"]("/users/level/progress", "GET");
+    },
+    addXP: async (amount) => {
+      const currentUserLevel = await client["request"]("/users/level", "GET");
+      const oldLevel = currentUserLevel.currentLevel;
+      const payload = { amount };
+      const result = await client["request"]("/users/xp/add", "POST", payload);
+      client["emit"]("xpGained", {
+        amount,
+        totalXP: result.totalXP,
+        leveledUp: result.leveledUp
+      });
+      if (result.leveledUp) {
+        client["emit"]("levelUp", {
+          oldLevel,
+          newLevel: result.newLevel,
+          creditsAwarded: result.creditsAwarded
+        });
+      }
+      return result;
+    },
+    config: {
+      list: async () => {
+        return client["request"]("/levels/config", "GET");
+      },
+      get: async (level) => {
+        return client["request"](`/levels/config/${level}`, "GET");
+      }
+    }
+  };
+}
+
+// ../data/src/domains/game/table.ts
+import {
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+  varchar
+} from "drizzle-orm/pg-core";
+var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
+var init_table = __esm(() => {
+  init_table3();
+  init_table4();
+  gamePlatformEnum = pgEnum("game_platform", ["web", "godot", "unity"]);
+  gameBootModeEnum = pgEnum("game_boot_mode", ["iframe", "module"]);
+  games = pgTable("games", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    developerId: text("developer_id").references(() => users.id, {
+      onDelete: "set null"
+    }),
+    slug: varchar("slug", { length: 255 }).notNull().unique(),
+    displayName: varchar("display_name", { length: 255 }).notNull(),
+    version: varchar("version", { length: 50 }).notNull(),
+    assetBundleBase: text("asset_bundle_base").notNull(),
+    platform: gamePlatformEnum("platform").notNull().default("web"),
+    mapElementId: uuid("map_element_id").references(() => mapElements.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb("metadata").default("{}"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
+  });
+  gameSessions = pgTable("game_sessions", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    endedAt: timestamp("ended_at", { withTimezone: true })
+  });
+  gameStates = pgTable("game_states", {
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    data: jsonb("data").default("{}"),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex("unique_user_game_idx").on(table.userId, table.gameId)]);
+});
+
+// ../data/src/domains/inventory/table.ts
+import { relations, sql } from "drizzle-orm";
+import {
+  boolean,
+  integer,
+  jsonb as jsonb2,
+  pgEnum as pgEnum2,
+  pgTable as pgTable2,
+  text as text2,
+  timestamp as timestamp2,
+  uniqueIndex as uniqueIndex2,
+  uuid as uuid2
+} from "drizzle-orm/pg-core";
+var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
+var init_table2 = __esm(() => {
+  init_table();
+  init_table3();
+  init_table4();
+  itemTypeEnum = pgEnum2("item_type", [
+    "currency",
+    "badge",
+    "trophy",
+    "collectible",
+    "consumable",
+    "unlock",
+    "upgrade",
+    "accessory",
+    "other"
+  ]);
+  items = pgTable2("items", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    slug: text2("slug").notNull(),
+    gameId: uuid2("game_id").references(() => games.id, {
+      onDelete: "cascade"
+    }),
+    displayName: text2("display_name").notNull(),
+    description: text2("description"),
+    type: itemTypeEnum("type").notNull().default("other"),
+    isPlaceable: boolean("is_placeable").default(false).notNull(),
+    imageUrl: text2("image_url"),
+    metadata: jsonb2("metadata").default({}),
+    createdAt: timestamp2("created_at").defaultNow().notNull()
+  }, (table) => [
+    uniqueIndex2("items_game_slug_idx").on(table.gameId, table.slug),
+    uniqueIndex2("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
+  ]);
+  inventoryItems = pgTable2("inventory_items", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    userId: text2("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    quantity: integer("quantity").notNull().default(1),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex2("unique_user_item_idx").on(table.userId, table.itemId)]);
+  currencies = pgTable2("currencies", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    symbol: text2("symbol"),
+    isPrimary: boolean("is_primary").default(false).notNull(),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex2("currency_item_id_idx").on(table.itemId)]);
+  shopListings = pgTable2("shop_listings", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    currencyId: uuid2("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
+    price: integer("price").notNull(),
+    sellBackPercentage: integer("sell_back_percentage"),
+    stock: integer("stock"),
+    isActive: boolean("is_active").default(true).notNull(),
+    availableFrom: timestamp2("available_from", { withTimezone: true }),
+    availableUntil: timestamp2("available_until", { withTimezone: true }),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex2("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
+  itemsRelations = relations(items, ({ many }) => ({
+    shopListings: many(shopListings),
+    inventoryItems: many(inventoryItems),
+    mapObjects: many(mapObjects)
+  }));
+  currenciesRelations = relations(currencies, ({ many }) => ({
+    shopListings: many(shopListings)
+  }));
+  shopListingsRelations = relations(shopListings, ({ one }) => ({
+    item: one(items, {
+      fields: [shopListings.itemId],
+      references: [items.id]
+    }),
+    currency: one(currencies, {
+      fields: [shopListings.currencyId],
+      references: [currencies.id]
+    })
+  }));
+  inventoryItemsRelations = relations(inventoryItems, ({ one }) => ({
+    item: one(items, {
+      fields: [inventoryItems.itemId],
+      references: [items.id]
+    }),
+    user: one(users, {
+      fields: [inventoryItems.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/domains/map/table.ts
+import { relations as relations2 } from "drizzle-orm";
+import {
+  doublePrecision,
+  index,
+  integer as integer2,
+  jsonb as jsonb3,
+  pgEnum as pgEnum3,
+  pgTable as pgTable3,
+  text as text3,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
+  varchar as varchar2
+} from "drizzle-orm/pg-core";
+var interactionTypeEnum, maps, mapElements, mapObjects, mapElementsRelations, mapsRelations, mapObjectsRelations;
+var init_table3 = __esm(() => {
+  init_table();
+  init_table2();
+  init_table4();
+  interactionTypeEnum = pgEnum3("interaction_type", [
+    "game_entry",
+    "game_registry",
+    "info",
+    "teleport",
+    "door_in",
+    "door_out",
+    "npc_interaction",
+    "quest_trigger"
+  ]);
+  maps = pgTable3("maps", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    identifier: varchar2("identifier", { length: 255 }).notNull().unique(),
+    displayName: varchar2("display_name", { length: 255 }).notNull(),
+    filePath: varchar2("file_path", { length: 255 }).notNull(),
+    tilesetBasePath: varchar2("tileset_base_path", { length: 255 }).notNull().default("/tilesets"),
+    defaultSpawnTileX: doublePrecision("default_spawn_tile_x").notNull().default(0),
+    defaultSpawnTileY: doublePrecision("default_spawn_tile_y").notNull().default(0),
+    description: text3("description")
+  });
+  mapElements = pgTable3("map_elements", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    mapId: uuid3("map_id").references(() => maps.id, {
+      onDelete: "cascade"
+    }),
+    elementSlug: varchar2("element_slug", { length: 255 }).notNull(),
+    interactionType: interactionTypeEnum("interaction_type").notNull(),
+    gameId: uuid3("game_id").references(() => games.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb3("metadata").$type().default({})
+  }, (table) => [uniqueIndex3("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
+  mapObjects = pgTable3("map_objects", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    userId: text3("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    mapId: uuid3("map_id").notNull().references(() => maps.id, { onDelete: "cascade" }),
+    itemId: uuid3("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    worldX: doublePrecision("world_x").notNull(),
+    worldY: doublePrecision("world_y").notNull(),
+    rotation: integer2("rotation").default(0).notNull(),
+    scale: doublePrecision("scale").default(1).notNull(),
+    createdAt: timestamp3("created_at").defaultNow().notNull()
+  }, (table) => [
+    index("map_objects_map_idx").on(table.mapId),
+    index("map_objects_spatial_idx").on(table.mapId, table.worldX, table.worldY)
+  ]);
+  mapElementsRelations = relations2(mapElements, ({ one }) => ({
+    game: one(games, {
+      fields: [mapElements.gameId],
+      references: [games.id]
+    }),
+    map: one(maps, {
+      fields: [mapElements.mapId],
+      references: [maps.id]
+    })
+  }));
+  mapsRelations = relations2(maps, ({ many }) => ({
+    elements: many(mapElements),
+    objects: many(mapObjects)
+  }));
+  mapObjectsRelations = relations2(mapObjects, ({ one }) => ({
+    user: one(users, {
+      fields: [mapObjects.userId],
+      references: [users.id]
+    }),
+    map: one(maps, {
+      fields: [mapObjects.mapId],
+      references: [maps.id]
+    }),
+    item: one(items, {
+      fields: [mapObjects.itemId],
+      references: [items.id]
+    })
+  }));
+});
+
+// ../data/src/domains/user/table.ts
+import { relations as relations3 } from "drizzle-orm";
+import { boolean as boolean2, pgEnum as pgEnum4, pgTable as pgTable4, text as text4, timestamp as timestamp4, uniqueIndex as uniqueIndex4 } from "drizzle-orm/pg-core";
+var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification, usersRelations;
+var init_table4 = __esm(() => {
+  init_table3();
+  userRoleEnum = pgEnum4("user_role", ["admin", "player", "developer"]);
+  developerStatusEnum = pgEnum4("developer_status", ["none", "pending", "approved"]);
+  users = pgTable4("user", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    name: text4("name").notNull(),
+    username: text4("username").unique(),
+    email: text4("email").notNull().unique(),
+    emailVerified: boolean2("email_verified").notNull().default(false),
+    image: text4("image"),
+    role: userRoleEnum("role").notNull().default("player"),
+    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
+    characterCreated: boolean2("character_created").notNull().default(false),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  accounts = pgTable4("account", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text4("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+    accountId: text4("account_id").notNull(),
+    providerId: text4("provider_id").notNull(),
+    accessToken: text4("access_token"),
+    refreshToken: text4("refresh_token"),
+    idToken: text4("id_token"),
+    accessTokenExpiresAt: timestamp4("access_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    refreshTokenExpiresAt: timestamp4("refresh_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    scope: text4("scope"),
+    password: text4("password"),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  }, (table) => [uniqueIndex4("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
+  sessions = pgTable4("session", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    expiresAt: timestamp4("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    token: text4("token").notNull().unique(),
+    ipAddress: text4("ip_address"),
+    userAgent: text4("user_agent"),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  verification = pgTable4("verification", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    identifier: text4("identifier").notNull(),
+    value: text4("value").notNull(),
+    expiresAt: timestamp4("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  usersRelations = relations3(users, ({ many }) => ({
+    mapObjects: many(mapObjects)
+  }));
+});
+
+// ../data/src/domains/developer/table.ts
+import { pgTable as pgTable5, text as text5, timestamp as timestamp5, uuid as uuid4, varchar as varchar3 } from "drizzle-orm/pg-core";
+var developerKeys;
+var init_table5 = __esm(() => {
+  init_table4();
+  developerKeys = pgTable5("developer_keys", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    label: varchar3("label", { length: 255 }),
+    keyHash: text5("key_hash").notNull().unique(),
+    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow()
+  });
+});
+
+// ../data/src/domains/level/table.ts
+import { relations as relations4 } from "drizzle-orm";
+import { integer as integer3, pgTable as pgTable6, text as text6, timestamp as timestamp6, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
+var userLevels, levelConfigs, userLevelsRelations;
+var init_table6 = __esm(() => {
+  init_table4();
+  userLevels = pgTable6("user_levels", {
+    userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
+    currentLevel: integer3("current_level").notNull().default(1),
+    currentXp: integer3("current_xp").notNull().default(0),
+    totalXP: integer3("total_xp").notNull().default(0),
+    lastLevelUpAt: timestamp6("last_level_up_at", { withTimezone: true }),
+    createdAt: timestamp6("created_at").defaultNow().notNull(),
+    updatedAt: timestamp6("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  });
+  levelConfigs = pgTable6("level_configs", {
+    id: uuid5("id").primaryKey().defaultRandom(),
+    level: integer3("level").notNull().unique(),
+    xpRequired: integer3("xp_required").notNull(),
+    creditsReward: integer3("credits_reward").notNull().default(0),
+    createdAt: timestamp6("created_at").defaultNow().notNull()
+  }, (table) => [uniqueIndex5("unique_level_config_idx").on(table.level)]);
+  userLevelsRelations = relations4(userLevels, ({ one }) => ({
+    user: one(users, {
+      fields: [userLevels.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/domains/leaderboard/table.ts
+import { relations as relations5 } from "drizzle-orm";
+import { index as index2, integer as integer4, jsonb as jsonb4, pgTable as pgTable7, text as text7, timestamp as timestamp7, uuid as uuid6 } from "drizzle-orm/pg-core";
+var gameScores, gameScoresRelations;
+var init_table7 = __esm(() => {
+  init_table();
+  init_table4();
+  gameScores = pgTable7("game_scores", {
+    id: uuid6("id").primaryKey().defaultRandom(),
+    userId: text7("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid6("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    score: integer4("score").notNull(),
+    metadata: jsonb4("metadata").default("{}"),
+    achievedAt: timestamp7("achieved_at", { withTimezone: true }).defaultNow().notNull(),
+    sessionId: uuid6("session_id").references(() => gameSessions.id, { onDelete: "set null" })
+  }, (table) => [
+    index2("game_scores_user_game_idx").on(table.userId, table.gameId),
+    index2("game_scores_game_score_idx").on(table.gameId, table.score),
+    index2("game_scores_achieved_at_idx").on(table.achievedAt)
+  ]);
+  gameScoresRelations = relations5(gameScores, ({ one }) => ({
+    user: one(users, {
+      fields: [gameScores.userId],
+      references: [users.id]
+    }),
+    game: one(games, {
+      fields: [gameScores.gameId],
+      references: [games.id]
+    }),
+    session: one(gameSessions, {
+      fields: [gameScores.sessionId],
+      references: [gameSessions.id]
+    })
+  }));
+});
+
+// ../data/src/domains/sprite/table.ts
+import { relations as relations6 } from "drizzle-orm";
+import { integer as integer5, pgTable as pgTable8, timestamp as timestamp8, uuid as uuid7, varchar as varchar4 } from "drizzle-orm/pg-core";
+var spriteTemplates, spriteSheets, spriteTemplatesRelations, spriteSheetsRelations;
+var init_table8 = __esm(() => {
+  spriteTemplates = pgTable8("sprite_templates", {
+    id: uuid7("id").primaryKey().defaultRandom(),
+    slug: varchar4("slug", { length: 64 }).notNull().unique(),
+    url: varchar4("url", { length: 255 }).notNull(),
+    createdAt: timestamp8("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp8("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  spriteSheets = pgTable8("sprite_sheets", {
+    id: uuid7("id").primaryKey().defaultRandom(),
+    templateId: uuid7("template_id").notNull().references(() => spriteTemplates.id, { onDelete: "cascade" }),
+    width: integer5("width").notNull(),
+    height: integer5("height").notNull(),
+    url: varchar4("url", { length: 255 }).notNull(),
+    createdAt: timestamp8("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp8("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  spriteTemplatesRelations = relations6(spriteTemplates, ({ many }) => ({
+    sheets: many(spriteSheets)
+  }));
+  spriteSheetsRelations = relations6(spriteSheets, ({ one }) => ({
+    template: one(spriteTemplates, {
+      fields: [spriteSheets.templateId],
+      references: [spriteTemplates.id]
+    })
+  }));
+});
+
+// ../data/src/domains/character/table.ts
+import { relations as relations7 } from "drizzle-orm";
+import { integer as integer6, pgEnum as pgEnum5, pgTable as pgTable9, text as text8, timestamp as timestamp9, uuid as uuid8, varchar as varchar5 } from "drizzle-orm/pg-core";
+var characterComponentTypeEnum, characterComponents, playerCharacters, characterComponentsRelations, playerCharactersRelations;
+var init_table9 = __esm(() => {
+  init_table8();
+  init_table4();
+  characterComponentTypeEnum = pgEnum5("character_component_type", [
+    "body",
+    "outfit",
+    "hairstyle",
+    "eyes",
+    "accessory"
+  ]);
+  characterComponents = pgTable9("character_components", {
+    id: uuid8("id").primaryKey().defaultRandom(),
+    componentType: characterComponentTypeEnum("component_type").notNull(),
+    slug: varchar5("slug", { length: 128 }).notNull().unique(),
+    displayName: varchar5("display_name", { length: 128 }).notNull(),
+    slot: varchar5("slot", { length: 64 }).notNull(),
+    spriteSheetId: uuid8("sprite_sheet_id").notNull().references(() => spriteSheets.id, { onDelete: "cascade" }),
+    unlockLevel: integer6("unlock_level").notNull().default(0),
+    variant: integer6("variant").notNull().default(0),
+    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  playerCharacters = pgTable9("player_characters", {
+    id: uuid8("id").primaryKey().defaultRandom(),
+    userId: text8("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    bodyComponentId: uuid8("body_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    eyesComponentId: uuid8("eyes_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    hairstyleComponentId: uuid8("hairstyle_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    outfitComponentId: uuid8("outfit_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    accessoryComponentId: uuid8("accessory_component_id").references(() => characterComponents.id, {
+      onDelete: "set null"
+    }),
+    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  characterComponentsRelations = relations7(characterComponents, ({ one }) => ({
+    sheet: one(spriteSheets, {
+      fields: [characterComponents.spriteSheetId],
+      references: [spriteSheets.id]
+    })
+  }));
+  playerCharactersRelations = relations7(playerCharacters, ({ one }) => ({
+    user: one(users, {
+      fields: [playerCharacters.userId],
+      references: [users.id]
+    }),
+    body: one(characterComponents, {
+      fields: [playerCharacters.bodyComponentId],
+      references: [characterComponents.id]
+    }),
+    eyes: one(characterComponents, {
+      fields: [playerCharacters.eyesComponentId],
+      references: [characterComponents.id]
+    }),
+    hair: one(characterComponents, {
+      fields: [playerCharacters.hairstyleComponentId],
+      references: [characterComponents.id]
+    }),
+    outfit: one(characterComponents, {
+      fields: [playerCharacters.outfitComponentId],
+      references: [characterComponents.id]
+    }),
+    accessory: one(characterComponents, {
+      fields: [playerCharacters.accessoryComponentId],
+      references: [characterComponents.id]
+    })
+  }));
+});
+
+// ../data/src/tables.index.ts
+var init_tables_index = __esm(() => {
+  init_table4();
+  init_table5();
+  init_table();
+  init_table2();
+  init_table3();
+  init_table6();
+  init_table7();
+  init_table8();
+  init_table9();
+});
+
+// ../data/src/constants.ts
+var ITEM_SLUGS, CURRENCIES, BADGES, INTERACTION_TYPE;
+var init_constants = __esm(() => {
+  init_tables_index();
+  ITEM_SLUGS = {
+    PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
+    PLAYCADEMY_XP: "PLAYCADEMY_XP",
+    FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
+    EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
+    FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
+    COMMON_SWORD: "COMMON_SWORD",
+    SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
+    SMALL_BACKPACK: "SMALL_BACKPACK",
+    LAVA_LAMP: "LAVA_LAMP",
+    BOOMBOX: "BOOMBOX",
+    CABIN_BED: "CABIN_BED"
+  };
+  CURRENCIES = {
+    PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+    XP: ITEM_SLUGS.PLAYCADEMY_XP
+  };
+  BADGES = {
+    FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+    EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+    FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
+  };
+  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
+});
+
+// src/core/namespaces/credits.ts
+function createCreditsNamespace(client) {
+  let cachedCreditsItemId = null;
+  const getCreditsItemId = async () => {
+    if (cachedCreditsItemId) {
+      return cachedCreditsItemId;
+    }
+    const queryParams = new URLSearchParams({ slug: CURRENCIES.PRIMARY });
+    const creditsItem = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+    if (!creditsItem || !creditsItem.id) {
+      throw new Error("Playcademy Credits item not found in catalog");
+    }
+    cachedCreditsItemId = creditsItem.id;
+    return creditsItem.id;
+  };
+  return {
+    balance: async () => {
+      const inventory = await client["request"]("/inventory", "GET");
+      const primaryCurrencyInventoryItem = inventory.find((item) => item.item?.slug === CURRENCIES.PRIMARY);
+      return primaryCurrencyInventoryItem?.quantity ?? 0;
+    },
+    add: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/add", "POST", {
+        itemId: creditsItemId,
+        qty: amount
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    },
+    spend: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/remove", "POST", {
+        itemId: creditsItemId,
+        qty: amount
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: -amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    }
+  };
+}
+var init_credits = __esm(() => {
+  init_constants();
+});
+
+// src/core/namespaces/leaderboard.ts
+function createLeaderboardNamespace(client) {
+  return {
+    fetch: async (options) => {
+      const params = new URLSearchParams({
+        timeframe: options?.timeframe || "all_time",
+        limit: String(options?.limit || 10),
+        offset: String(options?.offset || 0)
+      });
+      if (options?.gameId) {
+        params.append("gameId", options.gameId);
+      }
+      return client["request"](`/leaderboard?${params}`, "GET");
+    },
+    getUserRank: async (gameId, userId) => {
+      return client["request"](`/games/${gameId}/users/${userId}/rank`, "GET");
+    }
+  };
+}
+
+// src/core/namespaces/scores.ts
+function createScoresNamespace(client) {
+  return {
+    submit: async (gameId, score, metadata) => {
+      return client["request"](`/games/${gameId}/scores`, "POST", {
+        score,
+        metadata
+      });
+    },
+    getByUser: async (gameId, userId, options) => {
+      const params = new URLSearchParams;
+      if (options?.limit) {
+        params.append("limit", String(options.limit));
+      }
+      const queryString = params.toString();
+      const path = queryString ? `/games/${gameId}/users/${userId}/scores?${queryString}` : `/games/${gameId}/users/${userId}/scores`;
+      return client["request"](path, "GET");
+    }
+  };
+}
+
+// src/core/namespaces/character.ts
+function createCharacterNamespace(client) {
+  const componentCache = {};
+  const clearComponentCache = () => {
+    Object.keys(componentCache).forEach((key) => delete componentCache[key]);
+  };
+  const getCachedComponentLevels = () => {
+    return Object.keys(componentCache);
+  };
+  return {
+    get: async (userId) => {
+      try {
+        const path = userId ? `/character/${userId}` : "/character";
+        return await client["request"](path, "GET");
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.message.includes("404")) {
+            return null;
+          }
+        }
+        throw error;
+      }
+    },
+    create: async (characterData) => {
+      return client["request"]("/character", "POST", characterData);
+    },
+    update: async (updates) => {
+      return client["request"]("/character", "PATCH", updates);
+    },
+    components: {
+      list: async (options) => {
+        const cacheKey = options?.level === undefined ? "all" : String(options.level);
+        if (!options?.skipCache && componentCache[cacheKey]) {
+          return componentCache[cacheKey];
+        }
+        const path = options?.level !== undefined ? `/character/components?level=${options.level}` : "/character/components";
+        const components = await client["request"](path, "GET");
+        componentCache[cacheKey] = components || [];
+        return components || [];
+      },
+      clearCache: clearComponentCache,
+      getCacheKeys: getCachedComponentLevels
+    }
+  };
+}
+
+// src/core/namespaces/sprites.ts
+function createSpritesNamespace(client) {
+  return {
+    templates: {
+      get: async (slug) => {
+        const templateMeta = await client["request"](`/sprites/templates/${slug}`, "GET");
+        if (!templateMeta.url) {
+          throw new Error(`Template ${slug} has no URL in database`);
+        }
+        const response = await fetch(templateMeta.url);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch template JSON from ${templateMeta.url}: ${response.statusText}`);
+        }
+        return response.json();
+      }
+    }
+  };
+}
+
+// src/core/namespaces/realtime.client.ts
+class RealtimeChannelClient {
+  gameId;
+  _channelName;
+  getToken;
+  baseUrl;
+  ws;
+  listeners = new Set;
+  isClosing = false;
+  tokenRefreshUnsubscribe;
+  constructor(gameId, _channelName, getToken, baseUrl) {
+    this.gameId = gameId;
+    this._channelName = _channelName;
+    this.getToken = getToken;
+    this.baseUrl = baseUrl;
+  }
+  async connect() {
+    try {
+      const token = await this.getToken();
+      const wsUrl = this.baseUrl.replace(/^http/, "ws");
+      const url = `${wsUrl}?token=${encodeURIComponent(token)}&c=${encodeURIComponent(this._channelName)}`;
+      this.ws = new WebSocket(url);
+      this.setupEventHandlers();
+      this.setupTokenRefreshListener();
+      await new Promise((resolve, reject) => {
+        if (!this.ws) {
+          reject(new Error("WebSocket creation failed"));
+          return;
+        }
+        const onOpen = () => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (event) => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          reject(new Error(`WebSocket connection failed: ${event}`));
+        };
+        this.ws.addEventListener("open", onOpen);
+        this.ws.addEventListener("error", onError);
+      });
+      log.debug("[RealtimeChannelClient] Connected to channel", {
+        gameId: this.gameId,
+        channel: this._channelName
+      });
+      return this;
+    } catch (error) {
+      log.error("[RealtimeChannelClient] Connection failed", {
+        gameId: this.gameId,
+        channel: this._channelName,
+        error
+      });
+      throw error;
+    }
+  }
+  setupEventHandlers() {
+    if (!this.ws)
+      return;
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.listeners.forEach((callback) => {
+          try {
+            callback(data);
+          } catch (error) {
+            log.warn("[RealtimeChannelClient] Message listener error", {
+              channel: this._channelName,
+              error
+            });
+          }
+        });
+      } catch (error) {
+        log.warn("[RealtimeChannelClient] Failed to parse message", {
+          channel: this._channelName,
+          message: event.data,
+          error
+        });
+      }
+    };
+    this.ws.onclose = (event) => {
+      log.debug("[RealtimeChannelClient] Connection closed", {
+        channel: this._channelName,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (!this.isClosing && event.code !== CLOSE_CODES.TOKEN_REFRESH) {
+        log.warn("[RealtimeChannelClient] Unexpected disconnection", {
+          channel: this._channelName,
+          code: event.code,
+          reason: event.reason
+        });
+      }
+    };
+    this.ws.onerror = (event) => {
+      log.error("[RealtimeChannelClient] WebSocket error", {
+        channel: this._channelName,
+        event
+      });
+    };
+  }
+  setupTokenRefreshListener() {
+    const tokenRefreshHandler = async ({ token }) => {
+      log.debug("[RealtimeChannelClient] Token refresh received, reconnecting", {
+        channel: this._channelName
+      });
+      try {
+        await this.reconnectWithNewToken(token);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Token refresh reconnection failed", {
+          channel: this._channelName,
+          error
+        });
+      }
+    };
+    messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    this.tokenRefreshUnsubscribe = () => {
+      messaging.unlisten("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    };
+  }
+  async reconnectWithNewToken(_token) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.close(CLOSE_CODES.TOKEN_REFRESH, "token_refresh");
+      await new Promise((resolve) => {
+        const checkClosed = () => {
+          if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            resolve();
+          } else {
+            setTimeout(checkClosed, 10);
+          }
+        };
+        checkClosed();
+      });
+    }
+    await this.connect();
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      try {
+        const message = JSON.stringify(data);
+        this.ws.send(message);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Failed to send message", {
+          channel: this._channelName,
+          error,
+          data
+        });
+      }
+    } else {
+      log.warn("[RealtimeChannelClient] Cannot send message - connection not open", {
+        channel: this._channelName,
+        readyState: this.ws?.readyState
+      });
+    }
+  }
+  onMessage(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  close() {
+    this.isClosing = true;
+    if (this.tokenRefreshUnsubscribe) {
+      this.tokenRefreshUnsubscribe();
+      this.tokenRefreshUnsubscribe = undefined;
+    }
+    if (this.ws) {
+      this.ws.close(CLOSE_CODES.NORMAL_CLOSURE, "client_close");
+      this.ws = undefined;
+    }
+    this.listeners.clear();
+    log.debug("[RealtimeChannelClient] Channel closed", {
+      channel: this._channelName
+    });
+  }
+  get channelName() {
+    return this._channelName;
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+}
+var CLOSE_CODES;
+var init_realtime_client = __esm(() => {
+  init_src();
+  init_messaging();
+  CLOSE_CODES = {
+    NORMAL_CLOSURE: 1000,
+    TOKEN_REFRESH: 4000
+  };
+});
+
+// src/core/namespaces/realtime.ts
+function createRealtimeNamespace(client) {
+  return {
+    token: {
+      get: async () => {
+        return client["request"]("/realtime/token", "POST");
+      }
+    },
+    async open(channel = "default") {
+      if (!client["gameId"]) {
+        throw new Error("gameId is required for realtime channels");
+      }
+      const realtimeClient = new RealtimeChannelClient(client["gameId"], channel, () => client.realtime.token.get().then((r) => r.token), client.getBaseUrl());
+      return realtimeClient.connect();
+    }
+  };
+}
+var init_realtime = __esm(() => {
+  init_realtime_client();
+});
+
+// src/core/namespaces/index.ts
+var init_namespaces = __esm(() => {
+  init_runtime();
+  init_games();
+  init_credits();
+  init_realtime();
+});
+
+// src/core/static/init.ts
+async function getPlaycademyConfig() {
+  const preloaded = window.PLAYCADEMY;
+  if (preloaded?.token) {
+    return preloaded;
+  }
+  if (window.self !== window.top) {
+    return await waitForPlaycademyInit();
+  } else {
+    return createStandaloneConfig();
+  }
+}
+async function waitForPlaycademyInit() {
+  return new Promise((resolve, reject) => {
+    let contextReceived = false;
+    const timeoutDuration = 5000;
+    const handleMessage = (event) => {
+      if (event.data?.type === "PLAYCADEMY_INIT" /* INIT */) {
+        contextReceived = true;
+        window.removeEventListener("message", handleMessage);
+        clearTimeout(timeoutId);
+        window.PLAYCADEMY = event.data.payload;
+        resolve(event.data.payload);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const timeoutId = setTimeout(() => {
+      if (!contextReceived) {
+        window.removeEventListener("message", handleMessage);
+        reject(new Error(`${"PLAYCADEMY_INIT" /* INIT */} not received within ${timeoutDuration}ms`));
+      }
+    }, timeoutDuration);
+  });
+}
+function createStandaloneConfig() {
+  const mockConfig = {
+    baseUrl: "/api",
+    token: "mock-game-token-for-local-dev",
+    gameId: "mock-game-id-from-template"
+  };
+  window.PLAYCADEMY = mockConfig;
+  return mockConfig;
+}
+async function init() {
+  const { PlaycademyClient } = await Promise.resolve().then(() => (init_client(), exports_client));
+  if (typeof window === "undefined") {
+    throw new Error("Playcademy SDK must run in a browser context");
+  }
+  const config = await getPlaycademyConfig();
+  const client = new PlaycademyClient({
+    baseUrl: config.baseUrl,
+    token: config.token,
+    gameId: config.gameId
+  });
+  messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
+  messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+  if (import.meta.env?.MODE === "development") {
+    window.PLAYCADEMY_CLIENT = client;
+  }
+  return client;
+}
+var init_init = __esm(() => {
+  init_messaging();
+});
+
+// src/core/static/login.ts
+async function login(baseUrl, email, password) {
+  let url = baseUrl;
+  if (baseUrl.startsWith("/") && typeof window !== "undefined") {
+    url = window.location.origin + baseUrl;
+  }
+  url = url + "/auth/login";
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ email, password })
+  });
+  if (!response.ok) {
+    try {
+      const errorData = await response.json();
+      const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
+      throw new PlaycademyError(errorMessage);
+    } catch (error) {
+      log.error("[Playcademy SDK] Failed to parse error response JSON, using status text instead:", { error });
+      throw new PlaycademyError(response.statusText);
+    }
+  }
+  return response.json();
+}
+var init_login = __esm(() => {
+  init_src();
+  init_errors();
+});
+
+// src/core/static/index.ts
+var init_static = __esm(() => {
+  init_init();
+  init_login();
+});
+
+// src/core/client.ts
+var exports_client = {};
+__export(exports_client, {
+  PlaycademyClient: () => PlaycademyClient
+});
+var PlaycademyClient;
+var init_client = __esm(() => {
+  init_src();
+  init_errors();
+  init_namespaces();
+  init_request();
+  init_static();
+  PlaycademyClient = class PlaycademyClient {
+    baseUrl;
+    token;
+    gameId;
+    listeners = {};
+    internalClientSessionId;
+    constructor(config) {
+      if (!config) {
+        this.baseUrl = "/api";
+        this.token = undefined;
+        this.gameId = undefined;
+      } else {
+        this.baseUrl = config.baseUrl || "/api";
+        this.token = config.token;
+        this.gameId = config.gameId;
+      }
+      if (this.gameId) {
+        this._initializeInternalSession().catch((error) => {
+          log.error("[Playcademy SDK] Background initialization of auto-session failed:", {
+            error
+          });
+        });
+      }
+    }
+    getBaseUrl() {
+      const isRelative = this.baseUrl.startsWith("/");
+      const isBrowser2 = typeof window !== "undefined";
+      return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+    }
+    ping() {
+      return "pong";
+    }
+    setToken(token) {
+      this.token = token ?? undefined;
+      this.emit("authChange", { token: this.token ?? null });
+    }
+    onAuthChange(callback) {
+      this.on("authChange", (payload) => callback(payload.token));
+    }
+    on(event, callback) {
+      this.listeners[event] = this.listeners[event] ?? [];
+      this.listeners[event].push(callback);
+    }
+    emit(event, payload) {
+      (this.listeners[event] ?? []).forEach((listener) => {
+        listener(payload);
+      });
+    }
+    async request(path, method, body, headers) {
+      const effectiveHeaders = { ...headers };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.baseUrl,
+        token: this.token,
+        extraHeaders: effectiveHeaders
+      });
+    }
+    _ensureGameId() {
+      if (!this.gameId) {
+        throw new PlaycademyError("This operation requires a gameId, but none was provided when initializing the client.");
+      }
+      return this.gameId;
+    }
+    async _initializeInternalSession() {
+      if (!this.gameId || this.internalClientSessionId) {
+        return;
+      }
+      try {
+        const response = await this.games.startSession(this.gameId);
+        this.internalClientSessionId = response.sessionId;
+      } catch (error) {
+        log.error("[Playcademy SDK] Auto-starting session failed for game", {
+          gameId: this.gameId,
+          error
+        });
+      }
+    }
+    auth = createAuthNamespace(this);
+    runtime = createRuntimeNamespace(this);
+    games = createGamesNamespace(this);
+    users = createUsersNamespace(this);
+    dev = createDevNamespace(this);
+    maps = createMapsNamespace(this);
+    admin = createAdminNamespace(this);
+    shop = createShopNamespace(this);
+    levels = createLevelsNamespace(this);
+    telemetry = createTelemetryNamespace(this);
+    credits = createCreditsNamespace(this);
+    leaderboard = createLeaderboardNamespace(this);
+    scores = createScoresNamespace(this);
+    character = createCharacterNamespace(this);
+    sprites = createSpritesNamespace(this);
+    realtime = createRealtimeNamespace(this);
+    static init = init;
+    static login = login;
+  };
+});
+
+// src/index.ts
+init_client();
+init_messaging();
+export {
+  messaging,
+  PlaycademyClient,
+  MessageEvents
+};