@playcademy/sdk 0.0.1-beta.24 → 0.0.1-beta.26

package/dist/index.js

@@ -10,6 +10,86 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// ../logger/src/index.ts
+var isBrowser = () => {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}, colors, getLevelColor = (level) => {
+  switch (level) {
+    case "debug":
+      return colors.blue;
+    case "info":
+      return colors.cyan;
+    case "warn":
+      return colors.yellow;
+    case "error":
+      return colors.red;
+    default:
+      return colors.reset;
+  }
+}, logInBrowser = (level, message, context) => {
+  const timestamp = new Date().toISOString();
+  const levelUpper = level.toUpperCase();
+  const consoleMethod = getConsoleMethod(level);
+  if (context && Object.keys(context).length > 0) {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message, context);
+  } else {
+    consoleMethod(`[${timestamp}] ${levelUpper}`, message);
+  }
+}, logOnServer = (level, message, context) => {
+  const consoleMethod = getConsoleMethod(level);
+  if (true) {
+    const timestamp = new Date().toISOString();
+    const levelColor = getLevelColor(level);
+    const levelUpper = level.toUpperCase().padEnd(5);
+    const coloredPrefix = `${colors.dim}[${timestamp}]${colors.reset} ${levelColor}${levelUpper}${colors.reset}`;
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(`${coloredPrefix} ${message}`, context);
+    } else {
+      consoleMethod(`${coloredPrefix} ${message}`);
+    }
+  } else {}
+}, getConsoleMethod = (level) => {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+    default:
+      return console.log;
+  }
+}, performLog = (level, message, context) => {
+  if (level === "debug" && false) {}
+  if (isBrowser()) {
+    logInBrowser(level, message, context);
+  } else {
+    logOnServer(level, message, context);
+  }
+}, createLogger = () => {
+  return {
+    debug: (message, context) => performLog("debug", message, context),
+    info: (message, context) => performLog("info", message, context),
+    warn: (message, context) => performLog("warn", message, context),
+    error: (message, context) => performLog("error", message, context),
+    log: performLog
+  };
+}, log;
+var init_src = __esm(() => {
+  colors = {
+    reset: "\x1B[0m",
+    dim: "\x1B[2m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    cyan: "\x1B[36m",
+    gray: "\x1B[90m"
+  };
+  log = createLogger();
+});
+
 // src/core/errors.ts
 var PlaycademyError, ApiError;
 var init_errors = __esm(() => {
@@ -31,68 +111,6 @@ var init_errors = __esm(() => {
   };
 });
 
-// src/core/request.ts
-async function request({
-  path,
-  baseUrl,
-  token,
-  method = "GET",
-  body,
-  extraHeaders = {}
-}) {
-  const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
-  const headers = { ...extraHeaders };
-  let payload;
-  if (body instanceof FormData) {
-    payload = body;
-  } else if (body !== undefined && body !== null) {
-    payload = JSON.stringify(body);
-    headers["Content-Type"] = "application/json";
-  }
-  if (token)
-    headers["Authorization"] = `Bearer ${token}`;
-  const res = await fetch(url, {
-    method,
-    headers,
-    body: payload,
-    credentials: "omit"
-  });
-  if (!res.ok) {
-    const errorBody = await res.clone().json().catch(() => res.text().catch(() => {
-      return;
-    })) ?? undefined;
-    throw new ApiError(res.status, res.statusText, errorBody);
-  }
-  if (res.status === 204)
-    return;
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    return await res.json();
-  }
-  return await res.text();
-}
-async function fetchManifest(assetBundleBase) {
-  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
-  try {
-    const response = await fetch(manifestUrl);
-    if (!response.ok) {
-      console.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
-      throw new PlaycademyError(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
-    }
-    return await response.json();
-  } catch (error) {
-    if (error instanceof PlaycademyError) {
-      throw error;
-    }
-    console.error(`[fetchManifest] Error fetching or parsing manifest from ${manifestUrl}:`, error);
-    throw new PlaycademyError("Failed to load or parse game manifest");
-  }
-}
-var init_request = __esm(() => {
-  init_errors();
-  init_errors();
-});
-
 // src/core/namespaces/auth.ts
 function createAuthNamespace(client) {
   return {
@@ -208,7 +226,10 @@ function createRuntimeNamespace(client) {
         try {
           await client.games.endSession(client["internalClientSessionId"], client["gameId"]);
         } catch (error) {
-          console.error("[SDK] Failed to auto-end session:", client["internalClientSessionId"], error);
+          log.error("[Playcademy SDK] Failed to auto-end session:", {
+            sessionId: client["internalClientSessionId"],
+            error
+          });
         }
       }
       messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
@@ -216,9 +237,74 @@ function createRuntimeNamespace(client) {
   };
 }
 var init_runtime = __esm(() => {
+  init_src();
   init_messaging();
 });
 
+// src/core/request.ts
+async function request({
+  path,
+  baseUrl,
+  token,
+  method = "GET",
+  body,
+  extraHeaders = {}
+}) {
+  const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
+  const headers = { ...extraHeaders };
+  let payload;
+  if (body instanceof FormData) {
+    payload = body;
+  } else if (body !== undefined && body !== null) {
+    payload = JSON.stringify(body);
+    headers["Content-Type"] = "application/json";
+  }
+  if (token)
+    headers["Authorization"] = `Bearer ${token}`;
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: payload,
+    credentials: "omit"
+  });
+  if (!res.ok) {
+    const errorBody = await res.clone().json().catch(() => res.text().catch(() => {
+      return;
+    })) ?? undefined;
+    throw new ApiError(res.status, res.statusText, errorBody);
+  }
+  if (res.status === 204)
+    return;
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return await res.json();
+  }
+  return await res.text();
+}
+async function fetchManifest(assetBundleBase) {
+  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
+  try {
+    const response = await fetch(manifestUrl);
+    if (!response.ok) {
+      log.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
+      throw new PlaycademyError(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof PlaycademyError) {
+      throw error;
+    }
+    log.error(`[Playcademy SDK] Error fetching or parsing manifest from ${manifestUrl}:`, {
+      error
+    });
+    throw new PlaycademyError("Failed to load or parse game manifest");
+  }
+}
+var init_request = __esm(() => {
+  init_src();
+  init_errors();
+});
+
 // src/core/namespaces/games.ts
 function createGamesNamespace(client) {
   return {
@@ -263,15 +349,17 @@ function createUsersNamespace(client) {
   const resolveItemId = async (identifier) => {
     if (UUID_REGEX.test(identifier))
       return identifier;
-    if (itemIdCache.has(identifier))
-      return itemIdCache.get(identifier);
-    const inventory = await client.users.inventory.get();
-    const item = inventory.find((inv) => inv.item?.internalName === identifier);
-    if (!item) {
-      throw new Error(`Item with internal name '${identifier}' not found in inventory`);
-    }
-    itemIdCache.set(identifier, item.item.id);
-    return item.item.id;
+    const gameId = client["gameId"];
+    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
+    if (itemIdCache.has(cacheKey)) {
+      return itemIdCache.get(cacheKey);
+    }
+    const queryParams = new URLSearchParams({ slug: identifier });
+    if (gameId)
+      queryParams.append("gameId", gameId);
+    const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+    itemIdCache.set(cacheKey, item.id);
+    return item.id;
   };
   return {
     me: async () => {
@@ -300,12 +388,9 @@ function createUsersNamespace(client) {
         return res;
       },
       quantity: async (identifier) => {
+        const itemId = await resolveItemId(identifier);
         const inventory = await client.users.inventory.get();
-        if (UUID_REGEX.test(identifier)) {
-          const item2 = inventory.find((inv) => inv.item?.id === identifier);
-          return item2?.quantity ?? 0;
-        }
-        const item = inventory.find((inv) => inv.item?.internalName === identifier);
+        const item = inventory.find((inv) => inv.item?.id === itemId);
         return item?.quantity ?? 0;
       },
       has: async (identifier, minQuantity = 1) => {
@@ -337,9 +422,39 @@ function createDevNamespace(client) {
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE")
     },
     keys: {
-      createKey: (gameId, label) => client["request"](`/dev/games/${gameId}/keys`, "POST", { label }),
-      listKeys: (gameId) => client["request"](`/dev/games/${gameId}/keys`, "GET"),
+      createKey: (label) => client["request"](`/dev/keys`, "POST", { label }),
+      listKeys: () => client["request"](`/dev/keys`, "GET"),
       revokeKey: (keyId) => client["request"](`/dev/keys/${keyId}`, "DELETE")
+    },
+    items: {
+      create: (gameId, slug, itemData) => client["request"](`/games/${gameId}/items`, "POST", {
+        slug,
+        ...itemData
+      }),
+      update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}`, "PATCH", updates),
+      list: (gameId) => client["request"](`/games/${gameId}/items`, "GET"),
+      get: (gameId, slug) => {
+        const queryParams = new URLSearchParams({ slug, gameId });
+        return client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+      },
+      delete: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}`, "DELETE"),
+      shop: {
+        create: (gameId, itemId, listingData) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "POST", listingData);
+        },
+        get: (gameId, itemId) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "GET");
+        },
+        update: (gameId, itemId, updates) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "PATCH", updates);
+        },
+        delete: (gameId, itemId) => {
+          return client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "DELETE");
+        },
+        list: (gameId) => {
+          return client["request"](`/games/${gameId}/shop-listings`, "GET");
+        }
+      }
     }
   };
 }
