@playcademy/sdk 0.0.5 → 0.0.6

package/dist/index.js

@@ -10,2047 +10,2058 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../data/src/domains/game/table.ts
-import {
-  jsonb,
-  pgEnum,
-  pgTable,
-  text,
-  timestamp,
-  uniqueIndex,
-  uuid,
-  varchar
-} from "drizzle-orm/pg-core";
-var gamePlatformEnum, gameBootModeEnum, gameTypeEnum, 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"]);
-  gameTypeEnum = pgEnum("game_type", ["hosted", "external"]);
-  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(),
-    gameType: gameTypeEnum("game_type").notNull().default("hosted"),
-    assetBundleBase: text("asset_bundle_base"),
-    externalUrl: text("external_url"),
-    platform: gamePlatformEnum("platform").notNull().default("web"),
-    mapElementId: uuid("map_element_id").references(() => mapElements.id, {
-      onDelete: "set null"
-    }),
-    metadata: jsonb("metadata").$type().notNull().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)]);
+// ../logger/src/index.ts
+var isBrowser = () => {
+  const g = globalThis;
+  return typeof g.window !== "undefined" && typeof g.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();
 });
 
-// ../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]
-    })
-  }));
-});
+// src/core/auth/utils.ts
+function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
+  const left = window.screenX + (window.outerWidth - width) / 2;
+  const top = window.screenY + (window.outerHeight - height) / 2;
+  const features = [
+    `width=${width}`,
+    `height=${height}`,
+    `left=${left}`,
+    `top=${top}`,
+    "toolbar=no",
+    "menubar=no",
+    "location=yes",
+    "status=yes",
+    "scrollbars=yes",
+    "resizable=yes"
+  ].join(",");
+  return window.open(url, name, features);
+}
+function isInIframe() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
 
-// ../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, ssoProvider, 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(),
-    timebackId: text4("timeback_id").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()
-  });
-  ssoProvider = pgTable4("sso_provider", {
-    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    issuer: text4("issuer").notNull(),
-    oidcConfig: text4("oidc_config"),
-    samlConfig: text4("saml_config"),
-    userId: text4("user_id").references(() => users.id, { onDelete: "cascade" }),
-    providerId: text4("provider_id").notNull().unique(),
-    organizationId: text4("organization_id"),
-    domain: text4("domain").notNull()
-  });
-  usersRelations = relations3(users, ({ many }) => ({
-    mapObjects: many(mapObjects)
-  }));
+// 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);
+    }
+  };
 });
 
-// ../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()
-  });
-});
+// src/core/namespaces/auth.ts
+function createAuthNamespace(client) {
+  return {
+    login: async (credentials) => {
+      try {
+        const response = await client["request"]("/auth/login", "POST", credentials);
+        client.setToken(response.token);
+        return { success: true, token: response.token };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Authentication failed"
+        };
+      }
+    },
+    logout: async () => {
+      await client["request"]("/auth/logout", "POST");
+      client.setToken(null);
+    }
+  };
+}
 
-// ../data/src/domains/level/table.ts
-import { relations as relations4 } from "drizzle-orm";
-import {
-  doublePrecision as doublePrecision2,
-  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: doublePrecision2("current_xp").notNull().default(0),
-    totalXP: doublePrecision2("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]
-    })
-  }));
-});
+// ../utils/src/random.ts
+async function generateSecureRandomString(length) {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const randomValues = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(randomValues);
+  return Array.from(randomValues).map((byte) => charset[byte % charset.length]).join("");
+}
 
-// ../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]
-    })
-  }));
+// src/core/auth/oauth.ts
+function getTimebackConfig() {
+  return {
+    authorizationEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/authorize",
+    tokenEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/token",
+    scope: "openid email phone"
+  };
+}
+async function generateOAuthState(data) {
+  const csrfToken = await generateSecureRandomString(32);
+  if (data && Object.keys(data).length > 0) {
+    const jsonStr = JSON.stringify(data);
+    const base64 = btoa(jsonStr).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return `${csrfToken}.${base64}`;
+  }
+  return csrfToken;
+}
+function parseOAuthState(state) {
+  const lastDotIndex = state.lastIndexOf(".");
+  if (lastDotIndex > 0 && lastDotIndex < state.length - 1) {
+    try {
+      const csrfToken = state.substring(0, lastDotIndex);
+      const base64 = state.substring(lastDotIndex + 1);
+      const base64WithPadding = base64.replace(/-/g, "+").replace(/_/g, "/");
+      const paddedBase64 = base64WithPadding + "=".repeat((4 - base64WithPadding.length % 4) % 4);
+      const jsonStr = atob(paddedBase64);
+      const data = JSON.parse(jsonStr);
+      return { csrfToken, data };
+    } catch {}
+  }
+  return { csrfToken: state };
+}
+function getOAuthConfig(provider) {
+  const configGetter = OAUTH_CONFIGS[provider];
+  if (!configGetter)
+    throw new Error(`Unsupported auth provider: ${provider}`);
+  return configGetter();
+}
+var OAUTH_CONFIGS;
+var init_oauth = __esm(() => {
+  OAUTH_CONFIGS = {
+    get TIMEBACK() {
+      return getTimebackConfig;
+    }
+  };
 });
 
-// ../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()
+// src/core/auth/flows/popup.ts
+async function initiatePopupFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Opening authentication window..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    const popup = openPopupWindow(authUrl, "playcademy-auth");
+    if (!popup || popup.closed) {
+      throw new Error("Popup blocked. Please enable popups and try again.");
+    }
+    onStateChange?.({
+      status: "exchanging_token",
+      message: "Waiting for authentication..."
+    });
+    return await waitForServerMessage(popup, onStateChange);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage,
+      error: error instanceof Error ? error : new Error(errorMessage)
+    });
+    throw error;
+  }
+}
+async function waitForServerMessage(popup, onStateChange) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const handleMessage = (event) => {
+      if (event.origin !== window.location.origin)
+        return;
+      const data = event.data;
+      if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
+        resolved = true;
+        window.removeEventListener("message", handleMessage);
+        if (data.authenticated && data.user) {
+          onStateChange?.({
+            status: "complete",
+            message: "Authentication successful"
+          });
+          resolve({
+            success: true,
+            user: data.user
+          });
+        } else {
+          const error = new Error(data.error || "Authentication failed");
+          onStateChange?.({
+            status: "error",
+            message: error.message,
+            error
+          });
+          resolve({
+            success: false,
+            error
+          });
+        }
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const checkClosed = setInterval(() => {
+      if (popup.closed && !resolved) {
+        clearInterval(checkClosed);
+        window.removeEventListener("message", handleMessage);
+        const error = new Error("Authentication cancelled");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 500);
+    setTimeout(() => {
+      if (!resolved) {
+        window.removeEventListener("message", handleMessage);
+        clearInterval(checkClosed);
+        const error = new Error("Authentication timeout");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 5 * 60 * 1000);
   });
-  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,
-  uniqueIndex as uniqueIndex6,
-  uuid as uuid8,
-  varchar as varchar5
-} from "drizzle-orm/pg-core";
-var characterComponentTypeEnum, characterComponents, playerCharacters, playerCharacterAccessories, characterComponentsRelations, playerCharactersRelations, playerCharacterAccessoriesRelations;
-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" }),
-    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
-  });
-  playerCharacterAccessories = pgTable9("player_character_accessories", {
-    id: uuid8("id").primaryKey().defaultRandom(),
-    playerCharacterId: uuid8("player_character_id").notNull().references(() => playerCharacters.id, { onDelete: "cascade" }),
-    accessoryComponentId: uuid8("accessory_component_id").notNull().references(() => characterComponents.id, { onDelete: "cascade" }),
-    slot: varchar5("slot", { length: 64 }).notNull(),
-    equippedAt: timestamp9("equipped_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
-  }, (table) => [
-    uniqueIndex6("unique_player_character_slot_idx").on(table.playerCharacterId, table.slot),
-    uniqueIndex6("player_character_accessory_idx").on(table.playerCharacterId, table.accessoryComponentId)
-  ]);
-  characterComponentsRelations = relations7(characterComponents, ({ one }) => ({
-    sheet: one(spriteSheets, {
-      fields: [characterComponents.spriteSheetId],
-      references: [spriteSheets.id]
-    })
-  }));
-  playerCharactersRelations = relations7(playerCharacters, ({ one, many }) => ({
-    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]
-    }),
-    accessories: many(playerCharacterAccessories)
-  }));
-  playerCharacterAccessoriesRelations = relations7(playerCharacterAccessories, ({ one }) => ({
-    playerCharacter: one(playerCharacters, {
-      fields: [playerCharacterAccessories.playerCharacterId],
-      references: [playerCharacters.id]
-    }),
-    accessoryComponent: one(characterComponents, {
-      fields: [playerCharacterAccessories.accessoryComponentId],
-      references: [characterComponents.id]
-    })
-  }));
+}
+var init_popup = __esm(() => {
+  init_oauth();
 });
 
