@playcademy/sdk 0.0.9 → 0.1.1

package/dist/index.js

@@ -14,14 +14,37 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 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;
@@ -34,7 +57,7 @@ var isBrowser = () => {
     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);
@@ -43,22 +66,37 @@ var isBrowser = () => {
   } 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":
@@ -72,24 +110,24 @@ var isBrowser = () => {
     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" && false) {}
-  if (isBrowser()) {
-    logInBrowser(level, message, context);
-  } else {
-    logOnServer(level, message, context);
+  if (level === "debug" && isProduction()) {
+    return;
+  }
+  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 {
@@ -860,6 +898,22 @@ function createTTLCache(options) {
 }
 
 // src/core/request.ts
+function checkDevWarnings(data) {
+  if (!data || typeof data !== "object")
+    return;
+  const response = data;
+  const warningType = response.__playcademyDevWarning;
+  if (!warningType)
+    return;
+  switch (warningType) {
+    case "timeback-disabled":
+      console.warn("%c⚠️ TimeBack Disabled in Dev", "background: #f59e0b; color: white; padding: 4px 8px; border-radius: 3px; font-weight: bold", `
+` + (response.__playcademyDevMessage || "TimeBack is disabled in local development"));
+      break;
+    default:
+      console.warn(`[Playcademy Dev Warning] ${warningType}`);
+  }
+}
 async function request({
   path,
   baseUrl,
@@ -894,7 +948,9 @@ async function request({
   const contentType = res.headers.get("content-type") ?? "";
   if (contentType.includes("application/json")) {
     try {
-      return await res.json();
+      const parsed = await res.json();
+      checkDevWarnings(parsed);
+      return parsed;
     } catch (err) {
       if (err instanceof SyntaxError)
         return;
@@ -1185,15 +1241,7 @@ function createDevNamespace(client) {
               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 finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
           const authToken = client.getToken();
           const tokenType = client.getTokenType();
           const headers = {
@@ -1461,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()
-  });
-});
+// ../constants/src/auth.ts
+var init_auth = () => {};
 
-// ../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]
-    })
-  }));
-});
+// ../constants/src/domains.ts
+var init_domains = () => {};
 
-// ../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]
-    })
-  }));
-});
+// ../constants/src/env-vars.ts
+var init_env_vars = () => {};
 
-// ../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]
-    })
-  }));
-});
-
-// ../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]
-    })
-  }));
-});
-
-// ../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();
-});
-
-// ../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",
@@ -2278,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
@@ -2358,7 +1644,7 @@ function createCreditsNamespace(client) {
   };
 }
 var init_credits = __esm(() => {
-  init_constants();
+  init_src2();
 });
 
 // src/core/namespaces/leaderboard.ts
