@playcademy/sdk 0.0.1-beta.27 → 0.0.1-beta.29

package/dist/index.js

@@ -175,7 +175,8 @@ class PlaycademyMessaging {
     const iframeToParentEvents = [
       "PLAYCADEMY_READY" /* READY */,
       "PLAYCADEMY_EXIT" /* EXIT */,
-      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
+      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */
     ];
     const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
     return {
@@ -207,12 +208,49 @@ var init_messaging = __esm(() => {
     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");
@@ -233,6 +271,55 @@ function createRuntimeNamespace(client) {
         }
       }
       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;
     }
   };
 }
@@ -336,6 +423,27 @@ function createGamesNamespace(client) {
         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");
+      }
     }
   };
 }
@@ -401,6 +509,27 @@ function createUsersNamespace(client) {
         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");
+      }
     }
   };
 }
@@ -410,7 +539,7 @@ function createDevNamespace(client) {
   return {
     auth: {
       applyForDeveloper: () => client["request"]("/dev/apply", "POST"),
-      getDeveloperStatus: async () => {
+      getStatus: async () => {
         const response = await client["request"]("/dev/status", "GET");
         return response.status;
       }
@@ -478,9 +607,9 @@ function createDevNamespace(client) {
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE")
     },
     keys: {
-      createKey: (label) => client["request"](`/dev/keys`, "POST", { label }),
-      listKeys: () => client["request"](`/dev/keys`, "GET"),
-      revokeKey: (keyId) => client["request"](`/dev/keys/${keyId}`, "DELETE")
+      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", {
@@ -518,7 +647,13 @@ function createDevNamespace(client) {
 // src/core/namespaces/maps.ts
 function createMapsNamespace(client) {
   return {
-    elements: (mapId) => client["request"](`/map/elements?mapId=${mapId}`, "GET")
+    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")
+    }
   };
 }
 
@@ -608,125 +743,180 @@ function createLevelsNamespace(client) {
   };
 }
 
-// ../data/src/domains/user/table.ts
-import { boolean, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
-var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification;
+// ../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(() => {
-  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer"]);
-  developerStatusEnum = pgEnum("developer_status", ["none", "pending", "approved"]);
-  users = pgTable("user", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    name: text("name").notNull(),
-    username: text("username").unique(),
-    email: text("email").notNull().unique(),
-    emailVerified: boolean("email_verified").notNull().default(false),
-    image: text("image"),
-    role: userRoleEnum("role").notNull().default("player"),
-    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
-  });
-  accounts = pgTable("account", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
-    accountId: text("account_id").notNull(),
-    providerId: text("provider_id").notNull(),
-    accessToken: text("access_token"),
-    refreshToken: text("refresh_token"),
-    idToken: text("id_token"),
-    accessTokenExpiresAt: timestamp("access_token_expires_at", {
-      mode: "date",
-      withTimezone: true
+  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"
     }),
-    refreshTokenExpiresAt: timestamp("refresh_token_expires_at", {
-      mode: "date",
-      withTimezone: true
+    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"
     }),
-    scope: text("scope"),
-    password: text("password"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
-  }, (table) => [uniqueIndex("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
-  sessions = pgTable("session", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    expiresAt: timestamp("expires_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    token: text("token").notNull().unique(),
-    ipAddress: text("ip_address"),
-    userAgent: text("user_agent"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
+    metadata: jsonb("metadata").default("{}"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
   });
-  verification = pgTable("verification", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    identifier: text("identifier").notNull(),
-    value: text("value").notNull(),
-    expiresAt: timestamp("expires_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
+  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/developer/table.ts
-import { pgTable as pgTable2, text as text2, timestamp as timestamp2, uuid, varchar } from "drizzle-orm/pg-core";
-var developerKeys;
+// ../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();
-  developerKeys = pgTable2("developer_keys", {
-    id: uuid("id").primaryKey().defaultRandom(),
+  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" }),
-    label: varchar("label", { length: 255 }),
-    keyHash: text2("key_hash").notNull().unique(),
-    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
-  });
+    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 } from "drizzle-orm";
+import { relations as relations2 } from "drizzle-orm";
 import {
   doublePrecision,
-  jsonb,
-  pgEnum as pgEnum2,
+  index,
+  integer as integer2,
+  jsonb as jsonb3,
+  pgEnum as pgEnum3,
   pgTable as pgTable3,
   text as text3,
-  uniqueIndex as uniqueIndex2,
-  uuid as uuid2,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
   varchar as varchar2
 } from "drizzle-orm/pg-core";
-var interactionTypeEnum, maps, mapElements, mapElementsRelations, mapsRelations;
+var interactionTypeEnum, maps, mapElements, mapObjects, mapElementsRelations, mapsRelations, mapObjectsRelations;
 var init_table3 = __esm(() => {
+  init_table();
+  init_table2();
   init_table4();
-  interactionTypeEnum = pgEnum2("interaction_type", [
+  interactionTypeEnum = pgEnum3("interaction_type", [
     "game_entry",
     "game_registry",
     "info",
@@ -737,7 +927,7 @@ var init_table3 = __esm(() => {
     "quest_trigger"
   ]);
   maps = pgTable3("maps", {
-    id: uuid2("id").primaryKey().defaultRandom(),
+    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(),
@@ -747,18 +937,32 @@ var init_table3 = __esm(() => {
     description: text3("description")
   });
   mapElements = pgTable3("map_elements", {
-    id: uuid2("id").primaryKey().defaultRandom(),
-    mapId: uuid2("map_id").references(() => maps.id, {
+    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: uuid2("game_id").references(() => games.id, {
+    gameId: uuid3("game_id").references(() => games.id, {
       onDelete: "set null"
     }),
-    metadata: jsonb("metadata").$type().default({})
-  }, (table) => [uniqueIndex2("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
-  mapElementsRelations = relations(mapElements, ({ one }) => ({
+    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]
@@ -768,183 +972,158 @@ var init_table3 = __esm(() => {
       references: [maps.id]
     })
   }));
-  mapsRelations = relations(maps, ({ many }) => ({
-    elements: many(mapElements)
+  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/game/table.ts
-import {
-  jsonb as jsonb2,
-  pgEnum as pgEnum3,
-  pgTable as pgTable4,
-  text as text4,
-  timestamp as timestamp3,
-  uniqueIndex as uniqueIndex3,
-  uuid as uuid3,
-  varchar as varchar3
-} from "drizzle-orm/pg-core";
-var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
+// ../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();
-  init_table();
-  gamePlatformEnum = pgEnum3("game_platform", ["web", "godot", "unity"]);
-  gameBootModeEnum = pgEnum3("game_boot_mode", ["iframe", "module"]);
-  games = pgTable4("games", {
-    id: uuid3("id").primaryKey().defaultRandom(),
-    developerId: text4("developer_id").references(() => users.id, {
-      onDelete: "set null"
+  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
     }),
-    slug: varchar3("slug", { length: 255 }).notNull().unique(),
-    displayName: varchar3("display_name", { length: 255 }).notNull(),
-    version: varchar3("version", { length: 50 }).notNull(),
-    assetBundleBase: text4("asset_bundle_base").notNull(),
-    platform: gamePlatformEnum("platform").notNull().default("web"),
-    mapElementId: uuid3("map_element_id").references(() => mapElements.id, {
-      onDelete: "set null"
+    refreshTokenExpiresAt: timestamp4("refresh_token_expires_at", {
+      mode: "date",
+      withTimezone: true
     }),
-    metadata: jsonb2("metadata").default("{}"),
-    createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow(),
-    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
-  });
-  gameSessions = pgTable4("game_sessions", {
-    id: uuid3("id").primaryKey().defaultRandom(),
+    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" }),
-    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
-    endedAt: timestamp3("ended_at", { withTimezone: true })
+    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()
   });
-  gameStates = pgTable4("game_states", {
-    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    data: jsonb2("data").default("{}"),
-    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
-  }, (table) => [uniqueIndex3("unique_user_game_idx").on(table.userId, table.gameId)]);
+  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/inventory/table.ts
-import { relations as relations2, sql } from "drizzle-orm";
-import {
-  boolean as boolean2,
-  integer,
-  jsonb as jsonb3,
-  pgEnum as pgEnum4,
-  pgTable as pgTable5,
-  text as text5,
-  timestamp as timestamp4,
-  uniqueIndex as uniqueIndex4,
-  uuid as uuid4
-} from "drizzle-orm/pg-core";
-var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
+// ../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();
-  init_table();
-  itemTypeEnum = pgEnum4("item_type", [
-    "currency",
-    "badge",
-    "trophy",
-    "collectible",
-    "consumable",
-    "unlock",
-    "upgrade",
-    "other"
-  ]);
-  items = pgTable5("items", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    slug: text5("slug").notNull(),
-    gameId: uuid4("game_id").references(() => games.id, {
-      onDelete: "cascade"
-    }),
-    displayName: text5("display_name").notNull(),
-    description: text5("description"),
-    type: itemTypeEnum("type").notNull().default("other"),
-    imageUrl: text5("image_url"),
-    metadata: jsonb3("metadata").default({}),
-    createdAt: timestamp4("created_at").defaultNow().notNull()
-  }, (table) => [
-    uniqueIndex4("items_game_slug_idx").on(table.gameId, table.slug),
-    uniqueIndex4("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
-  ]);
-  inventoryItems = pgTable5("inventory_items", {
+  developerKeys = pgTable5("developer_keys", {
     id: uuid4("id").primaryKey().defaultRandom(),
     userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    quantity: integer("quantity").notNull().default(1),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow()
-  }, (table) => [uniqueIndex4("unique_user_item_idx").on(table.userId, table.itemId)]);
-  currencies = pgTable5("currencies", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    symbol: text5("symbol"),
-    isPrimary: boolean2("is_primary").default(false).notNull(),
-    createdAt: timestamp4("created_at").defaultNow().notNull(),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
-  }, (table) => [uniqueIndex4("currency_item_id_idx").on(table.itemId)]);
-  shopListings = pgTable5("shop_listings", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    currencyId: uuid4("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
-    price: integer("price").notNull(),
-    sellBackPercentage: integer("sell_back_percentage"),
-    stock: integer("stock"),
-    isActive: boolean2("is_active").default(true).notNull(),
-    availableFrom: timestamp4("available_from", { withTimezone: true }),
-    availableUntil: timestamp4("available_until", { withTimezone: true }),
-    createdAt: timestamp4("created_at").defaultNow().notNull(),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
-  }, (table) => [uniqueIndex4("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
-  itemsRelations = relations2(items, ({ many }) => ({
-    shopListings: many(shopListings),
-    inventoryItems: many(inventoryItems)
-  }));
-  currenciesRelations = relations2(currencies, ({ many }) => ({
-    shopListings: many(shopListings)
-  }));
-  shopListingsRelations = relations2(shopListings, ({ one }) => ({
-    item: one(items, {
-      fields: [shopListings.itemId],
-      references: [items.id]
-    }),
-    currency: one(currencies, {
-      fields: [shopListings.currencyId],
-      references: [currencies.id]
-    })
-  }));
-  inventoryItemsRelations = relations2(inventoryItems, ({ one }) => ({
-    item: one(items, {
-      fields: [inventoryItems.itemId],
-      references: [items.id]
-    }),
-    user: one(users, {
-      fields: [inventoryItems.userId],
-      references: [users.id]
-    })
-  }));
+    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 relations3 } from "drizzle-orm";
-import { integer as integer2, pgTable as pgTable6, text as text6, timestamp as timestamp5, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
+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_table();
+  init_table4();
   userLevels = pgTable6("user_levels", {
     userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
-    currentLevel: integer2("current_level").notNull().default(1),
-    currentXp: integer2("current_xp").notNull().default(0),
-    totalXP: integer2("total_xp").notNull().default(0),
-    lastLevelUpAt: timestamp5("last_level_up_at", { withTimezone: true }),
-    createdAt: timestamp5("created_at").defaultNow().notNull(),
-    updatedAt: timestamp5("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+    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: integer2("level").notNull().unique(),
-    xpRequired: integer2("xp_required").notNull(),
-    creditsReward: integer2("credits_reward").notNull().default(0),
-    createdAt: timestamp5("created_at").defaultNow().notNull()
+    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 = relations3(userLevels, ({ one }) => ({
+  userLevelsRelations = relations4(userLevels, ({ one }) => ({
     user: one(users, {
       fields: [userLevels.userId],
       references: [users.id]
@@ -952,14 +1131,158 @@ var init_table6 = __esm(() => {
   }));
 });
 
+// ../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_table();
-  init_table2();
   init_table4();
   init_table5();
+  init_table();
+  init_table2();
   init_table3();
   init_table6();
+  init_table7();
+  init_table8();
+  init_table9();
 });
 
 // ../data/src/constants.ts
@@ -974,7 +1297,10 @@ var init_constants = __esm(() => {
     FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
     COMMON_SWORD: "COMMON_SWORD",
     SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
-    SMALL_BACKPACK: "SMALL_BACKPACK"
+    SMALL_BACKPACK: "SMALL_BACKPACK",
+    LAVA_LAMP: "LAVA_LAMP",
+    BOOMBOX: "BOOMBOX",
+    CABIN_BED: "CABIN_BED"
   };
   CURRENCIES = {
     PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
@@ -1047,6 +1373,123 @@ 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.ts
+function createRealtimeNamespace(client) {
+  return {
+    token: {
+      get: async () => {
+        return client["request"]("/realtime/token", "POST");
+      }
+    }
+  };
+}
+
 // src/core/namespaces/index.ts
 var init_namespaces = __esm(() => {
   init_runtime();
@@ -1258,6 +1701,11 @@ var init_client = __esm(() => {
     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;
   };