@playcademy/sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -11,19 +11,40 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // ../logger/src/index.ts
-var hasProcess = () => {
-  return typeof process !== "undefined";
-}, isBrowser = () => {
+var isBrowser = () => {
   const g = globalThis;
   return typeof g.window !== "undefined" && typeof g.document !== "undefined";
-}, colors, shouldUseColor = () => {
-  const preference = (process.env.LOG_COLOR ?? "auto").toLowerCase();
-  if (preference === "always")
-    return true;
-  if (preference === "never")
-    return false;
-  return Boolean(process.stdout && process.stdout.isTTY && true);
-}, getLevelColor = (level) => {
+}, isProduction = () => {
+  return false;
+}, isDevelopment = () => {
+  return true;
+}, isInteractiveTTY = () => {
+  return Boolean(process.stdout && process.stdout.isTTY);
+}, detectOutputFormat = () => {
+  if (isBrowser()) {
+    return "browser";
+  }
+  if (process.env.LOG_FORMAT === "json") {
+    return "json-single-line";
+  }
+  if (process.env.LOG_PRETTY === "true" && isDevelopment()) {
+    return "json-pretty";
+  }
+  const colorPreference = (process.env.LOG_COLOR ?? "auto").toLowerCase();
+  if (colorPreference === "always" && !isProduction()) {
+    return "color-tty";
+  }
+  if (colorPreference === "never") {
+    return "json-single-line";
+  }
+  if (isProduction()) {
+    return "json-single-line";
+  }
+  if (isDevelopment() && isInteractiveTTY()) {
+    return "color-tty";
+  }
+  return "json-single-line";
+}, colors, getLevelColor = (level) => {
   switch (level) {
     case "debug":
       return colors.blue;
@@ -36,7 +57,7 @@ var hasProcess = () => {
     default:
       return colors.reset;
   }
-}, logInBrowser = (level, message, context) => {
+}, formatBrowserOutput = (level, message, context) => {
   const timestamp = new Date().toISOString();
   const levelUpper = level.toUpperCase();
   const consoleMethod = getConsoleMethod(level);
@@ -45,22 +66,37 @@ var hasProcess = () => {
   } else {
     consoleMethod(`[${timestamp}] ${levelUpper}`, message);
   }
-}, logOnServer = (level, message, context) => {
+}, formatColorTTY = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const levelColor = getLevelColor(level);
+  const levelUpper = level.toUpperCase().padEnd(5);
   const consoleMethod = getConsoleMethod(level);
-  if (shouldUseColor()) {
-    const timestamp = new Date().toISOString();
-    const levelColor = getLevelColor(level);
-    const levelUpper = level.toUpperCase().padEnd(5);
-    const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
-    if (context && Object.keys(context).length > 0) {
-      consoleMethod(`${coloredPrefix} ${message}`, context);
-    } else {
-      consoleMethod(`${coloredPrefix} ${message}`);
-    }
+  const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+  if (context && Object.keys(context).length > 0) {
+    consoleMethod(`${coloredPrefix} ${message}`, context);
   } else {
-    const formatted = formatLog(level, message, context);
-    consoleMethod(formatted);
+    consoleMethod(`${coloredPrefix} ${message}`);
   }
+}, formatJSONSingleLine = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    level: level.toUpperCase(),
+    message,
+    ...context && Object.keys(context).length > 0 && { context }
+  };
+  const consoleMethod = getConsoleMethod(level);
+  consoleMethod(JSON.stringify(logEntry));
+}, formatJSONPretty = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    level: level.toUpperCase(),
+    message,
+    ...context && Object.keys(context).length > 0 && { context }
+  };
+  const consoleMethod = getConsoleMethod(level);
+  consoleMethod(JSON.stringify(logEntry, null, 2));
 }, getConsoleMethod = (level) => {
   switch (level) {
     case "debug":
@@ -74,26 +110,24 @@ var hasProcess = () => {
     default:
       return console.log;
   }
-}, formatLog = (level, message, context) => {
-  const timestamp = new Date().toISOString();
-  const logEntry = {
-    timestamp,
-    level: level.toUpperCase(),
-    message,
-    ...context && Object.keys(context).length > 0 && { context }
-  };
-  if (true) {
-    return JSON.stringify(logEntry, null, 2);
-  }
-  return JSON.stringify(logEntry);
 }, performLog = (level, message, context) => {
-  if (level === "debug" && hasProcess() && process.env.PLAYCADEMY_EMBEDDED) {
+  if (level === "debug" && isProduction()) {
     return;
   }
-  if (isBrowser()) {
-    logInBrowser(level, message, context);
-  } else {
-    logOnServer(level, message, context);
+  const outputFormat = detectOutputFormat();
+  switch (outputFormat) {
+    case "browser":
+      formatBrowserOutput(level, message, context);
+      break;
+    case "color-tty":
+      formatColorTTY(level, message, context);
+      break;
+    case "json-single-line":
+      formatJSONSingleLine(level, message, context);
+      break;
+    case "json-pretty":
+      formatJSONPretty(level, message, context);
+      break;
   }
 }, createLogger = () => {
   return {
@@ -1475,801 +1509,18 @@ function createLevelsNamespace(client) {
 }
 var init_levels = () => {};
 
-// ../data/src/domains/game/table.ts
-import {
-  boolean,
-  jsonb,
-  pgEnum,
-  pgTable,
-  text,
-  timestamp,
-  uniqueIndex,
-  uuid,
-  varchar
-} from "drizzle-orm/pg-core";
-var gamePlatformEnum, gameBootModeEnum, gameTypeEnum, games, gameSessions, gameStates, deploymentProviderEnum, gameBackendDeployments;
-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)]);
-  deploymentProviderEnum = pgEnum("deployment_provider", ["cloudflare", "aws"]);
-  gameBackendDeployments = pgTable("game_backend_deployments", {
-    id: uuid("id").primaryKey().defaultRandom(),
-    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    deploymentId: text("deployment_id").notNull(),
-    provider: deploymentProviderEnum("provider").notNull(),
-    url: text("url").notNull(),
-    codeHash: text("code_hash"),
-    isActive: boolean("is_active").notNull().default(false),
-    deployedAt: timestamp("deployed_at", { withTimezone: true }).notNull().defaultNow()
-  });
-});
-
-// ../data/src/domains/inventory/table.ts
-import { relations, sql } from "drizzle-orm";
-import {
-  boolean as boolean2,
-  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: boolean2("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: boolean2("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: boolean2("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 boolean3, 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: boolean3("email_verified").notNull().default(false),
-    image: text4("image"),
-    role: userRoleEnum("role").notNull().default("player"),
-    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
-    characterCreated: boolean3("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 { boolean as boolean4, integer as integer3, pgTable as pgTable5, text as text5, timestamp as timestamp5, uuid as uuid4 } from "drizzle-orm/pg-core";
-var apikey;
-var init_table5 = __esm(() => {
-  init_table4();
-  apikey = pgTable5("api_key", {
-    id: uuid4("id").primaryKey().defaultRandom(),
-    name: text5("name"),
-    start: text5("start"),
-    prefix: text5("prefix"),
-    key: text5("key").notNull(),
-    userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    refillInterval: integer3("refill_interval"),
-    refillAmount: integer3("refill_amount"),
-    lastRefillAt: timestamp5("last_refill_at", { withTimezone: true }),
-    enabled: boolean4("enabled").notNull().default(true),
-    rateLimitEnabled: boolean4("rate_limit_enabled").notNull().default(false),
-    rateLimitTimeWindow: integer3("rate_limit_time_window"),
-    rateLimitMax: integer3("rate_limit_max"),
-    requestCount: integer3("request_count").notNull().default(0),
-    remaining: integer3("remaining"),
-    lastRequest: timestamp5("last_request", { withTimezone: true }),
-    expiresAt: timestamp5("expires_at", { withTimezone: true }),
-    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp5("updated_at", { withTimezone: true }).notNull().defaultNow(),
-    permissions: text5("permissions"),
-    metadata: text5("metadata")
-  });
-});
-
-// ../data/src/domains/level/table.ts
-import { relations as relations4 } from "drizzle-orm";
-import {
-  doublePrecision as doublePrecision2,
-  integer as integer4,
-  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: integer4("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: integer4("level").notNull().unique(),
-    xpRequired: integer4("xp_required").notNull(),
-    creditsReward: integer4("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 integer5, 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: integer5("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 integer6, pgTable as pgTable8, timestamp as timestamp8, uuid as uuid7, varchar as varchar3 } from "drizzle-orm/pg-core";
-var spriteTemplates, spriteSheets, spriteTemplatesRelations, spriteSheetsRelations;
-var init_table8 = __esm(() => {
-  spriteTemplates = pgTable8("sprite_templates", {
-    id: uuid7("id").primaryKey().defaultRandom(),
-    slug: varchar3("slug", { length: 64 }).notNull().unique(),
-    url: varchar3("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: integer6("width").notNull(),
-    height: integer6("height").notNull(),
-    url: varchar3("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 integer7,
-  pgEnum as pgEnum5,
-  pgTable as pgTable9,
-  text as text8,
-  timestamp as timestamp9,
-  uniqueIndex as uniqueIndex6,
-  uuid as uuid8,
-  varchar as varchar4
-} 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: varchar4("slug", { length: 128 }).notNull().unique(),
-    displayName: varchar4("display_name", { length: 128 }).notNull(),
-    slot: varchar4("slot", { length: 64 }).notNull(),
-    spriteSheetId: uuid8("sprite_sheet_id").notNull().references(() => spriteSheets.id, { onDelete: "cascade" }),
-    unlockLevel: integer7("unlock_level").notNull().default(0),
-    variant: integer7("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: varchar4("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, gameTimebackIntegrations;
-var init_table10 = __esm(() => {
-  init_table();
-  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)]);
-  gameTimebackIntegrations = pgTable10("game_timeback_integrations", {
-    id: uuid9("id").primaryKey().defaultRandom(),
-    gameId: uuid9("game_id").notNull().unique().references(() => games.id, { onDelete: "cascade" }),
-    courseId: text9("course_id").notNull(),
-    lastVerifiedAt: timestamp10("last_verified_at", { withTimezone: true }),
-    createdAt: timestamp10("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp10("updated_at", { withTimezone: true }).notNull().defaultNow()
-  });
-});
-
-// ../data/src/domains/achievement/table.ts
-import { relations as relations8 } from "drizzle-orm";
-import {
-  boolean as boolean5,
-  index as index3,
-  integer as integer8,
-  jsonb as jsonb5,
-  pgEnum as pgEnum6,
-  pgTable as pgTable11,
-  text as text10,
-  timestamp as timestamp11,
-  uniqueIndex as uniqueIndex8,
-  uuid as uuid10,
-  varchar as varchar5
-} from "drizzle-orm/pg-core";
-var achievementScopeEnum, achievements, userAchievementProgress, userAchievementClaims, userAchievementProgressRelations, userAchievementClaimsRelations;
-var init_table11 = __esm(() => {
-  init_table4();
-  achievementScopeEnum = pgEnum6("achievement_scope", [
-    "daily",
-    "weekly",
-    "monthly",
-    "yearly",
-    "game",
-    "global",
-    "map",
-    "level",
-    "event"
-  ]);
-  achievements = pgTable11("achievements", {
-    id: varchar5("id", { length: 255 }).primaryKey(),
-    title: varchar5("title", { length: 255 }).notNull(),
-    description: text10("description"),
-    scope: achievementScopeEnum("scope").notNull(),
-    rewardCredits: integer8("reward_credits").notNull().default(0),
-    limit: integer8("limit").notNull().default(1),
-    completionType: varchar5("completion_type", { length: 50 }).notNull(),
-    completionConfig: jsonb5("completion_config").notNull().default({}),
-    target: jsonb5("target").notNull().default({}),
-    active: boolean5("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: varchar5("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    scopeKey: text10("scope_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.scopeKey)
-  ]);
-  userAchievementClaims = pgTable11("user_achievement_claims", {
-    id: uuid10("id").primaryKey().defaultRandom(),
-    userId: text10("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    achievementId: varchar5("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    scopeKey: text10("scope_key").notNull(),
-    rewardCredits: integer8("reward_credits").notNull(),
-    createdAt: timestamp11("created_at", { withTimezone: true }).defaultNow().notNull()
-  }, (table) => [
-    uniqueIndex8("user_achievement_claims_unique").on(table.userId, table.achievementId, table.scopeKey)
-  ]);
-  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]
-    })
-  }));
-});
+// ../constants/src/auth.ts
+var init_auth = () => {};
 
-// ../data/src/domains/notification/table.ts
-import { relations as relations9 } from "drizzle-orm";
-import { index as index4, jsonb as jsonb6, pgEnum as pgEnum7, pgTable as pgTable12, text as text11, timestamp as timestamp12, uuid as uuid11, varchar as varchar6 } from "drizzle-orm/pg-core";
-var notificationPriorityEnum, notificationStatusEnum, notifications, notificationsRelations;
-var init_table12 = __esm(() => {
-  init_table4();
-  notificationPriorityEnum = pgEnum7("notification_priority", [
-    "low",
-    "normal",
-    "high",
-    "urgent"
-  ]);
-  notificationStatusEnum = pgEnum7("notification_status", [
-    "pending",
-    "delivered",
-    "seen",
-    "clicked",
-    "dismissed",
-    "expired"
-  ]);
-  notifications = pgTable12("notifications", {
-    id: uuid11("id").primaryKey().defaultRandom(),
-    userId: text11("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    type: varchar6("type", { length: 50 }).notNull(),
-    title: varchar6("title", { length: 255 }).notNull(),
-    message: text11("message").notNull(),
-    data: jsonb6("data").notNull().default({}),
-    priority: notificationPriorityEnum("priority").notNull().default("normal"),
-    status: notificationStatusEnum("status").notNull().default("pending"),
-    createdAt: timestamp12("created_at", { withTimezone: true }).defaultNow().notNull(),
-    deliveredAt: timestamp12("delivered_at", { withTimezone: true }),
-    seenAt: timestamp12("seen_at", { withTimezone: true }),
-    clickedAt: timestamp12("clicked_at", { withTimezone: true }),
-    expiresAt: timestamp12("expires_at", { withTimezone: true }),
-    method: varchar6("method", { length: 50 }),
-    clickUrl: text11("click_url"),
-    metadata: jsonb6("metadata").notNull().default({})
-  }, (table) => [
-    index4("notifications_user_id_idx").on(table.userId),
-    index4("notifications_status_idx").on(table.status),
-    index4("notifications_type_idx").on(table.type),
-    index4("notifications_created_at_idx").on(table.createdAt),
-    index4("notifications_user_status_idx").on(table.userId, table.status)
-  ]);
-  notificationsRelations = relations9(notifications, ({ one }) => ({
-    user: one(users, {
-      fields: [notifications.userId],
-      references: [users.id]
-    })
-  }));
-});
+// ../constants/src/domains.ts
+var init_domains = () => {};
 
-// ../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();
-  init_table12();
-});
+// ../constants/src/env-vars.ts
+var init_env_vars = () => {};
 
-// ../data/src/constants.ts
-var ITEM_SLUGS, CURRENCIES, BADGES, INTERACTION_TYPE;
-var init_constants = __esm(() => {
-  init_tables_index();
+// ../constants/src/overworld.ts
+var ITEM_SLUGS, CURRENCIES, BADGES;
+var init_overworld = __esm(() => {
   ITEM_SLUGS = {
     PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
     PLAYCADEMY_XP: "PLAYCADEMY_XP",
@@ -2292,7 +1543,28 @@ var init_constants = __esm(() => {
     EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
     FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
   };
-  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
+});
+// ../constants/src/timeback.ts
+var TIMEBACK_ROUTES;
+var init_timeback = __esm(() => {
+  TIMEBACK_ROUTES = {
+    PROGRESS: "/integrations/timeback/progress",
+    SESSION_END: "/integrations/timeback/session-end",
+    AWARD_XP: "/integrations/timeback/award-xp"
+  };
+});
+
+// ../constants/src/workers.ts
+var init_workers = () => {};
+
+// ../constants/src/index.ts
+var init_src2 = __esm(() => {
+  init_auth();
+  init_domains();
+  init_env_vars();
+  init_overworld();
+  init_timeback();
+  init_workers();
 });
 
 // src/core/cache/singleton-cache.ts
@@ -2372,7 +1644,7 @@ function createCreditsNamespace(client) {
   };
 }
 var init_credits = __esm(() => {
-  init_constants();
+  init_src2();
 });
 
 // src/core/namespaces/leaderboard.ts
@@ -2765,28 +2037,6 @@ function createAchievementsNamespace(client) {
 }
 var init_achievements = () => {};
 
-// src/constants.ts
-var CURRENCIES2, BADGES2, AuthProvider, TIMEBACK_ROUTES;
-var init_constants2 = __esm(() => {
-  CURRENCIES2 = {
-    PRIMARY: "PLAYCADEMY_CREDITS",
-    XP: "PLAYCADEMY_XP"
-  };
-  BADGES2 = {
-    FOUNDING_MEMBER: "FOUNDING_MEMBER_BADGE",
-    EARLY_ADOPTER: "EARLY_ADOPTER_BADGE",
-    FIRST_GAME: "FIRST_GAME_BADGE"
-  };
-  AuthProvider = {
-    TIMEBACK: "TIMEBACK"
-  };
-  TIMEBACK_ROUTES = {
-    PROGRESS: "/api/integrations/timeback/progress",
-    SESSION_END: "/api/integrations/timeback/session-end",
-    AWARD_XP: "/api/integrations/timeback/award-xp"
-  };
-});
-
 // src/core/namespaces/timeback.ts
 function createTimebackNamespace(client) {
   return {
@@ -2861,8 +2111,8 @@ function createTimebackNamespace(client) {
     }
   };
 }
-var init_timeback = __esm(() => {
-  init_constants2();
+var init_timeback2 = __esm(() => {
+  init_src2();
 });
 
 // src/core/namespaces/notifications.ts
@@ -2973,7 +2223,7 @@ var init_namespaces = __esm(() => {
   init_sprites();
   init_realtime();
   init_achievements();
-  init_timeback();
+  init_timeback2();
   init_notifications();
 });
 
@@ -3294,12 +2544,8 @@ var init_client = __esm(() => {
 // src/index.ts
 init_client();
 init_messaging();
-init_constants2();
 export {
   messaging,
   PlaycademyClient,
-  MessageEvents,
-  CURRENCIES2 as CURRENCIES,
-  BADGES2 as BADGES,
-  AuthProvider
+  MessageEvents
 };