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

package/dist/types.js

@@ -10,125 +10,180 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../data/src/domains/user/table.ts
-import { boolean, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
-var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification;
+// ../data/src/domains/game/table.ts
+import {
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+  varchar
+} from "drizzle-orm/pg-core";
+var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
 var init_table = __esm(() => {
-  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer"]);
-  developerStatusEnum = pgEnum("developer_status", ["none", "pending", "approved"]);
-  users = pgTable("user", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    name: text("name").notNull(),
-    username: text("username").unique(),
-    email: text("email").notNull().unique(),
-    emailVerified: boolean("email_verified").notNull().default(false),
-    image: text("image"),
-    role: userRoleEnum("role").notNull().default("player"),
-    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
-  });
-  accounts = pgTable("account", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
-    accountId: text("account_id").notNull(),
-    providerId: text("provider_id").notNull(),
-    accessToken: text("access_token"),
-    refreshToken: text("refresh_token"),
-    idToken: text("id_token"),
-    accessTokenExpiresAt: timestamp("access_token_expires_at", {
-      mode: "date",
-      withTimezone: true
+  init_table3();
+  init_table4();
+  gamePlatformEnum = pgEnum("game_platform", ["web", "godot", "unity"]);
+  gameBootModeEnum = pgEnum("game_boot_mode", ["iframe", "module"]);
+  games = pgTable("games", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    developerId: text("developer_id").references(() => users.id, {
+      onDelete: "set null"
     }),
-    refreshTokenExpiresAt: timestamp("refresh_token_expires_at", {
-      mode: "date",
-      withTimezone: true
+    slug: varchar("slug", { length: 255 }).notNull().unique(),
+    displayName: varchar("display_name", { length: 255 }).notNull(),
+    version: varchar("version", { length: 50 }).notNull(),
+    assetBundleBase: text("asset_bundle_base").notNull(),
+    platform: gamePlatformEnum("platform").notNull().default("web"),
+    mapElementId: uuid("map_element_id").references(() => mapElements.id, {
+      onDelete: "set null"
     }),
-    scope: text("scope"),
-    password: text("password"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
-  }, (table) => [uniqueIndex("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
-  sessions = pgTable("session", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    expiresAt: timestamp("expires_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    token: text("token").notNull().unique(),
-    ipAddress: text("ip_address"),
-    userAgent: text("user_agent"),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
+    metadata: jsonb("metadata").default("{}"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
   });
-  verification = pgTable("verification", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    identifier: text("identifier").notNull(),
-    value: text("value").notNull(),
-    expiresAt: timestamp("expires_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    createdAt: timestamp("created_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull(),
-    updatedAt: timestamp("updated_at", {
-      mode: "date",
-      withTimezone: true
-    }).notNull()
+  gameSessions = pgTable("game_sessions", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    endedAt: timestamp("ended_at", { withTimezone: true })
   });
+  gameStates = pgTable("game_states", {
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    data: jsonb("data").default("{}"),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex("unique_user_game_idx").on(table.userId, table.gameId)]);
 });
 
-// ../data/src/domains/developer/table.ts
-import { pgTable as pgTable2, text as text2, timestamp as timestamp2, uuid, varchar } from "drizzle-orm/pg-core";
-var developerKeys;
+// ../data/src/domains/inventory/table.ts
+import { relations, sql } from "drizzle-orm";
+import {
+  boolean,
+  integer,
+  jsonb as jsonb2,
+  pgEnum as pgEnum2,
+  pgTable as pgTable2,
+  text as text2,
+  timestamp as timestamp2,
+  uniqueIndex as uniqueIndex2,
+  uuid as uuid2
+} from "drizzle-orm/pg-core";
+var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
 var init_table2 = __esm(() => {
   init_table();
-  developerKeys = pgTable2("developer_keys", {
-    id: uuid("id").primaryKey().defaultRandom(),
+  init_table3();
+  init_table4();
+  itemTypeEnum = pgEnum2("item_type", [
+    "currency",
+    "badge",
+    "trophy",
+    "collectible",
+    "consumable",
+    "unlock",
+    "upgrade",
+    "accessory",
+    "other"
+  ]);
+  items = pgTable2("items", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    slug: text2("slug").notNull(),
+    gameId: uuid2("game_id").references(() => games.id, {
+      onDelete: "cascade"
+    }),
+    displayName: text2("display_name").notNull(),
+    description: text2("description"),
+    type: itemTypeEnum("type").notNull().default("other"),
+    isPlaceable: boolean("is_placeable").default(false).notNull(),
+    imageUrl: text2("image_url"),
+    metadata: jsonb2("metadata").default({}),
+    createdAt: timestamp2("created_at").defaultNow().notNull()
+  }, (table) => [
+    uniqueIndex2("items_game_slug_idx").on(table.gameId, table.slug),
+    uniqueIndex2("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
+  ]);
+  inventoryItems = pgTable2("inventory_items", {
+    id: uuid2("id").primaryKey().defaultRandom(),
     userId: text2("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    label: varchar("label", { length: 255 }),
-    keyHash: text2("key_hash").notNull().unique(),
-    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
-  });
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    quantity: integer("quantity").notNull().default(1),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex2("unique_user_item_idx").on(table.userId, table.itemId)]);
+  currencies = pgTable2("currencies", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    symbol: text2("symbol"),
+    isPrimary: boolean("is_primary").default(false).notNull(),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex2("currency_item_id_idx").on(table.itemId)]);
+  shopListings = pgTable2("shop_listings", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    currencyId: uuid2("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
+    price: integer("price").notNull(),
+    sellBackPercentage: integer("sell_back_percentage"),
+    stock: integer("stock"),
+    isActive: boolean("is_active").default(true).notNull(),
+    availableFrom: timestamp2("available_from", { withTimezone: true }),
+    availableUntil: timestamp2("available_until", { withTimezone: true }),
+    createdAt: timestamp2("created_at").defaultNow().notNull(),
+    updatedAt: timestamp2("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex2("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
+  itemsRelations = relations(items, ({ many }) => ({
+    shopListings: many(shopListings),
+    inventoryItems: many(inventoryItems),
+    mapObjects: many(mapObjects)
+  }));
+  currenciesRelations = relations(currencies, ({ many }) => ({
+    shopListings: many(shopListings)
+  }));
+  shopListingsRelations = relations(shopListings, ({ one }) => ({
+    item: one(items, {
+      fields: [shopListings.itemId],
+      references: [items.id]
+    }),
+    currency: one(currencies, {
+      fields: [shopListings.currencyId],
+      references: [currencies.id]
+    })
+  }));
+  inventoryItemsRelations = relations(inventoryItems, ({ one }) => ({
+    item: one(items, {
+      fields: [inventoryItems.itemId],
+      references: [items.id]
+    }),
+    user: one(users, {
+      fields: [inventoryItems.userId],
+      references: [users.id]
+    })
+  }));
 });
 
 // ../data/src/domains/map/table.ts
-import { relations } from "drizzle-orm";
+import { relations as relations2 } from "drizzle-orm";
 import {
   doublePrecision,
-  jsonb,
-  pgEnum as pgEnum2,
+  index,
+  integer as integer2,
+  jsonb as jsonb3,
+  pgEnum as pgEnum3,
   pgTable as pgTable3,
   text as text3,
-  uniqueIndex as uniqueIndex2,
-  uuid as uuid2,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
   varchar as varchar2
 } from "drizzle-orm/pg-core";
-var interactionTypeEnum, maps, mapElements, mapElementsRelations, mapsRelations;
+var interactionTypeEnum, maps, mapElements, mapObjects, mapElementsRelations, mapsRelations, mapObjectsRelations;
 var init_table3 = __esm(() => {
+  init_table();
+  init_table2();
   init_table4();
-  interactionTypeEnum = pgEnum2("interaction_type", [
+  interactionTypeEnum = pgEnum3("interaction_type", [
     "game_entry",
     "game_registry",
     "info",
@@ -139,7 +194,7 @@ var init_table3 = __esm(() => {
     "quest_trigger"
   ]);
   maps = pgTable3("maps", {
-    id: uuid2("id").primaryKey().defaultRandom(),
+    id: uuid3("id").primaryKey().defaultRandom(),
     identifier: varchar2("identifier", { length: 255 }).notNull().unique(),
     displayName: varchar2("display_name", { length: 255 }).notNull(),
     filePath: varchar2("file_path", { length: 255 }).notNull(),
@@ -149,18 +204,32 @@ var init_table3 = __esm(() => {
     description: text3("description")
   });
   mapElements = pgTable3("map_elements", {
-    id: uuid2("id").primaryKey().defaultRandom(),
-    mapId: uuid2("map_id").references(() => maps.id, {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    mapId: uuid3("map_id").references(() => maps.id, {
       onDelete: "cascade"
     }),
     elementSlug: varchar2("element_slug", { length: 255 }).notNull(),
     interactionType: interactionTypeEnum("interaction_type").notNull(),
-    gameId: uuid2("game_id").references(() => games.id, {
+    gameId: uuid3("game_id").references(() => games.id, {
       onDelete: "set null"
     }),
-    metadata: jsonb("metadata").$type().default({})
-  }, (table) => [uniqueIndex2("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
-  mapElementsRelations = relations(mapElements, ({ one }) => ({
+    metadata: jsonb3("metadata").$type().default({})
+  }, (table) => [uniqueIndex3("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
+  mapObjects = pgTable3("map_objects", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    userId: text3("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    mapId: uuid3("map_id").notNull().references(() => maps.id, { onDelete: "cascade" }),
+    itemId: uuid3("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    worldX: doublePrecision("world_x").notNull(),
+    worldY: doublePrecision("world_y").notNull(),
+    rotation: integer2("rotation").default(0).notNull(),
+    scale: doublePrecision("scale").default(1).notNull(),
+    createdAt: timestamp3("created_at").defaultNow().notNull()
+  }, (table) => [
+    index("map_objects_map_idx").on(table.mapId),
+    index("map_objects_spatial_idx").on(table.mapId, table.worldX, table.worldY)
+  ]);
+  mapElementsRelations = relations2(mapElements, ({ one }) => ({
     game: one(games, {
       fields: [mapElements.gameId],
       references: [games.id]
@@ -170,183 +239,158 @@ var init_table3 = __esm(() => {
       references: [maps.id]
     })
   }));
-  mapsRelations = relations(maps, ({ many }) => ({
-    elements: many(mapElements)
+  mapsRelations = relations2(maps, ({ many }) => ({
+    elements: many(mapElements),
+    objects: many(mapObjects)
+  }));
+  mapObjectsRelations = relations2(mapObjects, ({ one }) => ({
+    user: one(users, {
+      fields: [mapObjects.userId],
+      references: [users.id]
+    }),
+    map: one(maps, {
+      fields: [mapObjects.mapId],
+      references: [maps.id]
+    }),
+    item: one(items, {
+      fields: [mapObjects.itemId],
+      references: [items.id]
+    })
   }));
 });
 
-// ../data/src/domains/game/table.ts
-import {
-  jsonb as jsonb2,
-  pgEnum as pgEnum3,
-  pgTable as pgTable4,
-  text as text4,
-  timestamp as timestamp3,
-  uniqueIndex as uniqueIndex3,
-  uuid as uuid3,
-  varchar as varchar3
-} from "drizzle-orm/pg-core";
-var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
+// ../data/src/domains/user/table.ts
+import { relations as relations3 } from "drizzle-orm";
+import { boolean as boolean2, pgEnum as pgEnum4, pgTable as pgTable4, text as text4, timestamp as timestamp4, uniqueIndex as uniqueIndex4 } from "drizzle-orm/pg-core";
+var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification, usersRelations;
 var init_table4 = __esm(() => {
   init_table3();
-  init_table();
-  gamePlatformEnum = pgEnum3("game_platform", ["web", "godot", "unity"]);
-  gameBootModeEnum = pgEnum3("game_boot_mode", ["iframe", "module"]);
-  games = pgTable4("games", {
-    id: uuid3("id").primaryKey().defaultRandom(),
-    developerId: text4("developer_id").references(() => users.id, {
-      onDelete: "set null"
+  userRoleEnum = pgEnum4("user_role", ["admin", "player", "developer"]);
+  developerStatusEnum = pgEnum4("developer_status", ["none", "pending", "approved"]);
+  users = pgTable4("user", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    name: text4("name").notNull(),
+    username: text4("username").unique(),
+    email: text4("email").notNull().unique(),
+    emailVerified: boolean2("email_verified").notNull().default(false),
+    image: text4("image"),
+    role: userRoleEnum("role").notNull().default("player"),
+    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
+    characterCreated: boolean2("character_created").notNull().default(false),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  accounts = pgTable4("account", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text4("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+    accountId: text4("account_id").notNull(),
+    providerId: text4("provider_id").notNull(),
+    accessToken: text4("access_token"),
+    refreshToken: text4("refresh_token"),
+    idToken: text4("id_token"),
+    accessTokenExpiresAt: timestamp4("access_token_expires_at", {
+      mode: "date",
+      withTimezone: true
     }),
-    slug: varchar3("slug", { length: 255 }).notNull().unique(),
-    displayName: varchar3("display_name", { length: 255 }).notNull(),
-    version: varchar3("version", { length: 50 }).notNull(),
-    assetBundleBase: text4("asset_bundle_base").notNull(),
-    platform: gamePlatformEnum("platform").notNull().default("web"),
-    mapElementId: uuid3("map_element_id").references(() => mapElements.id, {
-      onDelete: "set null"
+    refreshTokenExpiresAt: timestamp4("refresh_token_expires_at", {
+      mode: "date",
+      withTimezone: true
     }),
-    metadata: jsonb2("metadata").default("{}"),
-    createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow(),
-    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
-  });
-  gameSessions = pgTable4("game_sessions", {
-    id: uuid3("id").primaryKey().defaultRandom(),
+    scope: text4("scope"),
+    password: text4("password"),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  }, (table) => [uniqueIndex4("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
+  sessions = pgTable4("session", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
     userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
-    endedAt: timestamp3("ended_at", { withTimezone: true })
+    expiresAt: timestamp4("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    token: text4("token").notNull().unique(),
+    ipAddress: text4("ip_address"),
+    userAgent: text4("user_agent"),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
   });
-  gameStates = pgTable4("game_states", {
-    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    data: jsonb2("data").default("{}"),
-    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
-  }, (table) => [uniqueIndex3("unique_user_game_idx").on(table.userId, table.gameId)]);
+  verification = pgTable4("verification", {
+    id: text4("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    identifier: text4("identifier").notNull(),
+    value: text4("value").notNull(),
+    expiresAt: timestamp4("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    createdAt: timestamp4("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp4("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  usersRelations = relations3(users, ({ many }) => ({
+    mapObjects: many(mapObjects)
+  }));
 });
 
-// ../data/src/domains/inventory/table.ts
-import { relations as relations2, sql } from "drizzle-orm";
-import {
-  boolean as boolean2,
-  integer,
-  jsonb as jsonb3,
-  pgEnum as pgEnum4,
-  pgTable as pgTable5,
-  text as text5,
-  timestamp as timestamp4,
-  uniqueIndex as uniqueIndex4,
-  uuid as uuid4
-} from "drizzle-orm/pg-core";
-var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
+// ../data/src/domains/developer/table.ts
+import { pgTable as pgTable5, text as text5, timestamp as timestamp5, uuid as uuid4, varchar as varchar3 } from "drizzle-orm/pg-core";
+var developerKeys;
 var init_table5 = __esm(() => {
   init_table4();
-  init_table();
-  itemTypeEnum = pgEnum4("item_type", [
-    "currency",
-    "badge",
-    "trophy",
-    "collectible",
-    "consumable",
-    "unlock",
-    "upgrade",
-    "other"
-  ]);
-  items = pgTable5("items", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    slug: text5("slug").notNull(),
-    gameId: uuid4("game_id").references(() => games.id, {
-      onDelete: "cascade"
-    }),
-    displayName: text5("display_name").notNull(),
-    description: text5("description"),
-    type: itemTypeEnum("type").notNull().default("other"),
-    imageUrl: text5("image_url"),
-    metadata: jsonb3("metadata").default({}),
-    createdAt: timestamp4("created_at").defaultNow().notNull()
-  }, (table) => [
-    uniqueIndex4("items_game_slug_idx").on(table.gameId, table.slug),
-    uniqueIndex4("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
-  ]);
-  inventoryItems = pgTable5("inventory_items", {
+  developerKeys = pgTable5("developer_keys", {
     id: uuid4("id").primaryKey().defaultRandom(),
     userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    quantity: integer("quantity").notNull().default(1),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow()
-  }, (table) => [uniqueIndex4("unique_user_item_idx").on(table.userId, table.itemId)]);
-  currencies = pgTable5("currencies", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    symbol: text5("symbol"),
-    isPrimary: boolean2("is_primary").default(false).notNull(),
-    createdAt: timestamp4("created_at").defaultNow().notNull(),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
-  }, (table) => [uniqueIndex4("currency_item_id_idx").on(table.itemId)]);
-  shopListings = pgTable5("shop_listings", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
-    currencyId: uuid4("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
-    price: integer("price").notNull(),
-    sellBackPercentage: integer("sell_back_percentage"),
-    stock: integer("stock"),
-    isActive: boolean2("is_active").default(true).notNull(),
-    availableFrom: timestamp4("available_from", { withTimezone: true }),
-    availableUntil: timestamp4("available_until", { withTimezone: true }),
-    createdAt: timestamp4("created_at").defaultNow().notNull(),
-    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
-  }, (table) => [uniqueIndex4("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
-  itemsRelations = relations2(items, ({ many }) => ({
-    shopListings: many(shopListings),
-    inventoryItems: many(inventoryItems)
-  }));
-  currenciesRelations = relations2(currencies, ({ many }) => ({
-    shopListings: many(shopListings)
-  }));
-  shopListingsRelations = relations2(shopListings, ({ one }) => ({
-    item: one(items, {
-      fields: [shopListings.itemId],
-      references: [items.id]
-    }),
-    currency: one(currencies, {
-      fields: [shopListings.currencyId],
-      references: [currencies.id]
-    })
-  }));
-  inventoryItemsRelations = relations2(inventoryItems, ({ one }) => ({
-    item: one(items, {
-      fields: [inventoryItems.itemId],
-      references: [items.id]
-    }),
-    user: one(users, {
-      fields: [inventoryItems.userId],
-      references: [users.id]
-    })
-  }));
+    label: varchar3("label", { length: 255 }),
+    keyHash: text5("key_hash").notNull().unique(),
+    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow()
+  });
 });
 
 // ../data/src/domains/level/table.ts
-import { relations as relations3 } from "drizzle-orm";
-import { integer as integer2, pgTable as pgTable6, text as text6, timestamp as timestamp5, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
+import { relations as relations4 } from "drizzle-orm";
+import { integer as integer3, pgTable as pgTable6, text as text6, timestamp as timestamp6, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
 var userLevels, levelConfigs, userLevelsRelations;
 var init_table6 = __esm(() => {
-  init_table();
+  init_table4();
   userLevels = pgTable6("user_levels", {
     userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
-    currentLevel: integer2("current_level").notNull().default(1),
-    currentXp: integer2("current_xp").notNull().default(0),
-    totalXP: integer2("total_xp").notNull().default(0),
-    lastLevelUpAt: timestamp5("last_level_up_at", { withTimezone: true }),
-    createdAt: timestamp5("created_at").defaultNow().notNull(),
-    updatedAt: timestamp5("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+    currentLevel: integer3("current_level").notNull().default(1),
+    currentXp: integer3("current_xp").notNull().default(0),
+    totalXP: integer3("total_xp").notNull().default(0),
+    lastLevelUpAt: timestamp6("last_level_up_at", { withTimezone: true }),
+    createdAt: timestamp6("created_at").defaultNow().notNull(),
+    updatedAt: timestamp6("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
   });
   levelConfigs = pgTable6("level_configs", {
     id: uuid5("id").primaryKey().defaultRandom(),
-    level: integer2("level").notNull().unique(),
-    xpRequired: integer2("xp_required").notNull(),
-    creditsReward: integer2("credits_reward").notNull().default(0),
-    createdAt: timestamp5("created_at").defaultNow().notNull()
+    level: integer3("level").notNull().unique(),
+    xpRequired: integer3("xp_required").notNull(),
+    creditsReward: integer3("credits_reward").notNull().default(0),
+    createdAt: timestamp6("created_at").defaultNow().notNull()
   }, (table) => [uniqueIndex5("unique_level_config_idx").on(table.level)]);
-  userLevelsRelations = relations3(userLevels, ({ one }) => ({
+  userLevelsRelations = relations4(userLevels, ({ one }) => ({
     user: one(users, {
       fields: [userLevels.userId],
       references: [users.id]
@@ -354,14 +398,158 @@ var init_table6 = __esm(() => {
   }));
 });
 
+// ../data/src/domains/leaderboard/table.ts
+import { relations as relations5 } from "drizzle-orm";
+import { index as index2, integer as integer4, jsonb as jsonb4, pgTable as pgTable7, text as text7, timestamp as timestamp7, uuid as uuid6 } from "drizzle-orm/pg-core";
+var gameScores, gameScoresRelations;
+var init_table7 = __esm(() => {
+  init_table();
+  init_table4();
+  gameScores = pgTable7("game_scores", {
+    id: uuid6("id").primaryKey().defaultRandom(),
+    userId: text7("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid6("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    score: integer4("score").notNull(),
+    metadata: jsonb4("metadata").default("{}"),
+    achievedAt: timestamp7("achieved_at", { withTimezone: true }).defaultNow().notNull(),
+    sessionId: uuid6("session_id").references(() => gameSessions.id, { onDelete: "set null" })
+  }, (table) => [
+    index2("game_scores_user_game_idx").on(table.userId, table.gameId),
+    index2("game_scores_game_score_idx").on(table.gameId, table.score),
+    index2("game_scores_achieved_at_idx").on(table.achievedAt)
+  ]);
+  gameScoresRelations = relations5(gameScores, ({ one }) => ({
+    user: one(users, {
+      fields: [gameScores.userId],
+      references: [users.id]
+    }),
+    game: one(games, {
+      fields: [gameScores.gameId],
+      references: [games.id]
+    }),
+    session: one(gameSessions, {
+      fields: [gameScores.sessionId],
+      references: [gameSessions.id]
+    })
+  }));
+});
+
+// ../data/src/domains/sprite/table.ts
+import { relations as relations6 } from "drizzle-orm";
+import { integer as integer5, pgTable as pgTable8, timestamp as timestamp8, uuid as uuid7, varchar as varchar4 } from "drizzle-orm/pg-core";
+var spriteTemplates, spriteSheets, spriteTemplatesRelations, spriteSheetsRelations;
+var init_table8 = __esm(() => {
+  spriteTemplates = pgTable8("sprite_templates", {
+    id: uuid7("id").primaryKey().defaultRandom(),
+    slug: varchar4("slug", { length: 64 }).notNull().unique(),
+    url: varchar4("url", { length: 255 }).notNull(),
+    createdAt: timestamp8("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp8("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  spriteSheets = pgTable8("sprite_sheets", {
+    id: uuid7("id").primaryKey().defaultRandom(),
+    templateId: uuid7("template_id").notNull().references(() => spriteTemplates.id, { onDelete: "cascade" }),
+    width: integer5("width").notNull(),
+    height: integer5("height").notNull(),
+    url: varchar4("url", { length: 255 }).notNull(),
+    createdAt: timestamp8("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp8("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  spriteTemplatesRelations = relations6(spriteTemplates, ({ many }) => ({
+    sheets: many(spriteSheets)
+  }));
+  spriteSheetsRelations = relations6(spriteSheets, ({ one }) => ({
+    template: one(spriteTemplates, {
+      fields: [spriteSheets.templateId],
+      references: [spriteTemplates.id]
+    })
+  }));
+});
+
+// ../data/src/domains/character/table.ts
+import { relations as relations7 } from "drizzle-orm";
+import { integer as integer6, pgEnum as pgEnum5, pgTable as pgTable9, text as text8, timestamp as timestamp9, uuid as uuid8, varchar as varchar5 } from "drizzle-orm/pg-core";
+var characterComponentTypeEnum, characterComponents, playerCharacters, characterComponentsRelations, playerCharactersRelations;
+var init_table9 = __esm(() => {
+  init_table8();
+  init_table4();
+  characterComponentTypeEnum = pgEnum5("character_component_type", [
+    "body",
+    "outfit",
+    "hairstyle",
+    "eyes",
+    "accessory"
+  ]);
+  characterComponents = pgTable9("character_components", {
+    id: uuid8("id").primaryKey().defaultRandom(),
+    componentType: characterComponentTypeEnum("component_type").notNull(),
+    slug: varchar5("slug", { length: 128 }).notNull().unique(),
+    displayName: varchar5("display_name", { length: 128 }).notNull(),
+    slot: varchar5("slot", { length: 64 }).notNull(),
+    spriteSheetId: uuid8("sprite_sheet_id").notNull().references(() => spriteSheets.id, { onDelete: "cascade" }),
+    unlockLevel: integer6("unlock_level").notNull().default(0),
+    variant: integer6("variant").notNull().default(0),
+    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  playerCharacters = pgTable9("player_characters", {
+    id: uuid8("id").primaryKey().defaultRandom(),
+    userId: text8("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    bodyComponentId: uuid8("body_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    eyesComponentId: uuid8("eyes_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    hairstyleComponentId: uuid8("hairstyle_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    outfitComponentId: uuid8("outfit_component_id").notNull().references(() => characterComponents.id, { onDelete: "restrict" }),
+    accessoryComponentId: uuid8("accessory_component_id").references(() => characterComponents.id, {
+      onDelete: "set null"
+    }),
+    createdAt: timestamp9("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  characterComponentsRelations = relations7(characterComponents, ({ one }) => ({
+    sheet: one(spriteSheets, {
+      fields: [characterComponents.spriteSheetId],
+      references: [spriteSheets.id]
+    })
+  }));
+  playerCharactersRelations = relations7(playerCharacters, ({ one }) => ({
+    user: one(users, {
+      fields: [playerCharacters.userId],
+      references: [users.id]
+    }),
+    body: one(characterComponents, {
+      fields: [playerCharacters.bodyComponentId],
+      references: [characterComponents.id]
+    }),
+    eyes: one(characterComponents, {
+      fields: [playerCharacters.eyesComponentId],
+      references: [characterComponents.id]
+    }),
+    hair: one(characterComponents, {
+      fields: [playerCharacters.hairstyleComponentId],
+      references: [characterComponents.id]
+    }),
+    outfit: one(characterComponents, {
+      fields: [playerCharacters.outfitComponentId],
+      references: [characterComponents.id]
+    }),
+    accessory: one(characterComponents, {
+      fields: [playerCharacters.accessoryComponentId],
+      references: [characterComponents.id]
+    })
+  }));
+});
+
 // ../data/src/tables.index.ts
 var init_tables_index = __esm(() => {
-  init_table();
-  init_table2();
   init_table4();
   init_table5();
+  init_table();
+  init_table2();
   init_table3();
   init_table6();
+  init_table7();
+  init_table8();
+  init_table9();
 });
 
 // ../data/src/constants.ts
@@ -376,7 +564,10 @@ var init_constants = __esm(() => {
     FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
     COMMON_SWORD: "COMMON_SWORD",
     SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
-    SMALL_BACKPACK: "SMALL_BACKPACK"
+    SMALL_BACKPACK: "SMALL_BACKPACK",
+    LAVA_LAMP: "LAVA_LAMP",
+    BOOMBOX: "BOOMBOX",
+    CABIN_BED: "CABIN_BED"
   };
   CURRENCIES = {
     PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,