@@ -437,10 +552,365 @@ function createLevelsNamespace(client) {
   };
 }
 
+// ../data/src/domains/user/table.ts
+import { boolean, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification;
+var init_table = __esm(() => {
+  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer"]);
+  developerStatusEnum = pgEnum("developer_status", ["none", "pending", "approved"]);
+  users = pgTable("user", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    name: text("name").notNull(),
+    username: text("username").unique(),
+    email: text("email").notNull().unique(),
+    emailVerified: boolean("email_verified").notNull().default(false),
+    image: text("image"),
+    role: userRoleEnum("role").notNull().default("player"),
+    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  accounts = pgTable("account", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: timestamp("access_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    refreshTokenExpiresAt: timestamp("refresh_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  }, (table) => [uniqueIndex("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
+  sessions = pgTable("session", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    expiresAt: timestamp("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    token: text("token").notNull().unique(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  verification = pgTable("verification", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: timestamp("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+});
+
+// ../data/src/domains/developer/table.ts
+import { pgTable as pgTable2, text as text2, timestamp as timestamp2, uuid, varchar } from "drizzle-orm/pg-core";
+var developerKeys;
+var init_table2 = __esm(() => {
+  init_table();
+  developerKeys = pgTable2("developer_keys", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text2("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    label: varchar("label", { length: 255 }),
+    keyHash: text2("key_hash").notNull().unique(),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  });
+});
+
+// ../data/src/domains/map/table.ts
+import { relations } from "drizzle-orm";
+import {
+  doublePrecision,
+  jsonb,
+  pgEnum as pgEnum2,
+  pgTable as pgTable3,
+  text as text3,
+  uniqueIndex as uniqueIndex2,
+  uuid as uuid2,
+  varchar as varchar2
+} from "drizzle-orm/pg-core";
+var interactionTypeEnum, maps, mapElements, mapElementsRelations, mapsRelations;
+var init_table3 = __esm(() => {
+  init_table4();
+  interactionTypeEnum = pgEnum2("interaction_type", [
+    "game_entry",
+    "game_registry",
+    "info",
+    "teleport",
+    "door_in",
+    "door_out",
+    "npc_interaction",
+    "quest_trigger"
+  ]);
+  maps = pgTable3("maps", {
+    id: uuid2("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: uuid2("id").primaryKey().defaultRandom(),
+    mapId: uuid2("map_id").references(() => maps.id, {
+      onDelete: "cascade"
+    }),
+    elementSlug: varchar2("element_slug", { length: 255 }).notNull(),
+    interactionType: interactionTypeEnum("interaction_type").notNull(),
+    gameId: uuid2("game_id").references(() => games.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb("metadata").$type().default({})
+  }, (table) => [uniqueIndex2("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
+  mapElementsRelations = relations(mapElements, ({ one }) => ({
+    game: one(games, {
+      fields: [mapElements.gameId],
+      references: [games.id]
+    }),
+    map: one(maps, {
+      fields: [mapElements.mapId],
+      references: [maps.id]
+    })
+  }));
+  mapsRelations = relations(maps, ({ many }) => ({
+    elements: many(mapElements)
+  }));
+});
+
+// ../data/src/domains/game/table.ts
+import {
+  jsonb as jsonb2,
+  pgEnum as pgEnum3,
+  pgTable as pgTable4,
+  text as text4,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
+  varchar as varchar3
+} from "drizzle-orm/pg-core";
+var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
+var init_table4 = __esm(() => {
+  init_table3();
+  init_table();
+  gamePlatformEnum = pgEnum3("game_platform", ["web", "godot", "unity"]);
+  gameBootModeEnum = pgEnum3("game_boot_mode", ["iframe", "module"]);
+  games = pgTable4("games", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    developerId: text4("developer_id").references(() => users.id, {
+      onDelete: "set null"
+    }),
+    slug: varchar3("slug", { length: 255 }).notNull().unique(),
+    displayName: varchar3("display_name", { length: 255 }).notNull(),
+    version: varchar3("version", { length: 50 }).notNull(),
+    assetBundleBase: text4("asset_bundle_base").notNull(),
+    platform: gamePlatformEnum("platform").notNull().default("web"),
+    mapElementId: uuid3("map_element_id").references(() => mapElements.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb2("metadata").default("{}"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
+  });
+  gameSessions = pgTable4("game_sessions", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
+    endedAt: timestamp3("ended_at", { withTimezone: true })
+  });
+  gameStates = pgTable4("game_states", {
+    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    data: jsonb2("data").default("{}"),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex3("unique_user_game_idx").on(table.userId, table.gameId)]);
+});
+
+// ../data/src/domains/inventory/table.ts
+import { relations as relations2, sql } from "drizzle-orm";
+import {
+  boolean as boolean2,
+  integer,
+  jsonb as jsonb3,
+  pgEnum as pgEnum4,
+  pgTable as pgTable5,
+  text as text5,
+  timestamp as timestamp4,
+  uniqueIndex as uniqueIndex4,
+  uuid as uuid4
+} from "drizzle-orm/pg-core";
+var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
+var init_table5 = __esm(() => {
+  init_table4();
+  init_table();
+  itemTypeEnum = pgEnum4("item_type", [
+    "currency",
+    "badge",
+    "trophy",
+    "collectible",
+    "consumable",
+    "unlock",
+    "upgrade",
+    "other"
+  ]);
+  items = pgTable5("items", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    slug: text5("slug").notNull(),
+    gameId: uuid4("game_id").references(() => games.id, {
+      onDelete: "cascade"
+    }),
+    displayName: text5("display_name").notNull(),
+    description: text5("description"),
+    type: itemTypeEnum("type").notNull().default("other"),
+    imageUrl: text5("image_url"),
+    metadata: jsonb3("metadata").default({}),
+    createdAt: timestamp4("created_at").defaultNow().notNull()
+  }, (table) => [
+    uniqueIndex4("items_game_slug_idx").on(table.gameId, table.slug),
+    uniqueIndex4("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
+  ]);
+  inventoryItems = pgTable5("inventory_items", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    quantity: integer("quantity").notNull().default(1),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex4("unique_user_item_idx").on(table.userId, table.itemId)]);
+  currencies = pgTable5("currencies", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    symbol: text5("symbol"),
+    isPrimary: boolean2("is_primary").default(false).notNull(),
+    createdAt: timestamp4("created_at").defaultNow().notNull(),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex4("currency_item_id_idx").on(table.itemId)]);
+  shopListings = pgTable5("shop_listings", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    currencyId: uuid4("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
+    price: integer("price").notNull(),
+    sellBackPercentage: integer("sell_back_percentage"),
+    stock: integer("stock"),
+    isActive: boolean2("is_active").default(true).notNull(),
+    availableFrom: timestamp4("available_from", { withTimezone: true }),
+    availableUntil: timestamp4("available_until", { withTimezone: true }),
+    createdAt: timestamp4("created_at").defaultNow().notNull(),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex4("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
+  itemsRelations = relations2(items, ({ many }) => ({
+    shopListings: many(shopListings),
+    inventoryItems: many(inventoryItems)
+  }));
+  currenciesRelations = relations2(currencies, ({ many }) => ({
+    shopListings: many(shopListings)
+  }));
+  shopListingsRelations = relations2(shopListings, ({ one }) => ({
+    item: one(items, {
+      fields: [shopListings.itemId],
+      references: [items.id]
+    }),
+    currency: one(currencies, {
+      fields: [shopListings.currencyId],
+      references: [currencies.id]
+    })
+  }));
+  inventoryItemsRelations = relations2(inventoryItems, ({ one }) => ({
+    item: one(items, {
+      fields: [inventoryItems.itemId],
+      references: [items.id]
+    }),
+    user: one(users, {
+      fields: [inventoryItems.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/domains/level/table.ts
+import { relations as relations3 } from "drizzle-orm";
+import { integer as integer2, pgTable as pgTable6, text as text6, timestamp as timestamp5, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
+var userLevels, levelConfigs, userLevelsRelations;
+var init_table6 = __esm(() => {
+  init_table();
+  userLevels = pgTable6("user_levels", {
+    userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
+    currentLevel: integer2("current_level").notNull().default(1),
+    currentXp: integer2("current_xp").notNull().default(0),
+    totalXP: integer2("total_xp").notNull().default(0),
+    lastLevelUpAt: timestamp5("last_level_up_at", { withTimezone: true }),
+    createdAt: timestamp5("created_at").defaultNow().notNull(),
+    updatedAt: timestamp5("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  });
+  levelConfigs = pgTable6("level_configs", {
+    id: uuid5("id").primaryKey().defaultRandom(),
+    level: integer2("level").notNull().unique(),
+    xpRequired: integer2("xp_required").notNull(),
+    creditsReward: integer2("credits_reward").notNull().default(0),
+    createdAt: timestamp5("created_at").defaultNow().notNull()
+  }, (table) => [uniqueIndex5("unique_level_config_idx").on(table.level)]);
+  userLevelsRelations = relations3(userLevels, ({ one }) => ({
+    user: one(users, {
+      fields: [userLevels.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/tables.index.ts
+var init_tables_index = __esm(() => {
+  init_table();
+  init_table2();
+  init_table4();
+  init_table5();
+  init_table3();
+  init_table6();
+});
+
 // ../data/src/constants.ts
-var ITEM_INTERNAL_NAMES, CURRENCIES, BADGES;
+var ITEM_SLUGS, CURRENCIES, BADGES, INTERACTION_TYPE;
 var init_constants = __esm(() => {
-  ITEM_INTERNAL_NAMES = {
+  init_tables_index();
+  ITEM_SLUGS = {
     PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
     PLAYCADEMY_XP: "PLAYCADEMY_XP",
     FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
@@ -451,14 +921,15 @@ var init_constants = __esm(() => {
     SMALL_BACKPACK: "SMALL_BACKPACK"
   };
   CURRENCIES = {
-    PRIMARY: ITEM_INTERNAL_NAMES.PLAYCADEMY_CREDITS,
-    XP: ITEM_INTERNAL_NAMES.PLAYCADEMY_XP
+    PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+    XP: ITEM_SLUGS.PLAYCADEMY_XP
   };
   BADGES = {
-    FOUNDING_MEMBER: ITEM_INTERNAL_NAMES.FOUNDING_MEMBER_BADGE,
-    EARLY_ADOPTER: ITEM_INTERNAL_NAMES.EARLY_ADOPTER_BADGE,
-    FIRST_GAME: ITEM_INTERNAL_NAMES.FIRST_GAME_BADGE
+    FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+    EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+    FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
   };
+  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
 });
 
 // src/core/namespaces/credits.ts
@@ -468,9 +939,9 @@ function createCreditsNamespace(client) {
     if (cachedCreditsItemId) {
       return cachedCreditsItemId;
     }
-    const items = await client.admin.items.list();
-    const creditsItem = items.find((item) => item.internalName === CURRENCIES.PRIMARY);
-    if (!creditsItem) {
+    const queryParams = new URLSearchParams({ slug: CURRENCIES.PRIMARY });
+    const creditsItem = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
+    if (!creditsItem || !creditsItem.id) {
       throw new Error("Playcademy Credits item not found in catalog");
     }
     cachedCreditsItemId = creditsItem.id;
@@ -479,8 +950,8 @@ function createCreditsNamespace(client) {
   return {
     balance: async () => {
       const inventory = await client.users.inventory.get();
-      const creditsItem = inventory.find((item) => item.item?.internalName === CURRENCIES.PRIMARY);
-      return creditsItem?.quantity ?? 0;
+      const primaryCurrencyInventoryItem = inventory.find((item) => item.item?.slug === CURRENCIES.PRIMARY);
+      return primaryCurrencyInventoryItem?.quantity ?? 0;
     },
     add: async (amount) => {
       if (amount <= 0) {
@@ -606,13 +1077,14 @@ async function login(baseUrl, email, password) {
       const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
       throw new PlaycademyError(errorMessage);
     } catch (error) {
-      console.error("[SDK] Failed to parse error response JSON, using status text instead:", error);
+      log.error("[Playcademy SDK] Failed to parse error response JSON, using status text instead:", { error });
       throw new PlaycademyError(response.statusText);
     }
   }
   return response.json();
 }
 var init_login = __esm(() => {
+  init_src();
   init_errors();
 });
 
@@ -629,9 +1101,10 @@ __export(exports_client, {
 });
 var PlaycademyClient;
 var init_client = __esm(() => {
+  init_src();
   init_errors();
-  init_request();
   init_namespaces();
+  init_request();
   init_static();
   PlaycademyClient = class PlaycademyClient {
     baseUrl;
@@ -651,14 +1124,16 @@ var init_client = __esm(() => {
       }
       if (this.gameId) {
         this._initializeInternalSession().catch((error) => {
-          console.error("[SDK] Background initialization of auto-session failed:", error);
+          log.error("[Playcademy SDK] Background initialization of auto-session failed:", {
+            error
+          });
         });
       }
     }
     getBaseUrl() {
       const isRelative = this.baseUrl.startsWith("/");
-      const isBrowser = typeof window !== "undefined";
-      return isRelative && isBrowser ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+      const isBrowser2 = typeof window !== "undefined";
+      return isRelative && isBrowser2 ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
     }
     ping() {
       return "pong";
@@ -704,7 +1179,10 @@ var init_client = __esm(() => {
         const response = await this.games.startSession(this.gameId);
         this.internalClientSessionId = response.sessionId;
       } catch (error) {
-        console.error("[SDK] Auto-starting session failed for game", this.gameId, error);
+        log.error("[Playcademy SDK] Auto-starting session failed for game", {
+          gameId: this.gameId,
+          error
+        });
       }
     }
     auth = createAuthNamespace(this);