@playcademy/sdk 0.0.1-beta.9 → 0.0.2

package/dist/index.js

@@ -0,0 +1,2846 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../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]
+    })
+  }));
+});
+
+// ../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)
+  }));
+});
+
+// ../data/src/domains/developer/table.ts
+import { pgTable as pgTable5, text as text5, timestamp as timestamp5, uuid as uuid4, varchar as varchar3 } from "drizzle-orm/pg-core";
+var developerKeys;
+var init_table5 = __esm(() => {
+  init_table4();
+  developerKeys = pgTable5("developer_keys", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    label: varchar3("label", { length: 255 }),
+    keyHash: text5("key_hash").notNull().unique(),
+    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow()
+  });
+});
+
+// ../data/src/domains/level/table.ts
+import { relations as relations4 } from "drizzle-orm";
+import {
+  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]
+    })
+  }));
+});
+
+// ../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)]);
+});
+
+// ../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]
+    })
+  }));
+});
+
+// ../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();
+});
+
+// ../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
+  };
+  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]));
+});
+
+// ../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 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);
+  }
+}, 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}`);
+    }
+  } else {}
+}, getConsoleMethod = (level) => {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+}, performLog = (level, message, context) => {
+  if (level === "debug" && false) {}
+  if (isBrowser()) {
+    logInBrowser(level, message, context);
+  } else {
+    logOnServer(level, message, context);
+  }
+}, createLogger = () => {
+  return {
+    debug: (message, context) => performLog("debug", message, context),
+    info: (message, context) => performLog("info", message, context),
+    warn: (message, context) => performLog("warn", message, context),
+    error: (message, context) => performLog("error", message, context),
+    log: performLog
+  };
+}, log;
+var init_src = __esm(() => {
+  colors = {
+    reset: "\x1B[0m",
+    dim: "\x1B[2m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    cyan: "\x1B[36m",
+    gray: "\x1B[90m"
+  };
+  log = createLogger();
+});
+
+// src/core/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);
+    }
+  };
+});
+
+// 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);
+    }
+  };
+}
+
+// ../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;
+    }
+  };
+});
+
+// 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);
+  });
+}
+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.");
+    }
+    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();
+});
+
+// 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 storedUserId = client["userId"];
+      if (storedUserId) {
+        stateData = {
+          playcademy_user_id: storedUserId,
+          game_id: client["gameId"] || ""
+        };
+      } else {
+        try {
+          const currentUser = await client.users.me();
+          if (currentUser?.id) {
+            stateData = {
+              playcademy_user_id: currentUser.id,
+              game_id: client["gameId"] || ""
+            };
+          }
+        } 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 enrichedOptions = {
+      ...options,
+      stateData
+    };
+    const result = await initiateUnifiedFlow(enrichedOptions);
+    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 {
+    connect: (options) => login(client, options),
+    _getContext: () => ({
+      isInIframe: client["authContext"]?.isInIframe ?? false
+    })
+  };
+}
+var init_identity = __esm(() => {
+  init_login();
+});
+
+// src/messaging.ts
+class PlaycademyMessaging {
+  listeners = new Map;
+  send(type, payload, options) {
+    if (options?.target) {
+      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
+      return;
+    }
+    const context = this.getMessagingContext(type);
+    if (context.shouldUsePostMessage) {
+      this.sendViaPostMessage(type, payload, context.target, context.origin);
+    } else {
+      this.sendViaCustomEvent(type, payload);
+    }
+  }
+  listen(type, handler) {
+    const postMessageListener = (event) => {
+      const messageEvent = event;
+      if (messageEvent.data?.type === type) {
+        handler(messageEvent.data.payload || messageEvent.data);
+      }
+    };
+    const customEventListener = (event) => {
+      handler(event.detail);
+    };
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Map);
+    }
+    const listenerMap = this.listeners.get(type);
+    listenerMap.set(handler, {
+      postMessage: postMessageListener,
+      customEvent: customEventListener
+    });
+    window.addEventListener("message", postMessageListener);
+    window.addEventListener(type, customEventListener);
+  }
+  unlisten(type, handler) {
+    const typeListeners = this.listeners.get(type);
+    if (!typeListeners || !typeListeners.has(handler)) {
+      return;
+    }
+    const listeners = typeListeners.get(handler);
+    window.removeEventListener("message", listeners.postMessage);
+    window.removeEventListener(type, listeners.customEvent);
+    typeListeners.delete(handler);
+    if (typeListeners.size === 0) {
+      this.listeners.delete(type);
+    }
+  }
+  getMessagingContext(eventType) {
+    const isIframe = typeof window !== "undefined" && window.self !== window.top;
+    const iframeToParentEvents = [
+      "PLAYCADEMY_READY" /* READY */,
+      "PLAYCADEMY_EXIT" /* EXIT */,
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
+      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */
+    ];
+    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    return {
+      shouldUsePostMessage,
+      target: shouldUsePostMessage ? window.parent : undefined,
+      origin: "*"
+    };
+  }
+  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
+    const messageData = { type };
+    if (payload !== undefined) {
+      messageData.payload = payload;
+    }
+    target.postMessage(messageData, origin);
+  }
+  sendViaCustomEvent(type, payload) {
+    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  }
+}
+var MessageEvents, messaging;
+var init_messaging = __esm(() => {
+  ((MessageEvents2) => {
+    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
+    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
+    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
+    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
+    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
+    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
+    MessageEvents2["READY"] = "PLAYCADEMY_READY";
+    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
+    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
+    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
+    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);
+    });
+  }
+  return {
+    getGameToken: async (gameId, options) => {
+      const res = await client["request"](`/games/${gameId}/token`, "POST");
+      if (options?.apply) {
+        client.setToken(res.token);
+      }
+      return res;
+    },
+    exit: async () => {
+      if (client["internalClientSessionId"] && client["gameId"]) {
+        try {
+          await client.games.endSession(client["internalClientSessionId"], client["gameId"]);
+        } catch (error) {
+          log.error("[Playcademy SDK] Failed to auto-end session:", {
+            sessionId: client["internalClientSessionId"],
+            error
+          });
+        }
+      }
+      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
+    },
+    onInit: (handler) => {
+      messaging.listen("PLAYCADEMY_INIT" /* INIT */, handler);
+      trackListener("PLAYCADEMY_INIT" /* INIT */, handler);
+    },
+    onTokenRefresh: (handler) => {
+      messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+      trackListener("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+    },
+    onPause: (handler) => {
+      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+      trackListener("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+    },
+    onResume: (handler) => {
+      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, handler);
+      trackListener("PLAYCADEMY_RESUME" /* RESUME */, handler);
+    },
+    onForceExit: (handler) => {
+      messaging.listen("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+      trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+    },
+    onOverlay: (handler) => {
+      messaging.listen("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+      trackListener("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+    },
+    ready: () => {
+      messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+    },
+    sendTelemetry: (data) => {
+      messaging.send("PLAYCADEMY_TELEMETRY" /* TELEMETRY */, data);
+    },
+    removeListener: (eventType, handler) => {
+      messaging.unlisten(eventType, handler);
+      untrackListener(eventType, handler);
+    },
+    removeAllListeners: () => {
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        for (const handler of handlers) {
+          messaging.unlisten(eventType, handler);
+        }
+      }
+      eventListeners.clear();
+    },
+    getListenerCounts: () => {
+      const counts = {};
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        counts[eventType] = handlers.size;
+      }
+      return counts;
+    }
+  };
+}
+var init_runtime = __esm(() => {
+  init_src();
+  init_messaging();
+});
+
+// src/core/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);
+      }
+    }
+  }
+  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;
+    }
+    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"
+  });
+  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;
+      }
+      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
+    },
+    token: {
+      create: async (gameId, options) => {
+        const res = await client["request"](`/games/${gameId}/token`, "POST");
+        if (options?.apply) {
+          client.setToken(res.token);
+        }
+        return res;
+      }
+    },
+    leaderboard: {
+      get: async (gameId, options) => {
+        const params = new URLSearchParams;
+        if (options?.limit)
+          params.append("limit", String(options.limit));
+        if (options?.offset)
+          params.append("offset", String(options.offset));
+        const queryString = params.toString();
+        const path = queryString ? `/games/${gameId}/leaderboard?${queryString}` : `/games/${gameId}/leaderboard`;
+        return client["request"](path, "GET");
+      }
+    }
+  };
+}
+var init_games = __esm(() => {
+  init_request();
+});
+
+// src/core/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;
+    });
+    cache.set(fullKey, promise);
+    return promise;
+  }
+  function clear(key) {
+    if (key === undefined) {
+      cache.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));
+    }
+    return result;
+  }
+  return { get, clear, has, size, keys };
+}
+
+// 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 {
+    me: async () => {
+      return client["request"]("/users/me", "GET");
+    },
+    inventory: {
+      get: async () => client["request"](`/inventory`, "GET"),
+      add: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/add`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      remove: async (identifier, qty) => {
+        const itemId = await resolveItemId(identifier);
+        const res = await client["request"](`/inventory/remove`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: -qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      quantity: async (identifier) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        return item?.quantity ?? 0;
+      },
+      has: async (identifier, minQuantity = 1) => {
+        const itemId = await resolveItemId(identifier);
+        const inventory = await client["request"](`/inventory`, "GET");
+        const item = inventory.find((inv) => inv.item?.id === itemId);
+        const qty = item?.quantity ?? 0;
+        return qty >= minQuantity;
+      }
+    },
+    scores: {
+      get: async (userIdOrOptions, options) => {
+        let userId;
+        let queryOptions;
+        if (typeof userIdOrOptions === "string") {
+          userId = userIdOrOptions;
+          queryOptions = options || {};
+        } else {
+          queryOptions = userIdOrOptions || {};
+          const user = await client["request"]("/users/me", "GET");
+          userId = user.id;
+        }
+        const params = new URLSearchParams({
+          limit: String(queryOptions.limit || 50)
+        });
+        if (queryOptions.gameId) {
+          params.append("gameId", queryOptions.gameId);
+        }
+        return client["request"](`/users/${userId}/scores?${params}`, "GET");
+      }
+    }
+  };
+}
+var init_users = () => {};
+
+// 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");
+        }
+      }
+    }
+  };
+}
+
+// src/core/namespaces/maps.ts
+function createMapsNamespace(client) {
+  return {
+    get: (identifier) => client["request"](`/maps/${identifier}`, "GET"),
+    elements: (mapId) => client["request"](`/map/elements?mapId=${mapId}`, "GET"),
+    objects: {
+      list: (mapId) => client["request"](`/maps/${mapId}/objects`, "GET"),
+      create: (mapId, objectData) => client["request"](`/maps/${mapId}/objects`, "POST", objectData),
+      delete: (mapId, objectId) => client["request"](`/maps/${mapId}/objects/${objectId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/admin.ts
+function createAdminNamespace(client) {
+  return {
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
+    },
+    items: {
+      create: (props) => client["request"]("/items", "POST", props),
+      get: (itemId) => client["request"](`/items/${itemId}`, "GET"),
+      list: () => client["request"]("/items", "GET"),
+      update: (itemId, props) => client["request"](`/items/${itemId}`, "PATCH", props),
+      delete: (itemId) => client["request"](`/items/${itemId}`, "DELETE")
+    },
+    currencies: {
+      create: (props) => client["request"]("/currencies", "POST", props),
+      get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
+      list: () => client["request"]("/currencies", "GET"),
+      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", props),
+      delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
+    },
+    shopListings: {
+      create: (props) => client["request"]("/shop-listings", "POST", props),
+      get: (listingId) => client["request"](`/shop-listings/${listingId}`, "GET"),
+      list: () => client["request"]("/shop-listings", "GET"),
+      update: (listingId, props) => client["request"](`/shop-listings/${listingId}`, "PATCH", props),
+      delete: (listingId) => client["request"](`/shop-listings/${listingId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/shop.ts
+function createShopNamespace(client) {
+  return {
+    view: () => {
+      return client["request"]("/shop/view", "GET");
+    }
+  };
+}
+
+// src/core/namespaces/telemetry.ts
+function createTelemetryNamespace(client) {
+  return {
+    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", metrics)
+  };
+}
+
+// src/core/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 };
+}
+
+// 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");
+      }
+    }
+  };
+}
+var init_levels = () => {};
+
+// src/core/cache/singleton-cache.ts
+function createSingletonCache() {
+  let cachedValue;
+  let hasValue = false;
+  async function get(loader) {
+    if (hasValue) {
+      return cachedValue;
+    }
+    const value = await loader();
+    cachedValue = value;
+    hasValue = true;
+    return value;
+  }
+  function clear() {
+    cachedValue = undefined;
+    hasValue = false;
+  }
+  function has() {
+    return hasValue;
+  }
+  return { get, clear, has };
+}
+
+// src/core/namespaces/credits.ts
+function createCreditsNamespace(client) {
+  const creditsIdCache = createSingletonCache();
+  const getCreditsItemId = async () => {
+    return creditsIdCache.get(async () => {
+      const queryParams = new URLSearchParams({ slug: CURRENCIES.PRIMARY });
+      const creditsItem = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      if (!creditsItem || !creditsItem.id) {
+        throw new Error("Playcademy Credits item not found in catalog");
+      }
+      return creditsItem.id;
+    });
+  };
+  return {
+    balance: async () => {
+      const inventory = await client["request"]("/inventory", "GET");
+      const primaryCurrencyInventoryItem = inventory.find((item) => item.item?.slug === CURRENCIES.PRIMARY);
+      return primaryCurrencyInventoryItem?.quantity ?? 0;
+    },
+    add: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/add", "POST", {
+        itemId: creditsItemId,
+        qty: amount
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    },
+    spend: async (amount) => {
+      if (amount <= 0) {
+        throw new Error("Amount must be positive");
+      }
+      const creditsItemId = await getCreditsItemId();
+      const result = await client["request"]("/inventory/remove", "POST", {
+        itemId: creditsItemId,
+        qty: amount
+      });
+      client["emit"]("inventoryChange", {
+        itemId: creditsItemId,
+        delta: -amount,
+        newTotal: result.newTotal
+      });
+      return result.newTotal;
+    }
+  };
+}
+var init_credits = __esm(() => {
+  init_constants();
+});
+
+// src/core/namespaces/leaderboard.ts
+function createLeaderboardNamespace(client) {
+  return {
+    fetch: async (options) => {
+      const params = new URLSearchParams({
+        timeframe: options?.timeframe || "all_time",
+        limit: String(options?.limit || 10),
+        offset: String(options?.offset || 0)
+      });
+      if (options?.gameId) {
+        params.append("gameId", options.gameId);
+      }
+      return client["request"](`/leaderboard?${params}`, "GET");
+    },
+    getUserRank: async (gameId, userId) => {
+      return client["request"](`/games/${gameId}/users/${userId}/rank`, "GET");
+    }
+  };
+}
+
+// src/core/namespaces/scores.ts
+function createScoresNamespace(client) {
+  return {
+    submit: async (gameId, score, metadata) => {
+      return client["request"](`/games/${gameId}/scores`, "POST", {
+        score,
+        metadata
+      });
+    },
+    getByUser: async (gameId, userId, options) => {
+      const params = new URLSearchParams;
+      if (options?.limit) {
+        params.append("limit", String(options.limit));
+      }
+      const queryString = params.toString();
+      const path = queryString ? `/games/${gameId}/users/${userId}/scores?${queryString}` : `/games/${gameId}/users/${userId}/scores`;
+      return client["request"](path, "GET");
+    }
+  };
+}
+
+// src/core/namespaces/character.ts
+function createCharacterNamespace(client) {
+  const componentCache = createTTLCache({
+    ttl: 5 * 60 * 1000,
+    keyPrefix: "character.components"
+  });
+  return {
+    get: async (userId) => {
+      try {
+        const path = userId ? `/character/${userId}` : "/character";
+        return await client["request"](path, "GET");
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.message.includes("404")) {
+            return null;
+          }
+        }
+        throw error;
+      }
+    },
+    create: async (characterData) => {
+      return client["request"]("/character", "POST", characterData);
+    },
+    update: async (updates) => {
+      return client["request"]("/character", "PATCH", updates);
+    },
+    components: {
+      list: async (options) => {
+        const cacheKey = options?.level === undefined ? "all" : String(options.level);
+        return componentCache.get(cacheKey, async () => {
+          const path = options?.level !== undefined ? `/character/components?level=${options.level}` : "/character/components";
+          const components = await client["request"](path, "GET");
+          return components || [];
+        }, options);
+      },
+      clearCache: (key) => componentCache.clear(key),
+      getCacheKeys: () => componentCache.getKeys()
+    },
+    accessories: {
+      equip: async (slot, componentId) => {
+        return client["request"]("/character/accessories/equip", "POST", { slot, accessoryComponentId: componentId });
+      },
+      remove: async (slot) => {
+        return client["request"](`/character/accessories/${slot}`, "DELETE");
+      },
+      list: async () => {
+        const character = await client.character.get();
+        return character?.accessories || [];
+      }
+    }
+  };
+}
+var init_character = () => {};
+
+// src/core/namespaces/sprites.ts
+function createSpritesNamespace(client) {
+  const templateUrlCache = createPermanentCache("sprite-template-urls");
+  return {
+    templates: {
+      get: async (slug) => {
+        if (!slug)
+          throw new Error("Sprite template slug is required");
+        const templateMeta = await templateUrlCache.get(slug, async () => {
+          return client["request"](`/sprites/templates/${slug}`, "GET");
+        });
+        if (!templateMeta.url) {
+          throw new Error(`Template ${slug} has no URL in database`);
+        }
+        const response = await fetch(templateMeta.url);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch template JSON from ${templateMeta.url}: ${response.statusText}`);
+        }
+        return await response.json();
+      }
+    }
+  };
+}
+var init_sprites = () => {};
+
+// src/core/namespaces/realtime.client.ts
+class RealtimeChannelClient {
+  gameId;
+  _channelName;
+  getToken;
+  baseUrl;
+  ws;
+  listeners = new Set;
+  isClosing = false;
+  tokenRefreshUnsubscribe;
+  constructor(gameId, _channelName, getToken, baseUrl) {
+    this.gameId = gameId;
+    this._channelName = _channelName;
+    this.getToken = getToken;
+    this.baseUrl = baseUrl;
+  }
+  async connect() {
+    try {
+      const token = await this.getToken();
+      let wsBase;
+      if (/^ws(s)?:\/\//.test(this.baseUrl)) {
+        wsBase = this.baseUrl;
+      } else if (/^http(s)?:\/\//.test(this.baseUrl)) {
+        wsBase = this.baseUrl.replace(/^http/, "ws");
+      } else {
+        const isBrowser2 = typeof window !== "undefined";
+        if (isBrowser2) {
+          const proto = window.location.protocol === "https:" ? "wss" : "ws";
+          wsBase = `${proto}://${window.location.host}${this.baseUrl}`;
+        } else {
+          wsBase = `ws://${this.baseUrl.replace(/^\//, "")}`;
+        }
+      }
+      const url = new URL(wsBase);
+      url.searchParams.set("token", token);
+      url.searchParams.set("c", this._channelName);
+      this.ws = new WebSocket(url);
+      this.setupEventHandlers();
+      this.setupTokenRefreshListener();
+      await new Promise((resolve, reject) => {
+        if (!this.ws) {
+          reject(new Error("WebSocket creation failed"));
+          return;
+        }
+        const onOpen = () => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (event) => {
+          this.ws?.removeEventListener("open", onOpen);
+          this.ws?.removeEventListener("error", onError);
+          reject(new Error(`WebSocket connection failed: ${event}`));
+        };
+        this.ws.addEventListener("open", onOpen);
+        this.ws.addEventListener("error", onError);
+      });
+      log.debug("[RealtimeChannelClient] Connected to channel", {
+        gameId: this.gameId,
+        channel: this._channelName
+      });
+      return this;
+    } catch (error) {
+      log.error("[RealtimeChannelClient] Connection failed", {
+        gameId: this.gameId,
+        channel: this._channelName,
+        error
+      });
+      throw error;
+    }
+  }
+  setupEventHandlers() {
+    if (!this.ws)
+      return;
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.listeners.forEach((callback) => {
+          try {
+            callback(data);
+          } catch (error) {
+            log.warn("[RealtimeChannelClient] Message listener error", {
+              channel: this._channelName,
+              error
+            });
+          }
+        });
+      } catch (error) {
+        log.warn("[RealtimeChannelClient] Failed to parse message", {
+          channel: this._channelName,
+          message: event.data,
+          error
+        });
+      }
+    };
+    this.ws.onclose = (event) => {
+      log.debug("[RealtimeChannelClient] Connection closed", {
+        channel: this._channelName,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (!this.isClosing && event.code !== CLOSE_CODES.TOKEN_REFRESH) {
+        log.warn("[RealtimeChannelClient] Unexpected disconnection", {
+          channel: this._channelName,
+          code: event.code,
+          reason: event.reason
+        });
+      }
+    };
+    this.ws.onerror = (event) => {
+      log.error("[RealtimeChannelClient] WebSocket error", {
+        channel: this._channelName,
+        event
+      });
+    };
+  }
+  setupTokenRefreshListener() {
+    const tokenRefreshHandler = async ({ token }) => {
+      log.debug("[RealtimeChannelClient] Token refresh received, reconnecting", {
+        channel: this._channelName
+      });
+      try {
+        await this.reconnectWithNewToken(token);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Token refresh reconnection failed", {
+          channel: this._channelName,
+          error
+        });
+      }
+    };
+    messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    this.tokenRefreshUnsubscribe = () => {
+      messaging.unlisten("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, tokenRefreshHandler);
+    };
+  }
+  async reconnectWithNewToken(_token) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.close(CLOSE_CODES.TOKEN_REFRESH, "token_refresh");
+      await new Promise((resolve) => {
+        const checkClosed = () => {
+          if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            resolve();
+          } else {
+            setTimeout(checkClosed, 10);
+          }
+        };
+        checkClosed();
+      });
+    }
+    await this.connect();
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      try {
+        const message = JSON.stringify(data);
+        this.ws.send(message);
+      } catch (error) {
+        log.error("[RealtimeChannelClient] Failed to send message", {
+          channel: this._channelName,
+          error,
+          data
+        });
+      }
+    } else {
+      log.warn("[RealtimeChannelClient] Cannot send message - connection not open", {
+        channel: this._channelName,
+        readyState: this.ws?.readyState
+      });
+    }
+  }
+  onMessage(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  close() {
+    this.isClosing = true;
+    if (this.tokenRefreshUnsubscribe) {
+      this.tokenRefreshUnsubscribe();
+      this.tokenRefreshUnsubscribe = undefined;
+    }
+    if (this.ws) {
+      this.ws.close(CLOSE_CODES.NORMAL_CLOSURE, "client_close");
+      this.ws = undefined;
+    }
+    this.listeners.clear();
+    log.debug("[RealtimeChannelClient] Channel closed", {
+      channel: this._channelName
+    });
+  }
+  get channelName() {
+    return this._channelName;
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+}
+var CLOSE_CODES;
+var init_realtime_client = __esm(() => {
+  init_src();
+  init_messaging();
+  CLOSE_CODES = {
+    NORMAL_CLOSURE: 1000,
+    TOKEN_REFRESH: 4000
+  };
+});
+
+// src/core/namespaces/realtime.ts
+function createRealtimeNamespace(client) {
+  return {
+    token: {
+      get: async () => {
+        const endpoint = client["gameId"] ? `/games/${client["gameId"]}/realtime/token` : "/realtime/token";
+        return client["request"](endpoint, "POST");
+      }
+    },
+    async open(channel = "default", url) {
+      if (!client["gameId"]) {
+        throw new Error("gameId is required for realtime channels");
+      }
+      let wsBaseUrl = url;
+      if (!wsBaseUrl && typeof window !== "undefined") {
+        const ctx = window.PLAYCADEMY;
+        if (ctx?.realtimeUrl) {
+          wsBaseUrl = ctx.realtimeUrl;
+        }
+      }
+      const realtimeClient = new RealtimeChannelClient(client["gameId"], channel, () => client.realtime.token.get().then((r) => r.token), wsBaseUrl ?? client.getBaseUrl());
+      return realtimeClient.connect();
+    }
+  };
+}
+var init_realtime = __esm(() => {
+  init_realtime_client();
+});
+
+// src/core/namespaces/achievements.ts
+function createAchievementsNamespace(client) {
+  const achievementsListCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "achievements.list"
+  });
+  const achievementsHistoryCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "achievements.history"
+  });
+  return {
+    list: (options) => {
+      return achievementsListCache.get("current", () => client["request"]("/achievements/current", "GET"), options);
+    },
+    history: {
+      list: async (queryOptions, cacheOptions) => {
+        const params = new URLSearchParams;
+        if (queryOptions?.limit)
+          params.append("limit", String(queryOptions.limit));
+        const qs = params.toString();
+        const path = qs ? `/achievements/history?${qs}` : "/achievements/history";
+        const cacheKey = qs ? `history-${qs}` : "history";
+        return achievementsHistoryCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+      }
+    },
+    progress: {
+      submit: async (achievementId) => client["request"]("/achievements/progress", "POST", {
+        achievementId
+      })
+    }
+  };
+}
+var init_achievements = () => {};
+
+// src/core/namespaces/timeback.ts
+function createTimebackNamespace(client) {
+  return {
+    xp: {
+      today: async (options) => {
+        const params = new URLSearchParams;
+        if (options?.date)
+          params.set("date", options.date);
+        if (options?.timezone)
+          params.set("tz", options.timezone);
+        const query = params.toString();
+        const endpoint = query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
+        return client["request"](endpoint, "GET");
+      },
+      total: async () => {
+        return client["request"]("/timeback/xp/total", "GET");
+      },
+      history: async (options) => {
+        const params = new URLSearchParams;
+        if (options?.startDate)
+          params.set("startDate", options.startDate);
+        if (options?.endDate)
+          params.set("endDate", options.endDate);
+        const query = params.toString();
+        const endpoint = query ? `/timeback/xp/history?${query}` : "/timeback/xp/history";
+        return client["request"](endpoint, "GET");
+      },
+      summary: async (options) => {
+        const [today, total] = await Promise.all([
+          client["request"]((() => {
+            const params = new URLSearchParams;
+            if (options?.date)
+              params.set("date", options.date);
+            if (options?.timezone)
+              params.set("tz", options.timezone);
+            const query = params.toString();
+            return query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
+          })(), "GET"),
+          client["request"]("/timeback/xp/total", "GET")
+        ]);
+        return { today, total };
+      }
+    }
+  };
+}
+
+// src/core/namespaces/index.ts
+var init_namespaces = __esm(() => {
+  init_identity();
+  init_runtime();
+  init_games();
+  init_users();
+  init_levels();
+  init_credits();
+  init_character();
+  init_sprites();
+  init_realtime();
+  init_achievements();
+});
+
+// src/core/static/init.ts
+async function getPlaycademyConfig() {
+  const preloaded = window.PLAYCADEMY;
+  if (preloaded?.token) {
+    return preloaded;
+  }
+  if (window.self !== window.top) {
+    return await waitForPlaycademyInit();
+  } else {
+    return createStandaloneConfig();
+  }
+}
+async function waitForPlaycademyInit() {
+  return new Promise((resolve, reject) => {
+    let contextReceived = false;
+    const timeoutDuration = 5000;
+    const handleMessage = (event) => {
+      if (event.data?.type === "PLAYCADEMY_INIT" /* INIT */) {
+        contextReceived = true;
+        window.removeEventListener("message", handleMessage);
+        clearTimeout(timeoutId);
+        window.PLAYCADEMY = event.data.payload;
+        resolve(event.data.payload);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const timeoutId = setTimeout(() => {
+      if (!contextReceived) {
+        window.removeEventListener("message", handleMessage);
+        reject(new Error(`${"PLAYCADEMY_INIT" /* INIT */} not received within ${timeoutDuration}ms`));
+      }
+    }, timeoutDuration);
+  });
+}
+function createStandaloneConfig() {
+  const mockConfig = {
+    baseUrl: "/api",
+    token: "mock-game-token-for-local-dev",
+    gameId: "mock-game-id-from-template",
+    realtimeUrl: undefined
+  };
+  window.PLAYCADEMY = mockConfig;
+  return mockConfig;
+}
+async function init() {
+  const { PlaycademyClient } = await Promise.resolve().then(() => (init_client(), exports_client));
+  if (typeof window === "undefined") {
+    throw new Error("Playcademy SDK must run in a browser context");
+  }
+  const config = await getPlaycademyConfig();
+  const client = new PlaycademyClient({
+    baseUrl: config.baseUrl,
+    token: config.token,
+    gameId: config.gameId
+  });
+  if (config.userId) {
+    client["userId"] = config.userId;
+  }
+  messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
+  messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+  if (import.meta.env?.MODE === "development") {
+    window.PLAYCADEMY_CLIENT = client;
+  }
+  return client;
+}
+var init_init = __esm(() => {
+  init_messaging();
+});
+
+// src/core/static/login.ts
+async function login2(baseUrl, email, password) {
+  let url = baseUrl;
+  if (baseUrl.startsWith("/") && typeof window !== "undefined") {
+    url = window.location.origin + baseUrl;
+  }
+  url = url + "/auth/login";
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ email, password })
+  });
+  if (!response.ok) {
+    try {
+      const errorData = await response.json();
+      const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
+      throw new PlaycademyError(errorMessage);
+    } catch (error) {
+      log.error("[Playcademy SDK] Failed to parse error response JSON, using status text instead:", { error });
+      throw new PlaycademyError(response.statusText);
+    }
+  }
+  return response.json();
+}
+var init_login2 = __esm(() => {
+  init_src();
+  init_errors();
+});
+
+// src/core/static/identity.ts
+var identity;
+var init_identity2 = __esm(() => {
+  init_oauth();
+  identity = {
+    parseOAuthState
+  };
+});
+
+// src/core/static/index.ts
+var init_static = __esm(() => {
+  init_init();
+  init_login2();
+  init_identity2();
+});
+
+// src/core/client.ts
+var exports_client = {};
+__export(exports_client, {
+  PlaycademyClient: () => PlaycademyClient
+});
+var PlaycademyClient;
+var init_client = __esm(() => {
+  init_src();
+  init_errors();
+  init_namespaces();
+  init_request();
+  init_static();
+  PlaycademyClient = class PlaycademyClient {
+    baseUrl;
+    token;
+    gameId;
+    listeners = {};
+    internalClientSessionId;
+    authContext;
+    userId;
+    constructor(config) {
+      if (!config) {
+        this.baseUrl = "/api";
+        this.token = undefined;
+        this.gameId = undefined;
+      } else {
+        this.baseUrl = config.baseUrl || "/api";
+        this.token = config.token;
+        this.gameId = config.gameId;
+      }
+      this.detectAuthContext();
+      if (this.gameId) {
+        this._initializeInternalSession().catch((error) => {
+          log.error("[Playcademy SDK] Background initialization of auto-session failed:", {
+            error
+          });
+        });
+      }
+    }
+    getBaseUrl() {
+      const isRelative = this.baseUrl.startsWith("/");
+      const isBrowser2 = typeof window !== "undefined";
+      return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+    }
+    ping() {
+      return "pong";
+    }
+    setToken(token) {
+      this.token = token ?? undefined;
+      this.emit("authChange", { token: this.token ?? null });
+    }
+    isAuthenticated() {
+      return !!this.token;
+    }
+    onAuthChange(callback) {
+      this.on("authChange", (payload) => callback(payload.token));
+    }
+    _setAuthContext(context) {
+      this.authContext = context;
+    }
+    on(event, callback) {
+      this.listeners[event] = this.listeners[event] ?? [];
+      this.listeners[event].push(callback);
+    }
+    emit(event, payload) {
+      (this.listeners[event] ?? []).forEach((listener) => {
+        listener(payload);
+      });
+    }
+    async request(path, method, body, headers) {
+      const effectiveHeaders = { ...headers };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.baseUrl,
+        token: this.token,
+        extraHeaders: effectiveHeaders
+      });
+    }
+    _ensureGameId() {
+      if (!this.gameId) {
+        throw new PlaycademyError("This operation requires a gameId, but none was provided when initializing the client.");
+      }
+      return this.gameId;
+    }
+    detectAuthContext() {
+      this.authContext = { isInIframe: isInIframe() };
+    }
+    async _initializeInternalSession() {
+      if (!this.gameId || this.internalClientSessionId) {
+        return;
+      }
+      try {
+        const response = await this.games.startSession(this.gameId);
+        this.internalClientSessionId = response.sessionId;
+      } catch (error) {
+        log.error("[Playcademy SDK] Auto-starting session failed for game", {
+          gameId: this.gameId,
+          error
+        });
+      }
+    }
+    auth = createAuthNamespace(this);
+    identity = createIdentityNamespace(this);
+    runtime = createRuntimeNamespace(this);
+    games = createGamesNamespace(this);
+    users = createUsersNamespace(this);
+    dev = createDevNamespace(this);
+    maps = createMapsNamespace(this);
+    admin = createAdminNamespace(this);
+    shop = createShopNamespace(this);
+    levels = createLevelsNamespace(this);
+    timeback = createTimebackNamespace(this);
+    telemetry = createTelemetryNamespace(this);
+    credits = createCreditsNamespace(this);
+    leaderboard = createLeaderboardNamespace(this);
+    scores = createScoresNamespace(this);
+    character = createCharacterNamespace(this);
+    sprites = createSpritesNamespace(this);
+    realtime = createRealtimeNamespace(this);
+    achievements = createAchievementsNamespace(this);
+    static init = init;
+    static login = login2;
+    static identity = identity;
+  };
+});
+
+// src/types.ts
+init_constants();
+var AuthProvider = {
+  TIMEBACK: "TIMEBACK"
+};
+
+// src/index.ts
+init_client();
+init_messaging();
+export {
+  messaging,
+  PlaycademyClient,
+  MessageEvents,
+  AuthProvider
+};