-// ../data/src/domains/timeback/table.ts
-import { doublePrecision as doublePrecision3, pgTable as pgTable10, text as text9, timestamp as timestamp10, uniqueIndex as uniqueIndex7, uuid as uuid9 } from "drizzle-orm/pg-core";
-var timebackDailyXp, timebackXpEvents;
-var init_table10 = __esm(() => {
-  init_table4();
-  timebackDailyXp = pgTable10("timeback_daily_xp", {
-    userId: text9("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    date: timestamp10("date", { mode: "date", withTimezone: true }).notNull(),
-    xp: doublePrecision3("xp").notNull().default(0),
-    createdAt: timestamp10("created_at", { mode: "date", withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp10("updated_at", { mode: "date", withTimezone: true }).notNull().defaultNow()
-  }, (table) => [uniqueIndex7("timeback_daily_xp_user_date_idx").on(table.userId, table.date)]);
-  timebackXpEvents = pgTable10("timeback_xp_event", {
-    id: uuid9("id").primaryKey().defaultRandom(),
-    userId: text9("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    occurredAt: timestamp10("occurred_at", { withTimezone: true }).notNull(),
-    xpDelta: doublePrecision3("xp_delta").notNull(),
-    source: text9("source").notNull(),
-    sourceId: text9("source_id"),
-    sensor: text9("sensor"),
-    appName: text9("app_name"),
-    createdAt: timestamp10("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp10("updated_at", { withTimezone: true }).notNull().defaultNow()
-  }, (table) => [uniqueIndex7("timeback_xp_events_source_id_idx").on(table.source, table.sourceId)]);
+// src/core/auth/flows/redirect.ts
+async function initiateRedirectFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Redirecting to authentication provider..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    window.location.href = authUrl;
+    return new Promise(() => {});
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage,
+      error: error instanceof Error ? error : new Error(errorMessage)
+    });
+    throw error;
+  }
+}
+var init_redirect = __esm(() => {
+  init_oauth();
 });
 
-// ../data/src/domains/achievement/table.ts
-import { relations as relations8 } from "drizzle-orm";
-import {
-  boolean as boolean3,
-  index as index3,
-  integer as integer7,
-  jsonb as jsonb5,
-  pgEnum as pgEnum6,
-  pgTable as pgTable11,
-  text as text10,
-  timestamp as timestamp11,
-  uniqueIndex as uniqueIndex8,
-  uuid as uuid10,
-  varchar as varchar6
-} from "drizzle-orm/pg-core";
-var achievementIntervalEnum, achievements, userAchievementProgress, userAchievementClaims, userAchievementProgressRelations, userAchievementClaimsRelations;
-var init_table11 = __esm(() => {
-  init_table4();
-  achievementIntervalEnum = pgEnum6("achievement_interval", ["daily", "weekly"]);
-  achievements = pgTable11("achievements", {
-    id: varchar6("id", { length: 255 }).primaryKey(),
-    title: varchar6("title", { length: 255 }).notNull(),
-    description: text10("description"),
-    intervalType: achievementIntervalEnum("interval_type").notNull(),
-    rewardCredits: integer7("reward_credits").notNull().default(0),
-    limitPerInterval: integer7("limit_per_interval").notNull().default(1),
-    completionType: varchar6("completion_type", { length: 50 }).notNull(),
-    completionConfig: jsonb5("completion_config").notNull().default({}),
-    scope: jsonb5("scope").notNull().default({}),
-    active: boolean3("active").notNull().default(true),
-    createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow(),
-    updatedAt: timestamp11("updated_at", { withTimezone: true }).defaultNow()
-  });
-  userAchievementProgress = pgTable11("user_achievement_progress", {
-    id: uuid10("id").primaryKey().defaultRandom(),
-    userId: text10("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    achievementId: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    intervalKey: text10("interval_key").notNull(),
-    progress: jsonb5("progress").notNull().default({}),
-    updatedAt: timestamp11("updated_at", { withTimezone: true }).defaultNow().notNull()
-  }, (table) => [
-    index3("user_achievement_progress_idx").on(table.userId, table.achievementId, table.intervalKey)
-  ]);
-  userAchievementClaims = pgTable11("user_achievement_claims", {
-    id: uuid10("id").primaryKey().defaultRandom(),
-    userId: text10("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    achievementId: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    intervalKey: text10("interval_key").notNull(),
-    rewardCredits: integer7("reward_credits").notNull(),
-    createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow().notNull()
-  }, (table) => [
-    uniqueIndex8("user_achievement_claims_unique").on(table.userId, table.achievementId, table.intervalKey)
-  ]);
-  userAchievementProgressRelations = relations8(userAchievementProgress, ({ one }) => ({
-    user: one(users, {
-      fields: [userAchievementProgress.userId],
-      references: [users.id]
-    }),
-    achievement: one(achievements, {
-      fields: [userAchievementProgress.achievementId],
-      references: [achievements.id]
-    })
-  }));
-  userAchievementClaimsRelations = relations8(userAchievementClaims, ({ one }) => ({
-    user: one(users, {
-      fields: [userAchievementClaims.userId],
-      references: [users.id]
-    }),
-    achievement: one(achievements, {
-      fields: [userAchievementClaims.achievementId],
-      references: [achievements.id]
-    })
-  }));
+// src/core/auth/flows/unified.ts
+async function initiateUnifiedFlow(options) {
+  const { mode = "auto" } = options;
+  const effectiveMode = mode === "auto" ? isInIframe() ? "popup" : "redirect" : mode;
+  switch (effectiveMode) {
+    case "popup":
+      return initiatePopupFlow(options);
+    case "redirect":
+      return initiateRedirectFlow(options);
+    default:
+      throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
+  }
+}
+var init_unified = __esm(() => {
+  init_popup();
+  init_redirect();
 });
 
-// ../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();
-  init_table10();
-  init_table11();
+// src/core/auth/login.ts
+async function login(client, options) {
+  try {
+    let stateData = options.stateData;
+    if (!stateData) {
+      const currentUser = client["initPayload"]?.user;
+      if (currentUser?.id) {
+        stateData = { playcademy_user_id: currentUser.id };
+      } else {
+        try {
+          const currentUser2 = await client.users.me();
+          if (currentUser2?.id) {
+            stateData = { playcademy_user_id: currentUser2.id };
+          }
+        } catch {
+          log.debug("[Playcademy SDK] No current user available for state data");
+        }
+      }
+    }
+    log.debug("[Playcademy SDK] Starting OAuth login", {
+      provider: options.provider,
+      mode: options.mode || "auto",
+      callbackUrl: options.callbackUrl,
+      hasStateData: !!stateData
+    });
+    const optionsWithState = {
+      ...options,
+      stateData
+    };
+    const result = await initiateUnifiedFlow(optionsWithState);
+    if (result.success && result.user) {
+      log.debug("[Playcademy SDK] OAuth login successful", {
+        userId: result.user.sub
+      });
+    }
+    return result;
+  } catch (error) {
+    log.error("[Playcademy SDK] OAuth login failed", { error });
+    const authError = error instanceof Error ? error : new Error("Authentication failed");
+    return {
+      success: false,
+      error: authError
+    };
+  }
+}
+var init_login = __esm(() => {
+  init_src();
+  init_unified();
 });
 
-// ../data/src/constants.ts
-var ITEM_SLUGS, CURRENCIES, BADGES, ACHIEVEMENT_COMPLETION_TYPES, ACHIEVEMENT_COMPLETION_TYPE, 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
+// src/core/namespaces/identity.ts
+function createIdentityNamespace(client) {
+  return {
+    get user() {
+      const gameUser = client["initPayload"]?.user;
+      if (!gameUser)
+        return null;
+      const name = gameUser.name || gameUser.username || "";
+      return {
+        sub: gameUser.id,
+        email: gameUser.email || "",
+        name,
+        email_verified: true,
+        given_name: undefined,
+        family_name: undefined
+      };
+    },
+    connect: (options) => login(client, options),
+    _getContext: () => ({
+      isInIframe: client["authContext"]?.isInIframe ?? false
+    })
   };
-  ACHIEVEMENT_COMPLETION_TYPES = [
-    "time_played_session",
-    "interaction",
-    "leaderboard_rank"
-  ];
-  ACHIEVEMENT_COMPLETION_TYPE = Object.fromEntries(ACHIEVEMENT_COMPLETION_TYPES.map((value) => [value, value]));
-  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
+}
+var init_identity = __esm(() => {
+  init_login();
 });
 
-// ../logger/src/index.ts
-var isBrowser = () => {
-  const g = globalThis;
-  return typeof g.window !== "undefined" && typeof g.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;
+// 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);
+    }
   }
-}, logInBrowser = (level, message, context) => {
-  const timestamp12 = new Date().toISOString();
-  const levelUpper = level.toUpperCase();
-  const consoleMethod = getConsoleMethod(level);
-  if (context && Object.keys(context).length > 0) {
-    consoleMethod(`[${timestamp12}] ${levelUpper}`, message, context);
-  } else {
-    consoleMethod(`[${timestamp12}] ${levelUpper}`, message);
+  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);
   }
-}, logOnServer = (level, message, context) => {
-  const consoleMethod = getConsoleMethod(level);
-  if (true) {
-    const timestamp12 = new Date().toISOString();
-    const levelColor = getLevelColor(level);
-    const levelUpper = level.toUpperCase().padEnd(5);
-    const coloredPrefix = `${colors.dim}[${timestamp12}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
-    if (context && Object.keys(context).length > 0) {
-      consoleMethod(`${coloredPrefix} ${message}`, context);
-    } else {
-      consoleMethod(`${coloredPrefix} ${message}`);
+  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);
     }
-  } 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);
+  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: "*"
+    };
   }
-}, 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
+  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";
+    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
+    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
+  })(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);
   };
-}, 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/auth/utils.ts
-function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
-  const left = window.screenX + (window.outerWidth - width) / 2;
-  const top = window.screenY + (window.outerHeight - height) / 2;
-  const features = [
-    `width=${width}`,
-    `height=${height}`,
-    `left=${left}`,
-    `top=${top}`,
-    "toolbar=no",
-    "menubar=no",
-    "location=yes",
-    "status=yes",
-    "scrollbars=yes",
-    "resizable=yes"
-  ].join(",");
-  return window.open(url, name, features);
-}
-function isInIframe() {
-  if (typeof window === "undefined") {
-    return false;
-  }
-  try {
-    return window.self !== window.top;
-  } catch {
-    return true;
-  }
-}
-
-// src/core/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);
+  const untrackListener = (eventType, handler) => {
+    const listeners = eventListeners.get(eventType);
+    if (listeners) {
+      listeners.delete(handler);
+      if (listeners.size === 0) {
+        eventListeners.delete(eventType);
+      }
     }
   };
-});
-
-// src/core/namespaces/auth.ts
-function createAuthNamespace(client) {
+  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 {
-    login: async (credentials) => {
-      try {
-        const response = await client["request"]("/auth/login", "POST", credentials);
-        client.setToken(response.token);
-        return { success: true, token: response.token };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Authentication failed"
-        };
+    getGameToken: async (gameId, options) => {
+      const res = await client["request"](`/games/${gameId}/token`, "POST");
+      if (options?.apply) {
+        client.setToken(res.token);
       }
+      return res;
     },
-    logout: async () => {
-      await client["request"]("/auth/logout", "POST");
-      client.setToken(null);
+    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;
     }
   };
 }
-
-// ../utils/src/random.ts
-async function generateSecureRandomString(length) {
-  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
-  const randomValues = new Uint8Array(length);
-  globalThis.crypto.getRandomValues(randomValues);
-  return Array.from(randomValues).map((byte) => charset[byte % charset.length]).join("");
-}
-
-// src/core/auth/oauth.ts
-function getTimebackConfig() {
-  return {
-    authorizationEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/authorize",
-    tokenEndpoint: "https://alpha-auth-production-idp.auth.us-west-2.amazoncognito.com/oauth2/token",
-    scope: "openid email phone"
-  };
-}
-async function generateOAuthState(data) {
-  const csrfToken = await generateSecureRandomString(32);
-  if (data && Object.keys(data).length > 0) {
-    const jsonStr = JSON.stringify(data);
-    const base64 = btoa(jsonStr).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-    return `${csrfToken}.${base64}`;
-  }
-  return csrfToken;
-}
-function parseOAuthState(state) {
-  const lastDotIndex = state.lastIndexOf(".");
-  if (lastDotIndex > 0 && lastDotIndex < state.length - 1) {
-    try {
-      const csrfToken = state.substring(0, lastDotIndex);
-      const base64 = state.substring(lastDotIndex + 1);
-      const base64WithPadding = base64.replace(/-/g, "+").replace(/_/g, "/");
-      const paddedBase64 = base64WithPadding + "=".repeat((4 - base64WithPadding.length % 4) % 4);
-      const jsonStr = atob(paddedBase64);
-      const data = JSON.parse(jsonStr);
-      return { csrfToken, data };
-    } catch {}
-  }
-  return { csrfToken: state };
-}
-function getOAuthConfig(provider) {
-  const configGetter = OAUTH_CONFIGS[provider];
-  if (!configGetter)
-    throw new Error(`Unsupported auth provider: ${provider}`);
-  return configGetter();
-}
-var OAUTH_CONFIGS;
-var init_oauth = __esm(() => {
-  OAUTH_CONFIGS = {
-    get TIMEBACK() {
-      return getTimebackConfig;
-    }
-  };
+var init_runtime = __esm(() => {
+  init_src();
+  init_messaging();
 });
 
-// src/core/auth/flows/popup.ts
-async function initiatePopupFlow(options) {
-  const { provider, callbackUrl, onStateChange, oauth } = options;
-  try {
-    onStateChange?.({
-      status: "opening_popup",
-      message: "Opening authentication window..."
-    });
-    const defaults = getOAuthConfig(provider);
-    const config = oauth ? { ...defaults, ...oauth } : defaults;
-    if (!config.clientId) {
-      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+// src/core/cache/ttl-cache.ts
+function createTTLCache(options) {
+  const cache = new Map;
+  const { ttl: defaultTTL, keyPrefix = "", onClear } = options;
+  async function get(key, loader, config) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const now = Date.now();
+    const effectiveTTL = config?.ttl !== undefined ? config.ttl : defaultTTL;
+    const force = config?.force || false;
+    const skipCache = config?.skipCache || false;
+    if (effectiveTTL === 0 || skipCache) {
+      return loader();
     }
-    const stateData = options.stateData;
-    const state = await generateOAuthState(stateData);
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: config.clientId,
-      redirect_uri: callbackUrl,
-      state
-    });
-    if (config.scope) {
-      params.set("scope", config.scope);
-    }
-    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
-    const popup = openPopupWindow(authUrl, "playcademy-auth");
-    if (!popup || popup.closed) {
-      throw new Error("Popup blocked. Please enable popups and try again.");
+    if (!force) {
+      const cached = cache.get(fullKey);
+      if (cached && cached.expiresAt > now) {
+        return cached.value;
+      }
     }
-    onStateChange?.({
-      status: "exchanging_token",
-      message: "Waiting for authentication..."
+    const promise = loader().catch((error) => {
+      cache.delete(fullKey);
+      throw error;
     });
-    return await waitForServerMessage(popup, onStateChange);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
-    onStateChange?.({
-      status: "error",
-      message: errorMessage,
-      error: error instanceof Error ? error : new Error(errorMessage)
+    cache.set(fullKey, {
+      value: promise,
+      expiresAt: now + effectiveTTL
     });
-    throw error;
+    return promise;
   }
-}
-async function waitForServerMessage(popup, onStateChange) {
-  return new Promise((resolve) => {
-    let resolved = false;
-    const handleMessage = (event) => {
-      if (event.origin !== window.location.origin)
-        return;
-      const data = event.data;
-      if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
-        resolved = true;
-        window.removeEventListener("message", handleMessage);
-        if (data.authenticated && data.user) {
-          onStateChange?.({
-            status: "complete",
-            message: "Authentication successful"
-          });
-          resolve({
-            success: true,
-            user: data.user
-          });
-        } else {
-          const error = new Error(data.error || "Authentication failed");
-          onStateChange?.({
-            status: "error",
-            message: error.message,
-            error
-          });
-          resolve({
-            success: false,
-            error
-          });
-        }
-      }
-    };
-    window.addEventListener("message", handleMessage);
-    const checkClosed = setInterval(() => {
-      if (popup.closed && !resolved) {
-        clearInterval(checkClosed);
-        window.removeEventListener("message", handleMessage);
-        const error = new Error("Authentication cancelled");
-        onStateChange?.({
-          status: "error",
-          message: error.message,
-          error
-        });
-        resolve({
-          success: false,
-          error
-        });
-      }
-    }, 500);
-    setTimeout(() => {
-      if (!resolved) {
-        window.removeEventListener("message", handleMessage);
-        clearInterval(checkClosed);
-        const error = new Error("Authentication timeout");
-        onStateChange?.({
-          status: "error",
-          message: error.message,
-          error
-        });
-        resolve({
-          success: false,
-          error
-        });
+  function clear(key) {
+    if (key === undefined) {
+      cache.clear();
+      onClear?.();
+    } else {
+      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+      cache.delete(fullKey);
+    }
+  }
+  function size() {
+    return cache.size;
+  }
+  function prune() {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (entry.expiresAt <= now) {
+        cache.delete(key);
       }
-    }, 5 * 60 * 1000);
-  });
+    }
+  }
+  function getKeys() {
+    const keys = [];
+    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
+    for (const fullKey of cache.keys()) {
+      keys.push(fullKey.substring(prefixLen));
+    }
+    return keys;
+  }
+  function has(key) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const cached = cache.get(fullKey);
+    if (!cached)
+      return false;
+    const now = Date.now();
+    if (cached.expiresAt <= now) {
+      cache.delete(fullKey);
+      return false;
+    }
+    return true;
+  }
+  return { get, clear, size, prune, getKeys, has };
 }
-var init_popup = __esm(() => {
-  init_oauth();
-});
 
-// src/core/auth/flows/redirect.ts
-async function initiateRedirectFlow(options) {
-  const { provider, callbackUrl, onStateChange, oauth } = options;
-  try {
-    onStateChange?.({
-      status: "opening_popup",
-      message: "Redirecting to authentication provider..."
-    });
-    const defaults = getOAuthConfig(provider);
-    const config = oauth ? { ...defaults, ...oauth } : defaults;
-    if (!config.clientId) {
-      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+// 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")) {
+    try {
+      return await res.json();
+    } catch (err) {
+      if (err instanceof SyntaxError)
+        return;
+      throw err;
     }
-    const stateData = options.stateData;
-    const state = await generateOAuthState(stateData);
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: config.clientId,
-      redirect_uri: callbackUrl,
-      state
-    });
-    if (config.scope) {
-      params.set("scope", config.scope);
+  }
+  const raw = await res.text().catch(() => "");
+  return raw && raw.length > 0 ? raw : undefined;
+}
+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}`);
     }
-    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
-    window.location.href = authUrl;
-    return new Promise(() => {});
+    return await response.json();
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
-    onStateChange?.({
-      status: "error",
-      message: errorMessage,
-      error: error instanceof Error ? error : new Error(errorMessage)
+    if (error instanceof PlaycademyError) {
+      throw error;
+    }
+    log.error(`[Playcademy SDK] Error fetching or parsing manifest from ${manifestUrl}:`, {
+      error
     });
-    throw error;
+    throw new PlaycademyError("Failed to load or parse game manifest");
   }
 }
-var init_redirect = __esm(() => {
-  init_oauth();
+var init_request = __esm(() => {
+  init_src();
+  init_errors();
 });
 
-// src/core/auth/flows/unified.ts
-async function initiateUnifiedFlow(options) {
-  const { mode = "auto" } = options;
-  const effectiveMode = mode === "auto" ? isInIframe() ? "popup" : "redirect" : mode;
-  switch (effectiveMode) {
-    case "popup":
-      return initiatePopupFlow(options);
-    case "redirect":
-      return initiateRedirectFlow(options);
-    default:
-      throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
-  }
-}
-var init_unified = __esm(() => {
-  init_popup();
-  init_redirect();
-});
-
-// src/core/auth/login.ts
-async function login(client, options) {
-  try {
-    let stateData = options.stateData;
-    if (!stateData) {
-      const currentUser = client["initPayload"]?.user;
-      if (currentUser?.id) {
-        stateData = { playcademy_user_id: currentUser.id };
-      } else {
-        try {
-          const currentUser2 = await client.users.me();
-          if (currentUser2?.id) {
-            stateData = { playcademy_user_id: currentUser2.id };
-          }
-        } catch {
-          log.debug("[Playcademy SDK] No current user available for state data");
+// src/core/namespaces/games.ts
+function createGamesNamespace(client) {
+  const gamesListCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "games.list"
+  });
+  const gameFetchCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "games.fetch"
+  });
+  return {
+    fetch: async (gameIdOrSlug, options) => {
+      const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
+      return gameFetchCache.get(gameIdOrSlug, async () => {
+        const baseGameData = await promise;
+        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null) {
+          const manifestData = await fetchManifest(baseGameData.assetBundleBase);
+          return { ...baseGameData, manifest: manifestData };
         }
+        return baseGameData;
+      }, options);
+    },
+    list: (options) => {
+      return gamesListCache.get("all", () => client["request"]("/games", "GET"), options);
+    },
+    saveState: async (state) => {
+      const gameId = client["_ensureGameId"]();
+      await client["request"](`/games/${gameId}/state`, "POST", 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;
       }
-    }
-    log.debug("[Playcademy SDK] Starting OAuth login", {
-      provider: options.provider,
-      mode: options.mode || "auto",
-      callbackUrl: options.callbackUrl,
-      hasStateData: !!stateData
-    });
-    const optionsWithState = {
-      ...options,
-      stateData
-    };
-    const result = await initiateUnifiedFlow(optionsWithState);
-    if (result.success && result.user) {
-      log.debug("[Playcademy SDK] OAuth login successful", {
-        userId: result.user.sub
-      });
-    }
-    return result;
-  } catch (error) {
-    log.error("[Playcademy SDK] OAuth login failed", { error });
-    const authError = error instanceof Error ? error : new Error("Authentication failed");
-    return {
-      success: false,
-      error: authError
-    };
-  }
-}
-var init_login = __esm(() => {
-  init_src();
-  init_unified();
-});
-
-// src/core/namespaces/identity.ts
-function createIdentityNamespace(client) {
-  return {
-    get user() {
-      return client["initPayload"]?.user ?? null;
+      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
     },
-    connect: (options) => login(client, options),
-    _getContext: () => ({
-      isInIframe: client["authContext"]?.isInIframe ?? false
-    })
+    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_identity = __esm(() => {
-  init_login();
+var init_games = __esm(() => {
+  init_request();
 });
 
-// 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
+// src/core/cache/permanent-cache.ts
+function createPermanentCache(keyPrefix) {
+  const cache = new Map;
+  async function get(key, loader) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const existing = cache.get(fullKey);
+    if (existing)
+      return existing;
+    const promise = loader().catch((error) => {
+      cache.delete(fullKey);
+      throw error;
     });
-    window.addEventListener("message", postMessageListener);
-    window.addEventListener(type, customEventListener);
+    cache.set(fullKey, promise);
+    return promise;
   }
-  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);
+  function clear(key) {
+    if (key === undefined) {
+      cache.clear();
+    } else {
+      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+      cache.delete(fullKey);
     }
   }
-  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: "*"
-    };
+  function has(key) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    return cache.has(fullKey);
   }
-  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
-    const messageData = { type };
-    if (payload !== undefined) {
-      messageData.payload = payload;
-    }
-    target.postMessage(messageData, origin);
+  function size() {
+    return cache.size;
   }
-  sendViaCustomEvent(type, payload) {
-    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  function keys() {
+    const result = [];
+    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
+    for (const fullKey of cache.keys()) {
+      result.push(fullKey.substring(prefixLen));
+    }
+    return result;
   }
+  return { get, clear, has, size, keys };
 }
-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";
-    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
-    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
-  })(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);
+// src/core/namespaces/users.ts
+function createUsersNamespace(client) {
+  const itemIdCache = createPermanentCache("items");
+  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const resolveItemId = async (identifier) => {
+    if (UUID_REGEX.test(identifier))
+      return identifier;
+    const gameId = client["gameId"];
+    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
+    return itemIdCache.get(cacheKey, async () => {
+      const queryParams = new URLSearchParams({ slug: identifier });
+      if (gameId)
+        queryParams.append("gameId", gameId);
+      const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      return item.id;
     });
-  }
+  };
   return {
-    getGameToken: async (gameId, options) => {
-      const res = await client["request"](`/games/${gameId}/token`, "POST");
-      if (options?.apply) {
-        client.setToken(res.token);
-      }
-      return res;
+    me: async () => {
+      return client["request"]("/users/me", "GET");
     },
-    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
-          });
-        }
+    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;
       }
-      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);
+    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");
       }
-      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();
-});
+var init_users = () => {};
 
