@playcademy/sdk 0.0.8 → 0.1.0

package/dist/index.js

@@ -11,10 +11,19 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // ../logger/src/index.ts
-var isBrowser = () => {
+var hasProcess = () => {
+  return typeof process !== "undefined";
+}, isBrowser = () => {
   const g = globalThis;
   return typeof g.window !== "undefined" && typeof g.document !== "undefined";
-}, colors, getLevelColor = (level) => {
+}, 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) => {
   switch (level) {
     case "debug":
       return colors.blue;
@@ -38,7 +47,7 @@ var isBrowser = () => {
   }
 }, logOnServer = (level, message, context) => {
   const consoleMethod = getConsoleMethod(level);
-  if (true) {
+  if (shouldUseColor()) {
     const timestamp = new Date().toISOString();
     const levelColor = getLevelColor(level);
     const levelUpper = level.toUpperCase().padEnd(5);
@@ -48,7 +57,10 @@ var isBrowser = () => {
     } else {
       consoleMethod(`${coloredPrefix} ${message}`);
     }
-  } else {}
+  } else {
+    const formatted = formatLog(level, message, context);
+    consoleMethod(formatted);
+  }
 }, getConsoleMethod = (level) => {
   switch (level) {
     case "debug":
@@ -62,8 +74,22 @@ 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 (level === "debug" && hasProcess() && process.env.PLAYCADEMY_EMBEDDED) {
+    return;
+  }
   if (isBrowser()) {
     logInBrowser(level, message, context);
   } else {
@@ -91,6 +117,85 @@ var init_src = __esm(() => {
   log = createLogger();
 });
 
+// src/core/auth/strategies.ts
+class ApiKeyAuth {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getToken() {
+    return this.apiKey;
+  }
+  getType() {
+    return "apiKey";
+  }
+  getHeaders() {
+    return { "x-api-key": this.apiKey };
+  }
+}
+
+class SessionAuth {
+  sessionToken;
+  constructor(sessionToken) {
+    this.sessionToken = sessionToken;
+  }
+  getToken() {
+    return this.sessionToken;
+  }
+  getType() {
+    return "session";
+  }
+  getHeaders() {
+    return { Authorization: `Bearer ${this.sessionToken}` };
+  }
+}
+
+class GameJwtAuth {
+  gameToken;
+  constructor(gameToken) {
+    this.gameToken = gameToken;
+  }
+  getToken() {
+    return this.gameToken;
+  }
+  getType() {
+    return "gameJwt";
+  }
+  getHeaders() {
+    return { Authorization: `Bearer ${this.gameToken}` };
+  }
+}
+
+class NoAuth {
+  getToken() {
+    return null;
+  }
+  getType() {
+    return "session";
+  }
+  getHeaders() {
+    return {};
+  }
+}
+function createAuthStrategy(token, tokenType) {
+  if (!token) {
+    return new NoAuth;
+  }
+  if (tokenType === "apiKey") {
+    return new ApiKeyAuth(token);
+  }
+  if (tokenType === "session") {
+    return new SessionAuth(token);
+  }
+  if (tokenType === "gameJwt") {
+    return new GameJwtAuth(token);
+  }
+  if (token.startsWith("cademy")) {
+    return new ApiKeyAuth(token);
+  }
+  return new GameJwtAuth(token);
+}
+
 // src/core/auth/utils.ts
 function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
   const left = window.screenX + (window.outerWidth - width) / 2;
@@ -146,9 +251,14 @@ function createAuthNamespace(client) {
   return {
     login: async (credentials) => {
       try {
-        const response = await client["request"]("/auth/login", "POST", credentials);
-        client.setToken(response.token);
-        return { success: true, token: response.token };
+        const response = await client["request"]("/auth/sign-in/email", "POST", credentials);
+        client.setToken(response.token, "session");
+        return {
+          success: true,
+          token: response.token,
+          user: response.user,
+          expiresAt: response.expiresAt
+        };
       } catch (error) {
         return {
           success: false,
@@ -157,8 +267,29 @@ function createAuthNamespace(client) {
       }
     },
     logout: async () => {
-      await client["request"]("/auth/logout", "POST");
+      try {
+        await client["request"]("/auth/sign-out", "POST");
+      } catch {}
       client.setToken(null);
+    },
+    apiKeys: {
+      create: async (options) => {
+        return client["request"]("/dev/api-keys", "POST", {
+          name: options?.name || `SDK Key - ${new Date().toISOString()}`,
+          expiresIn: options?.expiresIn !== undefined ? options.expiresIn : null,
+          permissions: options?.permissions || {
+            games: ["read", "write", "delete"],
+            users: ["read:self", "write:self"],
+            dev: ["read", "write"]
+          }
+        });
+      },
+      list: async () => {
+        return client["request"]("/auth/api-key/list", "GET");
+      },
+      revoke: async (keyId) => {
+        await client["request"]("/auth/api-key/revoke", "POST", { id: keyId });
+      }
     }
   };
 }
@@ -733,10 +864,25 @@ 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,
-  token,
   method = "GET",
   body,
   extraHeaders = {}
@@ -750,8 +896,6 @@ async function request({
     payload = JSON.stringify(body);
     headers["Content-Type"] = "application/json";
   }
-  if (token)
-    headers["Authorization"] = `Bearer ${token}`;
   const res = await fetch(url, {
     method,
     headers,
@@ -770,7 +914,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;
@@ -819,7 +965,7 @@ function createGamesNamespace(client) {
       const promise = client["request"](`/games/${gameIdOrSlug}`, "GET");
       return gameFetchCache.get(gameIdOrSlug, async () => {
         const baseGameData = await promise;
-        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null) {
+        if (baseGameData.gameType === "hosted" && baseGameData.assetBundleBase !== null && baseGameData.assetBundleBase !== "") {
           const manifestData = await fetchManifest(baseGameData.assetBundleBase);
           return { ...baseGameData, manifest: manifestData };
         }
@@ -1009,153 +1155,155 @@ function createDevNamespace(client) {
       }
     },
     games: {
-      upsert: async (slug, metadata, file, hooks) => {
-        hooks?.onEvent?.({ type: "init" });
-        const game = await client["request"](`/games/${slug}`, "PUT", metadata);
-        if (metadata.gameType === "external" || file === null) {
-          return game;
-        }
-        const fileName = file instanceof File ? file.name : "game.zip";
-        const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
-          fileName,
-          gameId: game.id
-        });
-        if (hooks?.onEvent) {
-          await new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest;
-            xhr.open("PUT", initiateResponse.presignedUrl, true);
-            const contentType = file.type || "application/octet-stream";
-            try {
-              xhr.setRequestHeader("Content-Type", contentType);
-            } catch {}
-            xhr.upload.onprogress = (event) => {
-              if (event.lengthComputable) {
-                const percent = event.loaded / event.total;
-                hooks.onEvent?.({
-                  type: "s3Progress",
-                  loaded: event.loaded,
-                  total: event.total,
-                  percent
-                });
-              }
-            };
-            xhr.onload = () => {
-              if (xhr.status >= 200 && xhr.status < 300)
-                resolve();
-              else
-                reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
-            };
-            xhr.onerror = () => reject(new Error("File upload failed: network error"));
-            xhr.send(file);
+      deploy: {
+        frontend: async (slug, metadata, file, hooks) => {
+          hooks?.onEvent?.({ type: "init" });
+          const game = await client["request"](`/games/${slug}`, "PUT", metadata);
+          if (metadata.gameType === "external" || file === null) {
+            return game;
+          }
+          const fileName = file instanceof File ? file.name : "game.zip";
+          const initiateResponse = await client["request"]("/games/uploads/initiate/", "POST", {
+            fileName,
+            gameId: game.id
           });
-        } else {
-          const uploadResponse = await fetch(initiateResponse.presignedUrl, {
-            method: "PUT",
-            body: file,
-            headers: {
-              "Content-Type": file.type || "application/octet-stream"
+          if (hooks?.onEvent && typeof XMLHttpRequest !== "undefined") {
+            await new Promise((resolve, reject) => {
+              const xhr = new XMLHttpRequest;
+              xhr.open("PUT", initiateResponse.presignedUrl, true);
+              const contentType = file.type || "application/octet-stream";
+              try {
+                xhr.setRequestHeader("Content-Type", contentType);
+              } catch {}
+              xhr.upload.onprogress = (event) => {
+                if (event.lengthComputable) {
+                  const percent = event.loaded / event.total;
+                  hooks.onEvent?.({
+                    type: "s3Progress",
+                    loaded: event.loaded,
+                    total: event.total,
+                    percent
+                  });
+                }
+              };
+              xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300)
+                  resolve();
+                else
+                  reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
+              };
+              xhr.onerror = () => reject(new Error("File upload failed: network error"));
+              xhr.send(file);
+            });
+          } else {
+            const uploadResponse = await fetch(initiateResponse.presignedUrl, {
+              method: "PUT",
+              body: file,
+              headers: {
+                "Content-Type": file.type || "application/octet-stream"
+              }
+            });
+            if (!uploadResponse.ok) {
+              throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
             }
+          }
+          const finalizeUrl = `${client.baseUrl}/games/uploads/finalize/`;
+          const authToken = client.getToken();
+          const tokenType = client.getTokenType();
+          const headers = {
+            "Content-Type": "application/json"
+          };
+          if (authToken) {
+            if (tokenType === "apiKey") {
+              headers["x-api-key"] = authToken;
+            } else {
+              headers["Authorization"] = `Bearer ${authToken}`;
+            }
+          }
+          const finalizeResponse = await fetch(finalizeUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              tempS3Key: initiateResponse.tempS3Key,
+              gameId: initiateResponse.gameId,
+              version: initiateResponse.version,
+              slug,
+              metadata,
+              originalFileName: fileName
+            }),
+            credentials: "omit"
           });
-          if (!uploadResponse.ok) {
-            throw new Error(`File upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+          if (!finalizeResponse.ok) {
+            const errText = await finalizeResponse.text().catch(() => "");
+            throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
           }
-        }
-        const baseUrl = (() => {
-          const anyClient = client;
-          try {
-            return typeof anyClient.getBaseUrl === "function" ? anyClient.getBaseUrl() : "/api";
-          } catch {
-            return "/api";
+          if (!finalizeResponse.body) {
+            throw new Error("Finalize response body missing");
           }
-        })();
-        const finalizeUrl = baseUrl.replace(/\/$/, "") + "/games/uploads/finalize/";
-        const authToken = client.token;
-        const finalizeResponse = await fetch(finalizeUrl, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
-          },
-          body: JSON.stringify({
-            tempS3Key: initiateResponse.tempS3Key,
-            gameId: initiateResponse.gameId,
-            version: initiateResponse.version,
-            slug,
-            metadata,
-            originalFileName: fileName
-          }),
-          credentials: "omit"
-        });
-        if (!finalizeResponse.ok) {
-          const errText = await finalizeResponse.text().catch(() => "");
-          throw new Error(`Finalize request failed: ${finalizeResponse.status} ${finalizeResponse.statusText}${errText ? ` - ${errText}` : ""}`);
-        }
-        if (!finalizeResponse.body) {
-          throw new Error("Finalize response body missing");
-        }
-        hooks?.onEvent?.({ type: "finalizeStart" });
-        let sawAnyServerEvent = false;
-        const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            if (!sawAnyServerEvent) {
-              hooks?.onClose?.();
-              hooks?.onEvent?.({ type: "close" });
+          hooks?.onEvent?.({ type: "finalizeStart" });
+          let sawAnyServerEvent = false;
+          const reader = finalizeResponse.body.pipeThrough(new TextDecoderStream).getReader();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (!sawAnyServerEvent) {
+                hooks?.onClose?.();
+                hooks?.onEvent?.({ type: "close" });
+              }
+              break;
             }
-            break;
-          }
-          buffer += value;
-          let eolIndex;
-          while ((eolIndex = buffer.indexOf(`
+            buffer += value;
+            let eolIndex;
+            while ((eolIndex = buffer.indexOf(`
 
 `)) >= 0) {
-            const message = buffer.slice(0, eolIndex);
-            buffer = buffer.slice(eolIndex + 2);
-            const eventLine = message.match(/^event: (.*)$/m);
-            const dataLine = message.match(/^data: (.*)$/m);
-            if (eventLine && dataLine) {
-              const eventType = eventLine[1];
-              const eventData = JSON.parse(dataLine[1]);
-              if (eventType === "uploadProgress") {
-                sawAnyServerEvent = true;
-                const percent = (eventData.value ?? 0) / 100;
-                hooks?.onEvent?.({
-                  type: "finalizeProgress",
-                  percent,
-                  currentFileLabel: eventData.currentFileLabel || ""
-                });
-              } else if (eventType === "status") {
-                sawAnyServerEvent = true;
-                if (eventData.message) {
+              const message = buffer.slice(0, eolIndex);
+              buffer = buffer.slice(eolIndex + 2);
+              const eventLine = message.match(/^event: (.*)$/m);
+              const dataLine = message.match(/^data: (.*)$/m);
+              if (eventLine && dataLine) {
+                const eventType = eventLine[1];
+                const eventData = JSON.parse(dataLine[1]);
+                if (eventType === "uploadProgress") {
+                  sawAnyServerEvent = true;
+                  const percent = (eventData.value ?? 0) / 100;
                   hooks?.onEvent?.({
-                    type: "finalizeStatus",
-                    message: eventData.message
+                    type: "finalizeProgress",
+                    percent,
+                    currentFileLabel: eventData.currentFileLabel || ""
                   });
+                } else if (eventType === "status") {
+                  sawAnyServerEvent = true;
+                  if (eventData.message) {
+                    hooks?.onEvent?.({
+                      type: "finalizeStatus",
+                      message: eventData.message
+                    });
+                  }
+                } else if (eventType === "complete") {
+                  sawAnyServerEvent = true;
+                  reader.cancel();
+                  return eventData;
+                } else if (eventType === "error") {
+                  sawAnyServerEvent = true;
+                  reader.cancel();
+                  throw new Error(eventData.message);
                 }
-              } else if (eventType === "complete") {
-                sawAnyServerEvent = true;
-                reader.cancel();
-                return eventData;
-              } else if (eventType === "error") {
-                sawAnyServerEvent = true;
-                reader.cancel();
-                throw new Error(eventData.message);
               }
             }
           }
+          throw new Error("Upload completed but no final game data received");
+        },
+        backend: async (slug, bundle) => {
+          return client["request"](`/games/${slug}/backend/deploy`, "POST", bundle);
         }
-        throw new Error("Upload completed but no final game data received");
       },
-      update: (gameId, props) => client["request"](`/games/${gameId}`, "PATCH", props),
+      upsert: async (slug, metadata) => {
+        return client.dev.games.deploy.frontend(slug, metadata, null);
+      },
       delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE")
     },
-    keys: {
-      create: (label) => client["request"](`/dev/keys`, "POST", { label }),
-      list: () => client["request"](`/dev/keys`, "GET"),
-      revoke: (keyId) => client["request"](`/dev/keys/${keyId}`, "DELETE")
-    },
     items: {
       create: (gameId, slug, itemData) => client["request"](`/games/${gameId}/items`, "POST", {
         slug,
@@ -1191,9 +1339,17 @@ function createDevNamespace(client) {
 
 // src/core/namespaces/maps.ts
 function createMapsNamespace(client) {
+  const mapDataCache = createTTLCache({
+    ttl: 5 * 60 * 1000,
+    keyPrefix: "maps.data"
+  });
+  const mapElementsCache = createTTLCache({
+    ttl: 60 * 1000,
+    keyPrefix: "maps.elements"
+  });
   return {
-    get: (identifier) => client["request"](`/maps/${identifier}`, "GET"),
-    elements: (mapId) => client["request"](`/map/elements?mapId=${mapId}`, "GET"),
+    get: (identifier, options) => mapDataCache.get(identifier, () => client["request"](`/maps/${identifier}`, "GET"), options),
+    elements: (mapId, options) => mapElementsCache.get(mapId, () => client["request"](`/map/elements?mapId=${mapId}`, "GET"), options),
     objects: {
       list: (mapId) => client["request"](`/maps/${mapId}/objects`, "GET"),
       create: (mapId, objectData) => client["request"](`/maps/${mapId}/objects`, "POST", objectData),
@@ -1201,6 +1357,7 @@ function createMapsNamespace(client) {
     }
   };
 }
+var init_maps = () => {};
 
 // src/core/namespaces/admin.ts
 function createAdminNamespace(client) {
@@ -1320,6 +1477,7 @@ var init_levels = () => {};
 
 // ../data/src/domains/game/table.ts
 import {
+  boolean,
   jsonb,
   pgEnum,
   pgTable,
@@ -1329,7 +1487,7 @@ import {
   uuid,
   varchar
 } from "drizzle-orm/pg-core";
-var gamePlatformEnum, gameBootModeEnum, gameTypeEnum, games, gameSessions, gameStates;
+var gamePlatformEnum, gameBootModeEnum, gameTypeEnum, games, gameSessions, gameStates, deploymentProviderEnum, gameBackendDeployments;
 var init_table = __esm(() => {
   init_table3();
   init_table4();
@@ -1368,12 +1526,23 @@ var init_table = __esm(() => {
     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,
+  boolean as boolean2,
   integer,
   jsonb as jsonb2,
   pgEnum as pgEnum2,
@@ -1408,7 +1577,7 @@ var init_table2 = __esm(() => {
     displayName: text2("display_name").notNull(),
     description: text2("description"),
     type: itemTypeEnum("type").notNull().default("other"),
-    isPlaceable: boolean("is_placeable").default(false).notNull(),
+    isPlaceable: boolean2("is_placeable").default(false).notNull(),
     imageUrl: text2("image_url"),
     metadata: jsonb2("metadata").default({}),
     createdAt: timestamp2("created_at").defaultNow().notNull()
@@ -1427,7 +1596,7 @@ var init_table2 = __esm(() => {
     id: uuid2("id").primaryKey().defaultRandom(),
     itemId: uuid2("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
     symbol: text2("symbol"),
-    isPrimary: boolean("is_primary").default(false).notNull(),
+    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)]);
@@ -1438,7 +1607,7 @@ var init_table2 = __esm(() => {
     price: integer("price").notNull(),
     sellBackPercentage: integer("sell_back_percentage"),
     stock: integer("stock"),
-    isActive: boolean("is_active").default(true).notNull(),
+    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(),
@@ -1572,7 +1741,7 @@ var init_table3 = __esm(() => {
 
 // ../data/src/domains/user/table.ts
 import { relations as relations3 } from "drizzle-orm";
-import { boolean as boolean2, pgEnum as pgEnum4, pgTable as pgTable4, text as text4, timestamp as timestamp4, uniqueIndex as uniqueIndex4 } from "drizzle-orm/pg-core";
+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();
@@ -1584,11 +1753,11 @@ var init_table4 = __esm(() => {
     username: text4("username").unique(),
     email: text4("email").notNull().unique(),
     timebackId: text4("timeback_id").unique(),
-    emailVerified: boolean2("email_verified").notNull().default(false),
+    emailVerified: boolean3("email_verified").notNull().default(false),
     image: text4("image"),
     role: userRoleEnum("role").notNull().default("player"),
     developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
-    characterCreated: boolean2("character_created").notNull().default(false),
+    characterCreated: boolean3("character_created").notNull().default(false),
     createdAt: timestamp4("created_at", {
       mode: "date",
       withTimezone: true
@@ -1677,16 +1846,32 @@ var init_table4 = __esm(() => {
 });
 
 // ../data/src/domains/developer/table.ts
-import { pgTable as pgTable5, text as text5, timestamp as timestamp5, uuid as uuid4, varchar as varchar3 } from "drizzle-orm/pg-core";
-var developerKeys;
+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();
-  developerKeys = pgTable5("developer_keys", {
+  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" }),
-    label: varchar3("label", { length: 255 }),
-    keyHash: text5("key_hash").notNull().unique(),
-    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow()
+    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")
   });
 });
 
@@ -1694,7 +1879,7 @@ var init_table5 = __esm(() => {
 import { relations as relations4 } from "drizzle-orm";
 import {
   doublePrecision as doublePrecision2,
-  integer as integer3,
+  integer as integer4,
   pgTable as pgTable6,
   text as text6,
   timestamp as timestamp6,
@@ -1706,7 +1891,7 @@ var init_table6 = __esm(() => {
   init_table4();
   userLevels = pgTable6("user_levels", {
     userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
-    currentLevel: integer3("current_level").notNull().default(1),
+    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 }),
@@ -1715,9 +1900,9 @@ var init_table6 = __esm(() => {
   });
   levelConfigs = pgTable6("level_configs", {
     id: uuid5("id").primaryKey().defaultRandom(),
-    level: integer3("level").notNull().unique(),
-    xpRequired: integer3("xp_required").notNull(),
-    creditsReward: integer3("credits_reward").notNull().default(0),
+    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 }) => ({
@@ -1730,7 +1915,7 @@ var init_table6 = __esm(() => {
 
 // ../data/src/domains/leaderboard/table.ts
 import { relations as relations5 } from "drizzle-orm";
-import { index as index2, integer as integer4, jsonb as jsonb4, pgTable as pgTable7, text as text7, timestamp as timestamp7, uuid as uuid6 } from "drizzle-orm/pg-core";
+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();
@@ -1739,7 +1924,7 @@ var init_table7 = __esm(() => {
     id: uuid6("id").primaryKey().defaultRandom(),
     userId: text7("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
     gameId: uuid6("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    score: integer4("score").notNull(),
+    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" })
@@ -1766,22 +1951,22 @@ var init_table7 = __esm(() => {
 
 // ../data/src/domains/sprite/table.ts
 import { relations as relations6 } from "drizzle-orm";
-import { integer as integer5, pgTable as pgTable8, timestamp as timestamp8, uuid as uuid7, varchar as varchar4 } from "drizzle-orm/pg-core";
+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: varchar4("slug", { length: 64 }).notNull().unique(),
-    url: varchar4("url", { length: 255 }).notNull(),
+    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: integer5("width").notNull(),
-    height: integer5("height").notNull(),
-    url: varchar4("url", { length: 255 }).notNull(),
+    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()
   });
@@ -1799,14 +1984,14 @@ var init_table8 = __esm(() => {
 // ../data/src/domains/character/table.ts
 import { relations as relations7 } from "drizzle-orm";
 import {
-  integer as integer6,
+  integer as integer7,
   pgEnum as pgEnum5,
   pgTable as pgTable9,
   text as text8,
   timestamp as timestamp9,
   uniqueIndex as uniqueIndex6,
   uuid as uuid8,
-  varchar as varchar5
+  varchar as varchar4
 } from "drizzle-orm/pg-core";
 var characterComponentTypeEnum, characterComponents, playerCharacters, playerCharacterAccessories, characterComponentsRelations, playerCharactersRelations, playerCharacterAccessoriesRelations;
 var init_table9 = __esm(() => {
@@ -1822,12 +2007,12 @@ var init_table9 = __esm(() => {
   characterComponents = pgTable9("character_components", {
     id: uuid8("id").primaryKey().defaultRandom(),
     componentType: characterComponentTypeEnum("component_type").notNull(),
-    slug: varchar5("slug", { length: 128 }).notNull().unique(),
-    displayName: varchar5("display_name", { length: 128 }).notNull(),
-    slot: varchar5("slot", { length: 64 }).notNull(),
+    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: integer6("unlock_level").notNull().default(0),
-    variant: integer6("variant").notNull().default(0),
+    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()
   });
@@ -1845,7 +2030,7 @@ var init_table9 = __esm(() => {
     id: uuid8("id").primaryKey().defaultRandom(),
     playerCharacterId: uuid8("player_character_id").notNull().references(() => playerCharacters.id, { onDelete: "cascade" }),
     accessoryComponentId: uuid8("accessory_component_id").notNull().references(() => characterComponents.id, { onDelete: "cascade" }),
-    slot: varchar5("slot", { length: 64 }).notNull(),
+    slot: varchar4("slot", { length: 64 }).notNull(),
     equippedAt: timestamp9("equipped_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp9("updated_at", { withTimezone: true }).notNull().defaultNow()
   }, (table) => [
@@ -1895,8 +2080,9 @@ var init_table9 = __esm(() => {
 
 // ../data/src/domains/timeback/table.ts
 import { doublePrecision as doublePrecision3, pgTable as pgTable10, text as text9, timestamp as timestamp10, uniqueIndex as uniqueIndex7, uuid as uuid9 } from "drizzle-orm/pg-core";
-var timebackDailyXp, timebackXpEvents;
+var 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" }),
@@ -1917,14 +2103,22 @@ var init_table10 = __esm(() => {
     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 boolean3,
+  boolean as boolean5,
   index as index3,
-  integer as integer7,
+  integer as integer8,
   jsonb as jsonb5,
   pgEnum as pgEnum6,
   pgTable as pgTable11,
@@ -1932,45 +2126,55 @@ import {
   timestamp as timestamp11,
   uniqueIndex as uniqueIndex8,
   uuid as uuid10,
-  varchar as varchar6
+  varchar as varchar5
 } from "drizzle-orm/pg-core";
-var achievementIntervalEnum, achievements, userAchievementProgress, userAchievementClaims, userAchievementProgressRelations, userAchievementClaimsRelations;
+var achievementScopeEnum, achievements, userAchievementProgress, userAchievementClaims, userAchievementProgressRelations, userAchievementClaimsRelations;
 var init_table11 = __esm(() => {
   init_table4();
-  achievementIntervalEnum = pgEnum6("achievement_interval", ["daily", "weekly"]);
+  achievementScopeEnum = pgEnum6("achievement_scope", [
+    "daily",
+    "weekly",
+    "monthly",
+    "yearly",
+    "game",
+    "global",
+    "map",
+    "level",
+    "event"
+  ]);
   achievements = pgTable11("achievements", {
-    id: varchar6("id", { length: 255 }).primaryKey(),
-    title: varchar6("title", { length: 255 }).notNull(),
+    id: varchar5("id", { length: 255 }).primaryKey(),
+    title: varchar5("title", { length: 255 }).notNull(),
     description: text10("description"),
-    intervalType: achievementIntervalEnum("interval_type").notNull(),
-    rewardCredits: integer7("reward_credits").notNull().default(0),
-    limitPerInterval: integer7("limit_per_interval").notNull().default(1),
-    completionType: varchar6("completion_type", { length: 50 }).notNull(),
+    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({}),
-    scope: jsonb5("scope").notNull().default({}),
-    active: boolean3("active").notNull().default(true),
+    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: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    intervalKey: text10("interval_key").notNull(),
+    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.intervalKey)
+    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: varchar6("achievement_id", { length: 255 }).notNull().references(() => achievements.id, { onDelete: "cascade" }),
-    intervalKey: text10("interval_key").notNull(),
-    rewardCredits: integer7("reward_credits").notNull(),
+    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.intervalKey)
+    uniqueIndex8("user_achievement_claims_unique").on(table.userId, table.achievementId, table.scopeKey)
   ]);
   userAchievementProgressRelations = relations8(userAchievementProgress, ({ one }) => ({
     user: one(users, {
@@ -1994,6 +2198,58 @@ var init_table11 = __esm(() => {
   }));
 });
 
+// ../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();
@@ -2007,10 +2263,11 @@ var init_tables_index = __esm(() => {
   init_table9();
   init_table10();
   init_table11();
+  init_table12();
 });
 
 // ../data/src/constants.ts
-var ITEM_SLUGS, CURRENCIES, BADGES, ACHIEVEMENT_COMPLETION_TYPES, ACHIEVEMENT_COMPLETION_TYPE, INTERACTION_TYPE;
+var ITEM_SLUGS, CURRENCIES, BADGES, INTERACTION_TYPE;
 var init_constants = __esm(() => {
   init_tables_index();
   ITEM_SLUGS = {
@@ -2035,12 +2292,6 @@ var init_constants = __esm(() => {
     EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
     FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
   };
-  ACHIEVEMENT_COMPLETION_TYPES = [
-    "time_played_session",
-    "interaction",
-    "leaderboard_rank"
-  ];
-  ACHIEVEMENT_COMPLETION_TYPE = Object.fromEntries(ACHIEVEMENT_COMPLETION_TYPES.map((value) => [value, value]));
   INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
 });
 
@@ -2514,9 +2765,60 @@ 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 {
+    recordProgress: (progressData) => {
+      return client["requestGameBackend"](TIMEBACK_ROUTES.PROGRESS, "POST", { progressData });
+    },
+    recordSessionEnd: (sessionData) => {
+      return client["requestGameBackend"](TIMEBACK_ROUTES.SESSION_END, "POST", { sessionData });
+    },
+    awardXP: (xpAmount, metadata) => {
+      return client["requestGameBackend"](TIMEBACK_ROUTES.AWARD_XP, "POST", {
+        xpAmount,
+        metadata
+      });
+    },
+    management: {
+      setup: (request2) => {
+        return client["request"]("/timeback/setup", "POST", request2);
+      },
+      verify: (gameId) => {
+        return client["request"](`/timeback/verify/${gameId}`, "GET");
+      },
+      cleanup: (gameId) => {
+        return client["request"](`/timeback/integrations/${gameId}`, "DELETE");
+      },
+      get: (gameId) => {
+        return client["request"](`/timeback/integrations/${gameId}`, "GET");
+      },
+      getConfig: (gameId) => {
+        return client["request"](`/timeback/config/${gameId}`, "GET");
+      }
+    },
     xp: {
       today: async (options) => {
         const params = new URLSearchParams;
@@ -2559,6 +2861,104 @@ function createTimebackNamespace(client) {
     }
   };
 }
+var init_timeback = __esm(() => {
+  init_constants2();
+});
+
+// src/core/namespaces/notifications.ts
+function createNotificationsNamespace(client) {
+  const notificationsListCache = createTTLCache({
+    ttl: 5 * 1000,
+    keyPrefix: "notifications.list"
+  });
+  const notificationStatsCache = createTTLCache({
+    ttl: 30 * 1000,
+    keyPrefix: "notifications.stats"
+  });
+  return {
+    list: async (queryOptions, cacheOptions) => {
+      const params = new URLSearchParams;
+      if (queryOptions?.status)
+        params.append("status", queryOptions.status);
+      if (queryOptions?.type)
+        params.append("type", queryOptions.type);
+      if (queryOptions?.limit)
+        params.append("limit", String(queryOptions.limit));
+      if (queryOptions?.offset)
+        params.append("offset", String(queryOptions.offset));
+      const qs = params.toString();
+      const path = qs ? `/notifications?${qs}` : "/notifications";
+      const cacheKey = qs ? `list-${qs}` : "list";
+      return notificationsListCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+    },
+    markAsSeen: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        id: notificationId,
+        status: "seen"
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    markAsClicked: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        id: notificationId,
+        status: "clicked"
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    dismiss: async (notificationId) => {
+      const result = await client["request"](`/notifications/${notificationId}/status`, "PATCH", {
+        id: notificationId,
+        status: "dismissed"
+      });
+      notificationsListCache.clear();
+      return result;
+    },
+    stats: {
+      get: async (queryOptions, cacheOptions) => {
+        const user = await client.users.me();
+        const params = new URLSearchParams;
+        if (queryOptions?.from)
+          params.append("from", queryOptions.from);
+        if (queryOptions?.to)
+          params.append("to", queryOptions.to);
+        const qs = params.toString();
+        const path = qs ? `/notifications/stats/${user.id}?${qs}` : `/notifications/stats/${user.id}`;
+        const cacheKey = qs ? `stats-${qs}` : "stats";
+        return notificationStatsCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
+      }
+    }
+  };
+}
+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(() => {
@@ -2566,12 +2966,15 @@ var init_namespaces = __esm(() => {
   init_runtime();
   init_games();
   init_users();
+  init_maps();
   init_levels();
   init_credits();
   init_character();
   init_sprites();
   init_realtime();
   init_achievements();
+  init_timeback();
+  init_notifications();
 });
 
 // src/core/static/init.ts
@@ -2600,6 +3003,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;
@@ -2643,7 +3049,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
@@ -2662,6 +3069,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
@@ -2739,7 +3147,8 @@ var init_client = __esm(() => {
   init_static();
   PlaycademyClient = class PlaycademyClient {
     baseUrl;
-    token;
+    gameUrl;
+    authStrategy;
     gameId;
     config;
     listeners = {};
@@ -2747,16 +3156,11 @@ var init_client = __esm(() => {
     authContext;
     initPayload;
     constructor(config) {
-      if (!config) {
-        this.baseUrl = "/api";
-        this.token = undefined;
-        this.gameId = undefined;
-      } else {
-        this.baseUrl = config.baseUrl || "/api";
-        this.token = config.token;
-        this.gameId = config.gameId;
-      }
+      this.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);
       this._detectAuthContext();
       this._initializeInternalSession().catch(() => {});
     }
@@ -2765,18 +3169,30 @@ 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";
     }
-    setToken(token) {
-      this.token = token ?? undefined;
-      this.emit("authChange", { token: this.token ?? null });
+    setToken(token, tokenType) {
+      this.authStrategy = createAuthStrategy(token, tokenType);
+      this.emit("authChange", { token });
+    }
+    getTokenType() {
+      return this.authStrategy.getType();
     }
     getToken() {
-      return this.token ?? null;
+      return this.authStrategy.getToken();
     }
     isAuthenticated() {
-      return !!this.token;
+      return this.authStrategy.getToken() !== null;
     }
     onAuthChange(callback) {
       this.on("authChange", (payload) => callback(payload.token));
@@ -2794,13 +3210,28 @@ var init_client = __esm(() => {
       });
     }
     async request(path, method, body, headers) {
-      const effectiveHeaders = { ...headers };
+      const effectiveHeaders = {
+        ...headers,
+        ...this.authStrategy.getHeaders()
+      };
       return request({
         path,
         method,
         body,
         baseUrl: this.baseUrl,
-        token: this.token,
+        extraHeaders: effectiveHeaders
+      });
+    }
+    async requestGameBackend(path, method, body, headers) {
+      const effectiveHeaders = {
+        ...headers,
+        ...this.authStrategy.getHeaders()
+      };
+      return request({
+        path,
+        method,
+        body,
+        baseUrl: this.getGameBackendUrl(),
         extraHeaders: effectiveHeaders
       });
     }
@@ -2852,6 +3283,8 @@ var init_client = __esm(() => {
     sprites = createSpritesNamespace(this);
     realtime = createRealtimeNamespace(this);
     achievements = createAchievementsNamespace(this);
+    notifications = createNotificationsNamespace(this);
+    backend = createBackendNamespace(this);
     static init = init;
     static login = login2;
     static identity = identity;
@@ -2861,20 +3294,7 @@ 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"
-};
+init_constants2();
 export {
   messaging,
   PlaycademyClient,