@@ -2755,13 +2041,16 @@ var init_achievements = () => {};
 function createTimebackNamespace(client) {
   return {
     recordProgress: (progressData) => {
-      return client["request"]("/api/integrations/timeback/progress", "POST", { progressData });
+      return client["requestGameBackend"](TIMEBACK_ROUTES.PROGRESS, "POST", { progressData });
     },
     recordSessionEnd: (sessionData) => {
-      return client["request"]("/api/integrations/timeback/session-end", "POST", { sessionData });
+      return client["requestGameBackend"](TIMEBACK_ROUTES.SESSION_END, "POST", { sessionData });
     },
     awardXP: (xpAmount, metadata) => {
-      return client["request"]("/api/integrations/timeback/award-xp", "POST", { xpAmount, metadata });
+      return client["requestGameBackend"](TIMEBACK_ROUTES.AWARD_XP, "POST", {
+        xpAmount,
+        metadata
+      });
     },
     management: {
       setup: (request2) => {
@@ -2822,6 +2111,9 @@ function createTimebackNamespace(client) {
     }
   };
 }
+var init_timeback2 = __esm(() => {
+  init_src2();
+});
 
 // src/core/namespaces/notifications.ts
 function createNotificationsNamespace(client) {
@@ -2891,6 +2183,33 @@ function createNotificationsNamespace(client) {
 }
 var init_notifications = () => {};
 
+// src/core/namespaces/backend.ts
+function createBackendNamespace(client) {
+  function normalizePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+  return {
+    async get(path, headers) {
+      return client["requestGameBackend"](normalizePath(path), "GET", undefined, headers);
+    },
+    async post(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "POST", body, headers);
+    },
+    async put(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "PUT", body, headers);
+    },
+    async patch(path, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), "PATCH", body, headers);
+    },
+    async delete(path, headers) {
+      return client["requestGameBackend"](normalizePath(path), "DELETE", undefined, headers);
+    },
+    async request(path, method, body, headers) {
+      return client["requestGameBackend"](normalizePath(path), method, body, headers);
+    }
+  };
+}
+
 // src/core/namespaces/index.ts
 var init_namespaces = __esm(() => {
   init_identity();
@@ -2904,6 +2223,7 @@ var init_namespaces = __esm(() => {
   init_sprites();
   init_realtime();
   init_achievements();
+  init_timeback2();
   init_notifications();
 });
 
@@ -2933,6 +2253,9 @@ function buildAllowedOrigins(explicit) {
   return ref ? [ref] : [];
 }
 function isOriginAllowed(origin, allowlist) {
+  if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") {
+    return true;
+  }
   if (!allowlist || allowlist.length === 0) {
     console.error("[Playcademy SDK] No allowed origins configured. Consider passing allowedParentOrigins explicitly to init().");
     return false;
@@ -2976,7 +2299,8 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
 function createStandaloneConfig() {
   console.warn("[Playcademy SDK] Standalone mode detected, creating mock context for local development");
   const mockConfig = {
-    baseUrl: "/api",
+    baseUrl: "http://localhost:4321",
+    gameUrl: "http://localhost:8788",
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
     realtimeUrl: undefined
@@ -2995,6 +2319,7 @@ async function init(options) {
   }
   const client = new PlaycademyClient({
     baseUrl: config.baseUrl,
+    gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
     autoStartSession: window.self !== window.top
@@ -3072,6 +2397,7 @@ var init_client = __esm(() => {
   init_static();
   PlaycademyClient = class PlaycademyClient {
     baseUrl;
+    gameUrl;
     authStrategy;
     gameId;
     config;
@@ -3080,7 +2406,8 @@ var init_client = __esm(() => {
     authContext;
     initPayload;
     constructor(config) {
-      this.baseUrl = config?.baseUrl || "/api";
+      this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
+      this.gameUrl = config?.gameUrl;
       this.gameId = config?.gameId;
       this.config = config || {};
       this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
@@ -3092,6 +2419,15 @@ var init_client = __esm(() => {
       const isBrowser2 = typeof window !== "undefined";
       return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
     }
+    getGameBackendUrl() {
+      if (!this.gameUrl) {
+        throw new PlaycademyError("Game backend URL not configured. gameUrl must be set to use game backend features.");
+      }
+      const isRelative = this.gameUrl.startsWith("/");
+      const isBrowser2 = typeof window !== "undefined";
+      const effectiveGameUrl = isRelative && isBrowser2 ? `${window.location.origin}${this.gameUrl}` : this.gameUrl;
+      return `${effectiveGameUrl}/api`;
+    }
     ping() {
       return "pong";
     }
@@ -3136,6 +2472,19 @@ var init_client = __esm(() => {
         extraHeaders: effectiveHeaders
       });
     }
+    async requestGameBackend(path, method, body, headers) {
+      const effectiveHeaders = {
+        ...headers,
+        ...this.authStrategy.getHeaders()
+      };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.getGameBackendUrl(),
+        extraHeaders: effectiveHeaders
+      });
+    }
     _ensureGameId() {
       if (!this.gameId) {
         throw new PlaycademyError("This operation requires a gameId, but none was provided when initializing the client.");
@@ -3185,6 +2534,7 @@ var init_client = __esm(() => {
     realtime = createRealtimeNamespace(this);
     achievements = createAchievementsNamespace(this);
     notifications = createNotificationsNamespace(this);
+    backend = createBackendNamespace(this);
     static init = init;
     static login = login2;
     static identity = identity;
@@ -3194,25 +2544,8 @@ var init_client = __esm(() => {
 // src/index.ts
 init_client();
 init_messaging();
-
-// src/constants.ts
-var CURRENCIES2 = {
-  PRIMARY: "PLAYCADEMY_CREDITS",
-  XP: "PLAYCADEMY_XP"
-};
-var BADGES2 = {
-  FOUNDING_MEMBER: "FOUNDING_MEMBER_BADGE",
-  EARLY_ADOPTER: "EARLY_ADOPTER_BADGE",
-  FIRST_GAME: "FIRST_GAME_BADGE"
-};
-var AuthProvider = {
-  TIMEBACK: "TIMEBACK"
-};
 export {
   messaging,
   PlaycademyClient,
-  MessageEvents,
-  CURRENCIES2 as CURRENCIES,
-  BADGES2 as BADGES,
-  AuthProvider
+  MessageEvents
 };