-// src/core/cache/ttl-cache.ts
-function createTTLCache(options) {
-  const cache = new Map;
-  const { ttl: defaultTTL, keyPrefix = "", onClear } = options;
-  async function get(key, loader, config) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const now = Date.now();
-    const effectiveTTL = config?.ttl !== undefined ? config.ttl : defaultTTL;
-    const force = config?.force || false;
-    const skipCache = config?.skipCache || false;
-    if (effectiveTTL === 0 || skipCache) {
-      return loader();
-    }
-    if (!force) {
-      const cached = cache.get(fullKey);
-      if (cached && cached.expiresAt > now) {
-        return cached.value;
-      }
-    }
-    const promise = loader().catch((error) => {
-      cache.delete(fullKey);
-      throw error;
-    });
-    cache.set(fullKey, {
-      value: promise,
-      expiresAt: now + effectiveTTL
-    });
-    return promise;
-  }
-  function clear(key) {
-    if (key === undefined) {
-      cache.clear();
-      onClear?.();
-    } else {
-      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-      cache.delete(fullKey);
-    }
-  }
-  function size() {
-    return cache.size;
-  }
-  function prune() {
-    const now = Date.now();
-    for (const [key, entry] of cache.entries()) {
-      if (entry.expiresAt <= now) {
-        cache.delete(key);
+// src/core/namespaces/dev.ts
+function createDevNamespace(client) {
+  return {
+    status: {
+      apply: () => client["request"]("/dev/apply", "POST"),
+      get: async () => {
+        const response = await client["request"]("/dev/status", "GET");
+        return response.status;
+      }
+    },
+    games: {
+      upsert: async (slug, metadata, file, hooks) => {
+        hooks?.onEvent?.({ type: "init" });
+        const game = await client["request"](`/games/${slug}`, "PUT", metadata);
+        if (metadata.gameType === "external" || file === null) {
+          return game;
+        }
+        const fileName = file instanceof File ? file.name : "game.zip";
+        const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
+          fileName,
+          gameId: game.id
+        });
+        if (hooks?.onEvent) {
+          await new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest;
+            xhr.open("PUT", initiateResponse.presignedUrl, true);
+            const contentType = file.type || "application/octet-stream";
+            try {
+              xhr.setRequestHeader("Content-Type", contentType);
+            } catch {}
+            xhr.upload.onprogress = (event) => {
+              if (event.lengthComputable) {
+                const percent = event.loaded / event.total;
+                hooks.onEvent?.({
+                  type: "s3Progress",
+                  loaded: event.loaded,
+                  total: event.total,
+                  percent
+                });
+              }
+            };
+            xhr.onload = () => {
+              if (xhr.status >= 200 && xhr.status < 300)
+                resolve();
+              else
+                reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
+            };
+            xhr.onerror = () => reject(new Error("File upload failed: network error"));
+            xhr.send(file);
+          });
+        } else {
+          const uploadResponse = await fetch(initiateResponse.presignedUrl, {
+            method: "PUT",
+            body: file,
+            headers: {
+              "Content-Type": file.type || "application/octet-stream"
+            }
+          });
+          if (!uploadResponse.ok) {
+            throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+          }
+        }
+        const baseUrl = (() => {
+          const anyClient = client;
+          try {
+            return typeof anyClient.getBaseUrl === "function" ? anyClient.getBaseUrl() : "/api";
+          } catch {
+            return "/api";
+          }
+        })();
+        const finalizeUrl = baseUrl.replace(/\/$/, "") + "/games/uploads/finalize/";
+        const authToken = client.token;
+        const finalizeResponse = await fetch(finalizeUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
+          },
+          body: JSON.stringify({
+            tempS3Key: initiateResponse.tempS3Key,
+            gameId: initiateResponse.gameId,
+            version: initiateResponse.version,
+            slug,
+            metadata,
+            originalFileName: fileName
+          }),
+          credentials: "omit"
+        });
+        if (!finalizeResponse.ok) {
+          const errText = await finalizeResponse.text().catch(() => "");
+          throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
+        }
+        if (!finalizeResponse.body) {
+          throw new Error("Finalize response body missing");
+        }
+        hooks?.onEvent?.({ type: "finalizeStart" });
+        let sawAnyServerEvent = false;
+        const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (!sawAnyServerEvent) {
+              hooks?.onClose?.();
+              hooks?.onEvent?.({ type: "close" });
+            }
+            break;
+          }
+          buffer += value;
+          let eolIndex;
+          while ((eolIndex = buffer.indexOf(`
+
+`)) >= 0) {
+            const message = buffer.slice(0, eolIndex);
+            buffer = buffer.slice(eolIndex + 2);
+            const eventLine = message.match(/^event: (.*)$/m);
+            const dataLine = message.match(/^data: (.*)$/m);
+            if (eventLine && dataLine) {
+              const eventType = eventLine[1];
+              const eventData = JSON.parse(dataLine[1]);
+              if (eventType === "uploadProgress") {
+                sawAnyServerEvent = true;
+                const percent = (eventData.value ?? 0) / 100;
+                hooks?.onEvent?.({
+                  type: "finalizeProgress",
+                  percent,
+                  currentFileLabel: eventData.currentFileLabel || ""
+                });
+              } else if (eventType === "status") {
+                sawAnyServerEvent = true;
+                if (eventData.message) {
+                  hooks?.onEvent?.({
+                    type: "finalizeStatus",
+                    message: eventData.message
+                  });
+                }
+              } else if (eventType === "complete") {
+                sawAnyServerEvent = true;
+                reader.cancel();
+                return eventData;
+              } else if (eventType === "error") {
+                sawAnyServerEvent = true;
+                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");
+        }
       }
     }
-  }
-  function getKeys() {
-    const keys = [];
-    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
-    for (const fullKey of cache.keys()) {
-      keys.push(fullKey.substring(prefixLen));
-    }
-    return keys;
-  }
-  function has(key) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const cached = cache.get(fullKey);
-    if (!cached)
-      return false;
-    const now = Date.now();
-    if (cached.expiresAt <= now) {
-      cache.delete(fullKey);
-      return false;
-    }
-    return true;
-  }
-  return { get, clear, size, prune, getKeys, has };
-}
-
-// 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")) {
-    try {
-      return await res.json();
-    } catch (err) {
-      if (err instanceof SyntaxError)
-        return;
-      throw err;
-    }
-  }
-  const raw = await res.text().catch(() => "");
-  return raw && raw.length > 0 ? raw : undefined;
+  };
 }
-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;
+
+// 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")
     }
-    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) {
-  const gamesListCache = createTTLCache({
-    ttl: 60 * 1000,
-    keyPrefix: "games.list"
-  });
-  const gameFetchCache = createTTLCache({
-    ttl: 60 * 1000,
-    keyPrefix: "games.fetch"
-  });
+// src/core/namespaces/admin.ts
+function createAdminNamespace(client) {
   return {
-    fetch: async (gameIdOrSlug, options) => {
-      const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
-      return gameFetchCache.get(gameIdOrSlug, async () => {
-        const baseGameData = await promise;
-        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null) {
-          const manifestData = await fetchManifest(baseGameData.assetBundleBase);
-          return { ...baseGameData, manifest: manifestData };
-        }
-        return baseGameData;
-      }, options);
-    },
-    list: (options) => {
-      return gamesListCache.get("all", () => client["request"]("/games", "GET"), options);
-    },
-    saveState: async (state) => {
-      const gameId = client["_ensureGameId"]();
-      await client["request"](`/games/${gameId}/state`, "POST", 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", {});
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "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");
+    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")
     },
-    token: {
-      create: async (gameId, options) => {
-        const res = await client["request"](`/games/${gameId}/token`, "POST");
-        if (options?.apply) {
-          client.setToken(res.token);
-        }
-        return res;
-      }
+    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")
     },
-    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");
-      }
+    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")
     }
   };
 }
-var init_games = __esm(() => {
-  init_request();
-});
 
-// src/core/cache/permanent-cache.ts
-function createPermanentCache(keyPrefix) {
-  const cache = new Map;
-  async function get(key, loader) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const existing = cache.get(fullKey);
-    if (existing)
-      return existing;
-    const promise = loader().catch((error) => {
-      cache.delete(fullKey);
+// 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/cache/cooldown-cache.ts
+function createCooldownCache(defaultCooldownMs) {
+  const lastFetchTime = new Map;
+  const pendingRequests = new Map;
+  const lastResults = new Map;
+  async function get(key, loader, config) {
+    const now = Date.now();
+    const lastFetch = lastFetchTime.get(key) || 0;
+    const timeSinceLastFetch = now - lastFetch;
+    const effectiveCooldown = config?.cooldown !== undefined ? config.cooldown : defaultCooldownMs;
+    const force = config?.force || false;
+    const pending = pendingRequests.get(key);
+    if (pending) {
+      return pending;
+    }
+    if (!force && timeSinceLastFetch < effectiveCooldown) {
+      const cachedResult = lastResults.get(key);
+      if (cachedResult !== undefined) {
+        return Promise.resolve(cachedResult);
+      }
+    }
+    const promise = loader().then((result) => {
+      pendingRequests.delete(key);
+      lastFetchTime.set(key, Date.now());
+      lastResults.set(key, result);
+      return result;
+    }).catch((error) => {
+      pendingRequests.delete(key);
       throw error;
     });
-    cache.set(fullKey, promise);
+    pendingRequests.set(key, promise);
     return promise;
   }
   function clear(key) {
     if (key === undefined) {
-      cache.clear();
+      lastFetchTime.clear();
+      pendingRequests.clear();
+      lastResults.clear();
     } else {
-      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-      cache.delete(fullKey);
-    }
-  }
-  function has(key) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    return cache.has(fullKey);
-  }
-  function size() {
-    return cache.size;
-  }
-  function keys() {
-    const result = [];
-    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
-    for (const fullKey of cache.keys()) {
-      result.push(fullKey.substring(prefixLen));
+      lastFetchTime.delete(key);
+      pendingRequests.delete(key);
+      lastResults.delete(key);
     }
-    return result;
   }
-  return { get, clear, has, size, keys };
+  return { get, clear };
 }
 
-// src/core/namespaces/users.ts
-function createUsersNamespace(client) {
-  const itemIdCache = createPermanentCache("items");
-  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  const resolveItemId = async (identifier) => {
-    if (UUID_REGEX.test(identifier))
-      return identifier;
-    const gameId = client["gameId"];
-    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
-    return itemIdCache.get(cacheKey, async () => {
-      const queryParams = new URLSearchParams({ slug: identifier });
-      if (gameId)
-        queryParams.append("gameId", gameId);
-      const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
-      return item.id;
-    });
-  };
+// src/core/namespaces/levels.ts
+function createLevelsNamespace(client) {
+  const progressCache = createCooldownCache(5000);
   return {
-    me: async () => {
-      return client["request"]("/users/me", "GET");
+    get: async () => {
+      return client["request"]("/users/level", "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;
-      }
+    progress: async (options) => {
+      return progressCache.get("user-progress", () => client["request"]("/users/level/progress", "GET"), options);
     },
-    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");
+    config: {
+      list: async () => {
+        return client["request"]("/levels/config", "GET");
+      },
+      get: async (level) => {
+        return client["request"](`/levels/config/${level}`, "GET");
       }
     }
   };
 }
-var init_users = () => {};
+var init_levels = () => {};
 
-// src/core/namespaces/dev.ts
-function createDevNamespace(client) {
-  return {
-    status: {
-      apply: () => client["request"]("/dev/apply", "POST"),
-      get: async () => {
-        const response = await client["request"]("/dev/status", "GET");
-        return response.status;
-      }
-    },
-    games: {
-      upsert: async (slug, metadata, file, hooks) => {
-        hooks?.onEvent?.({ type: "init" });
-        const game = await client["request"](`/games/${slug}`, "PUT", metadata);
-        if (metadata.gameType === "external" || file === null) {
-          return game;
-        }
-        const fileName = file instanceof File ? file.name : "game.zip";
-        const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
-          fileName,
-          gameId: game.id
-        });
-        if (hooks?.onEvent) {
-          await new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest;
-            xhr.open("PUT", initiateResponse.presignedUrl, true);
-            const contentType = file.type || "application/octet-stream";
-            try {
-              xhr.setRequestHeader("Content-Type", contentType);
-            } catch {}
-            xhr.upload.onprogress = (event) => {
-              if (event.lengthComputable) {
-                const percent = event.loaded / event.total;
-                hooks.onEvent?.({
-                  type: "s3Progress",
-                  loaded: event.loaded,
-                  total: event.total,
-                  percent
-                });
-              }
-            };
-            xhr.onload = () => {
-              if (xhr.status >= 200 && xhr.status < 300)
-                resolve();
-              else
-                reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
-            };
-            xhr.onerror = () => reject(new Error("File upload failed: network error"));
-            xhr.send(file);
-          });
-        } else {
-          const uploadResponse = await fetch(initiateResponse.presignedUrl, {
-            method: "PUT",
-            body: file,
-            headers: {
-              "Content-Type": file.type || "application/octet-stream"
-            }
-          });
-          if (!uploadResponse.ok) {
-            throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
-          }
-        }
-        const baseUrl = (() => {
-          const anyClient = client;
-          try {
-            return typeof anyClient.getBaseUrl === "function" ? anyClient.getBaseUrl() : "/api";
-          } catch {
-            return "/api";
-          }
-        })();
-        const finalizeUrl = baseUrl.replace(/\/$/, "") + "/games/uploads/finalize/";
-        const authToken = client.token;
-        const finalizeResponse = await fetch(finalizeUrl, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
-          },
-          body: JSON.stringify({
-            tempS3Key: initiateResponse.tempS3Key,
-            gameId: initiateResponse.gameId,
-            version: initiateResponse.version,
-            slug,
-            metadata,
-            originalFileName: fileName
-          }),
-          credentials: "omit"
-        });
-        if (!finalizeResponse.ok) {
-          const errText = await finalizeResponse.text().catch(() => "");
-          throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
-        }
-        if (!finalizeResponse.body) {
-          throw new Error("Finalize response body missing");
-        }
-        hooks?.onEvent?.({ type: "finalizeStart" });
-        let sawAnyServerEvent = false;
-        const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            if (!sawAnyServerEvent) {
-              hooks?.onClose?.();
-              hooks?.onEvent?.({ type: "close" });
-            }
-            break;
-          }
-          buffer += value;
-          let eolIndex;
-          while ((eolIndex = buffer.indexOf(`
+// ../data/src/domains/game/table.ts
+import {
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+  varchar
+} from "drizzle-orm/pg-core";
+var gamePlatformEnum, gameBootModeEnum, gameTypeEnum, 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"]);
+  gameTypeEnum = pgEnum("game_type", ["hosted", "external"]);
+  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(),
+    gameType: gameTypeEnum("game_type").notNull().default("hosted"),
+    assetBundleBase: text("asset_bundle_base"),
+    externalUrl: text("external_url"),
+    platform: gamePlatformEnum("platform").notNull().default("web"),
+    mapElementId: uuid("map_element_id").references(() => mapElements.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb("metadata").$type().notNull().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]
+    })
+  }));
+});
 
-`)) >= 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 === "uploadProgress") {
-                sawAnyServerEvent = true;
-                const percent = (eventData.value ?? 0) / 100;
-                hooks?.onEvent?.({
-                  type: "finalizeProgress",
-                  percent,
-                  currentFileLabel: eventData.currentFileLabel || ""
-                });
-              } else if (eventType === "status") {
-                sawAnyServerEvent = true;
-                if (eventData.message) {
-                  hooks?.onEvent?.({
-                    type: "finalizeStatus",
-                    message: eventData.message
-                  });
-                }
-              } else if (eventType === "complete") {
-                sawAnyServerEvent = true;
-                reader.cancel();
-                return eventData;
-              } else if (eventType === "error") {
-                sawAnyServerEvent = true;
-                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");
-        }
-      }
-    }
-  };
-}
+// ../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, ssoProvider, 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(),
+    timebackId: text4("timeback_id").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()
+  });
+  ssoProvider = pgTable4("sso_provider", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    issuer: text4("issuer").notNull(),
+    oidcConfig: text4("oidc_config"),
+    samlConfig: text4("saml_config"),
+    userId: text4("user_id").references(() => users.id, { onDelete: "cascade" }),
+    providerId: text4("provider_id").notNull().unique(),
+    organizationId: text4("organization_id"),
+    domain: text4("domain").notNull()
+  });
+  usersRelations = relations3(users, ({ many }) => ({
+    mapObjects: many(mapObjects)
+  }));
+});
 
-// 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")
-    }
-  };
-}
+// ../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()
+  });
+});
 
-// 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")
-    }
-  };
-}
+// ../data/src/domains/level/table.ts
+import { relations as relations4 } from "drizzle-orm";
+import {
+  doublePrecision as doublePrecision2,
+  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: doublePrecision2("current_xp").notNull().default(0),
+    totalXP: doublePrecision2("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,
+  uniqueIndex as uniqueIndex6,
+  uuid as uuid8,
+  varchar as varchar5
+} from "drizzle-orm/pg-core";
+var characterComponentTypeEnum, characterComponents, playerCharacters, playerCharacterAccessories, characterComponentsRelations, playerCharactersRelations, playerCharacterAccessoriesRelations;
+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" }),
+    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  playerCharacterAccessories = pgTable9("player_character_accessories", {
+    id: uuid8("id").primaryKey().defaultRandom(),
+    playerCharacterId: uuid8("player_character_id").notNull().references(() => playerCharacters.id, { onDelete: "cascade" }),
+    accessoryComponentId: uuid8("accessory_component_id").notNull().references(() => characterComponents.id, { onDelete: "cascade" }),
+    slot: varchar5("slot", { length: 64 }).notNull(),
+    equippedAt: timestamp9("equipped_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table) => [
+    uniqueIndex6("unique_player_character_slot_idx").on(table.playerCharacterId, table.slot),
+    uniqueIndex6("player_character_accessory_idx").on(table.playerCharacterId, table.accessoryComponentId)
+  ]);
+  characterComponentsRelations = relations7(characterComponents, ({ one }) => ({
+    sheet: one(spriteSheets, {
+      fields: [characterComponents.spriteSheetId],
+      references: [spriteSheets.id]
+    })
+  }));
+  playerCharactersRelations = relations7(playerCharacters, ({ one, many }) => ({
+    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]
+    }),
+    accessories: many(playerCharacterAccessories)
+  }));
+  playerCharacterAccessoriesRelations = relations7(playerCharacterAccessories, ({ one }) => ({
+    playerCharacter: one(playerCharacters, {
+      fields: [playerCharacterAccessories.playerCharacterId],
+      references: [playerCharacters.id]
+    }),
+    accessoryComponent: one(characterComponents, {
+      fields: [playerCharacterAccessories.accessoryComponentId],
+      references: [characterComponents.id]
+    })
+  }));
+});
 
-// src/core/namespaces/shop.ts
-function createShopNamespace(client) {
-  return {
-    view: () => {
-      return client["request"]("/shop/view", "GET");
-    }
-  };
-}
+// ../data/src/domains/timeback/table.ts
+import { doublePrecision as doublePrecision3, pgTable as pgTable10, text as text9, timestamp as timestamp10, uniqueIndex as uniqueIndex7, uuid as uuid9 } from "drizzle-orm/pg-core";
+var timebackDailyXp, timebackXpEvents;
+var init_table10 = __esm(() => {
+  init_table4();
+  timebackDailyXp = pgTable10("timeback_daily_xp", {
+    userId: text9("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    date: timestamp10("date", { mode: "date", withTimezone: true }).notNull(),
+    xp: doublePrecision3("xp").notNull().default(0),
+    createdAt: timestamp10("created_at", { mode: "date", withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp10("updated_at", { mode: "date", withTimezone: true }).notNull().defaultNow()
+  }, (table) => [uniqueIndex7("timeback_daily_xp_user_date_idx").on(table.userId, table.date)]);
+  timebackXpEvents = pgTable10("timeback_xp_event", {
+    id: uuid9("id").primaryKey().defaultRandom(),
+    userId: text9("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    occurredAt: timestamp10("occurred_at", { withTimezone: true }).notNull(),
+    xpDelta: doublePrecision3("xp_delta").notNull(),
+    source: text9("source").notNull(),
+    sourceId: text9("source_id"),
+    sensor: text9("sensor"),
+    appName: text9("app_name"),
+    createdAt: timestamp10("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp10("updated_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table) => [uniqueIndex7("timeback_xp_events_source_id_idx").on(table.source, table.sourceId)]);
+});
 
-// src/core/namespaces/telemetry.ts
-function createTelemetryNamespace(client) {
-  return {
-    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", metrics)
-  };
-}
+// ../data/src/domains/achievement/table.ts
+import { relations as relations8 } from "drizzle-orm";
+import {
+  boolean as boolean3,
+  index as index3,
+  integer as integer7,
+  jsonb as jsonb5,
+  pgEnum as pgEnum6,
+  pgTable as pgTable11,
+  text as text10,
+  timestamp as timestamp11,
+  uniqueIndex as uniqueIndex8,
+  uuid as uuid10,
+  varchar as varchar6
+} from "drizzle-orm/pg-core";
+var achievementIntervalEnum, achievements, userAchievementProgress, userAchievementClaims, userAchievementProgressRelations, userAchievementClaimsRelations;
+var init_table11 = __esm(() => {
+  init_table4();
+  achievementIntervalEnum = pgEnum6("achievement_interval", ["daily", "weekly"]);
+  achievements = pgTable11("achievements", {
+    id: varchar6("id", { length: 255 }).primaryKey(),
+    title: varchar6("title", { length: 255 }).notNull(),
+    description: text10("description"),
+    intervalType: achievementIntervalEnum("interval_type").notNull(),
+    rewardCredits: integer7("reward_credits").notNull().default(0),
+    limitPerInterval: integer7("limit_per_interval").notNull().default(1),
+    completionType: varchar6("completion_type", { length: 50 }).notNull(),
+    completionConfig: jsonb5("completion_config").notNull().default({}),
+    scope: jsonb5("scope").notNull().default({}),
+    active: boolean3("active").notNull().default(true),
+    createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp11("updated_at", { withTimezone: true }).defaultNow()
+  });
+  userAchievementProgress = pgTable11("user_achievement_progress", {
+    id: uuid10("id").primaryKey().defaultRandom(),
+    userId: text10("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    achievementId: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
+    intervalKey: text10("interval_key").notNull(),
+    progress: jsonb5("progress").notNull().default({}),
+    updatedAt: timestamp11("updated_at", { withTimezone: true }).defaultNow().notNull()
+  }, (table) => [
+    index3("user_achievement_progress_idx").on(table.userId, table.achievementId, table.intervalKey)
+  ]);
+  userAchievementClaims = pgTable11("user_achievement_claims", {
+    id: uuid10("id").primaryKey().defaultRandom(),
+    userId: text10("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    achievementId: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
+    intervalKey: text10("interval_key").notNull(),
+    rewardCredits: integer7("reward_credits").notNull(),
+    createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow().notNull()
+  }, (table) => [
+    uniqueIndex8("user_achievement_claims_unique").on(table.userId, table.achievementId, table.intervalKey)
+  ]);
+  userAchievementProgressRelations = relations8(userAchievementProgress, ({ one }) => ({
+    user: one(users, {
+      fields: [userAchievementProgress.userId],
+      references: [users.id]
+    }),
+    achievement: one(achievements, {
+      fields: [userAchievementProgress.achievementId],
+      references: [achievements.id]
+    })
+  }));
+  userAchievementClaimsRelations = relations8(userAchievementClaims, ({ one }) => ({
+    user: one(users, {
+      fields: [userAchievementClaims.userId],
+      references: [users.id]
+    }),
+    achievement: one(achievements, {
+      fields: [userAchievementClaims.achievementId],
+      references: [achievements.id]
+    })
+  }));
+});
 
-// src/core/cache/cooldown-cache.ts
-function createCooldownCache(defaultCooldownMs) {
-  const lastFetchTime = new Map;
-  const pendingRequests = new Map;
-  const lastResults = new Map;
-  async function get(key, loader, config) {
-    const now = Date.now();
-    const lastFetch = lastFetchTime.get(key) || 0;
-    const timeSinceLastFetch = now - lastFetch;
-    const effectiveCooldown = config?.cooldown !== undefined ? config.cooldown : defaultCooldownMs;
-    const force = config?.force || false;
-    const pending = pendingRequests.get(key);
-    if (pending) {
-      return pending;
-    }
-    if (!force && timeSinceLastFetch < effectiveCooldown) {
-      const cachedResult = lastResults.get(key);
-      if (cachedResult !== undefined) {
-        return Promise.resolve(cachedResult);
-      }
-    }
-    const promise = loader().then((result) => {
-      pendingRequests.delete(key);
-      lastFetchTime.set(key, Date.now());
-      lastResults.set(key, result);
-      return result;
-    }).catch((error) => {
-      pendingRequests.delete(key);
-      throw error;
-    });
-    pendingRequests.set(key, promise);
-    return promise;
-  }
-  function clear(key) {
-    if (key === undefined) {
-      lastFetchTime.clear();
-      pendingRequests.clear();
-      lastResults.clear();
-    } else {
-      lastFetchTime.delete(key);
-      pendingRequests.delete(key);
-      lastResults.delete(key);
-    }
-  }
-  return { get, clear };
-}
+// ../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();
+  init_table10();
+  init_table11();
+});
 
-// src/core/namespaces/levels.ts
-function createLevelsNamespace(client) {
-  const progressCache = createCooldownCache(5000);
-  return {
-    get: async () => {
-      return client["request"]("/users/level", "GET");
-    },
-    progress: async (options) => {
-      return progressCache.get("user-progress", () => client["request"]("/users/level/progress", "GET"), options);
-    },
-    config: {
-      list: async () => {
-        return client["request"]("/levels/config", "GET");
-      },
-      get: async (level) => {
-        return client["request"](`/levels/config/${level}`, "GET");
-      }
-    }
+// ../data/src/constants.ts
+var ITEM_SLUGS, CURRENCIES, BADGES, ACHIEVEMENT_COMPLETION_TYPES, ACHIEVEMENT_COMPLETION_TYPE, 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"
   };
-}
-var init_levels = () => {};
+  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
+  };
+  ACHIEVEMENT_COMPLETION_TYPES = [
+    "time_played_session",
+    "interaction",
+    "leaderboard_rank"
+  ];
+  ACHIEVEMENT_COMPLETION_TYPE = Object.fromEntries(ACHIEVEMENT_COMPLETION_TYPES.map((value) => [value, value]));
+  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
+});
 
 // src/core/cache/singleton-cache.ts
 function createSingletonCache() {
@@ -2636,7 +2647,8 @@ async function init() {
   const client = new PlaycademyClient({
     baseUrl: config.baseUrl,
     token: config.token,
-    gameId: config.gameId
+    gameId: config.gameId,
+    autoStartSession: window.self !== window.top
   });
   client["initPayload"] = config;
   messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
@@ -2713,6 +2725,7 @@ var init_client = __esm(() => {
     baseUrl;
     token;
     gameId;
+    config;
     listeners = {};
     internalClientSessionId;
     authContext;
@@ -2727,14 +2740,9 @@ var init_client = __esm(() => {
         this.token = config.token;
         this.gameId = config.gameId;
       }
-      this.detectAuthContext();
-      if (this.gameId) {
-        this._initializeInternalSession().catch((error) => {
-          log.error("[Playcademy SDK] Background initialization of auto-session failed:", {
-            error
-          });
-        });
-      }
+      this.config = config || {};
+      this._detectAuthContext();
+      this._initializeInternalSession().catch(() => {});
     }
     getBaseUrl() {
       const isRelative = this.baseUrl.startsWith("/");
@@ -2783,16 +2791,22 @@ var init_client = __esm(() => {
       }
       return this.gameId;
     }
-    detectAuthContext() {
+    _detectAuthContext() {
       this.authContext = { isInIframe: isInIframe() };
     }
     async _initializeInternalSession() {
-      if (!this.gameId || this.internalClientSessionId) {
+      if (!this.gameId || this.internalClientSessionId)
+        return;
+      const shouldAutoStart = this.config.autoStartSession ?? true;
+      if (!shouldAutoStart)
         return;
-      }
       try {
         const response = await this.games.startSession(this.gameId);
         this.internalClientSessionId = response.sessionId;
+        log.debug("[Playcademy SDK] Auto-started game session", {
+          gameId: this.gameId,
+          sessionId: this.internalClientSessionId
+        });
       } catch (error) {
         log.error("[Playcademy SDK] Auto-starting session failed for game", {
           gameId: this.gameId,
@@ -2825,18 +2839,28 @@ var init_client = __esm(() => {
   };
 });
 
-// src/types.ts
-init_constants();
-var AuthProvider = {
-  TIMEBACK: "TIMEBACK"
-};
-
 // src/index.ts
 init_client();
 init_messaging();
+
+// src/constants.ts
+var CURRENCIES2 = {
+  PRIMARY: "PLAYCADEMY_CREDITS",
+  XP: "PLAYCADEMY_XP"
+};
+var BADGES2 = {
+  FOUNDING_MEMBER: "FOUNDING_MEMBER_BADGE",
+  EARLY_ADOPTER: "EARLY_ADOPTER_BADGE",
+  FIRST_GAME: "FIRST_GAME_BADGE"
+};
+var AuthProvider = {
+  TIMEBACK: "TIMEBACK"
+};
 export {
   messaging,
   PlaycademyClient,
   MessageEvents,
+  CURRENCIES2 as CURRENCIES,
+  BADGES2 as BADGES,
   AuthProvider
 };