@playcademy/sdk 0.9.1-beta.1 → 0.9.1-beta.3

package/dist/index.js

@@ -19,13 +19,11 @@ var MessageEvents;
   MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
   MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
   MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
-  MessageEvents2["CONNECTION_STATE"] = "PLAYCADEMY_CONNECTION_STATE";
   MessageEvents2["READY"] = "PLAYCADEMY_READY";
   MessageEvents2["INIT_ERROR"] = "PLAYCADEMY_INIT_ERROR";
   MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
   MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
   MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
-  MessageEvents2["DISPLAY_ALERT"] = "PLAYCADEMY_DISPLAY_ALERT";
   MessageEvents2["DEMO_END"] = "PLAYCADEMY_DEMO_END";
   MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
   MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
@@ -87,7 +85,6 @@ class PlaycademyMessaging {
       "PLAYCADEMY_EXIT" /* EXIT */,
       "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
       "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */,
-      "PLAYCADEMY_DISPLAY_ALERT" /* DISPLAY_ALERT */,
       "PLAYCADEMY_DEMO_END" /* DEMO_END */
     ];
     const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
@@ -194,7 +191,6 @@ function createStandaloneConfig() {
     gameUrl: globalThis.location.origin,
     token: "mock-game-token-for-local-dev",
     gameId: "mock-game-id-from-template",
-    realtimeUrl: undefined,
     mode: "standalone"
   };
   globalThis.PLAYCADEMY = mockConfig;
@@ -213,10 +209,7 @@ async function init(options) {
     gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
-    mode: config.mode,
-    autoStartSession: globalThis.self !== window.top,
-    onDisconnect: options?.onDisconnect,
-    enableConnectionMonitoring: options?.enableConnectionMonitoring
+    mode: config.mode
   });
   client["initPayload"] = config;
   messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
@@ -637,6 +630,80 @@ function getOAuthConfig(provider) {
 var identity = {
   parseOAuthState
 };
+// src/namespaces/game/backend.ts
+function normalizePath(path) {
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function createBackendNamespace(client) {
+  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);
+    },
+    async download(path, method = "GET", body, headers) {
+      return client["requestGameBackend"](normalizePath(path), method, body, headers, { raw: true });
+    },
+    url(pathOrStrings, ...values) {
+      if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
+        const strings = pathOrStrings;
+        const path2 = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
+        return `${client.gameUrl}/api${path2.startsWith("/") ? path2 : `/${path2}`}`;
+      }
+      const path = pathOrStrings;
+      return `${client.gameUrl}/api${path.startsWith("/") ? path : `/${path}`}`;
+    }
+  };
+}
+// src/core/assert.ts
+function assertPlatformMode(client, operation) {
+  if (client.mode !== "platform") {
+    throw new PlaycademyError(`${operation} requires platform mode (current: ${client.mode}). Check client.mode before calling.`);
+  }
+}
+function assertDemoMode(client, operation) {
+  if (client.mode !== "demo") {
+    throw new PlaycademyError(`${operation} requires demo mode (current: ${client.mode}). Check client.mode before calling.`);
+  }
+}
+
+// src/namespaces/game/demo.ts
+function createDemoNamespace(client) {
+  return {
+    profile: {
+      get: async () => {
+        assertDemoMode(client, "demo.profile.get()");
+        return client["request"]("/users/demo-profile", "GET");
+      },
+      update: async (updates) => {
+        assertDemoMode(client, "demo.profile.update()");
+        return client["request"]("/users/demo-profile", "PATCH", {
+          body: updates
+        });
+      }
+    },
+    end: (score, options) => {
+      assertDemoMode(client, "demo.end()");
+      messaging.send("PLAYCADEMY_DEMO_END" /* DEMO_END */, {
+        score,
+        ...options
+      });
+    }
+  };
+}
 // src/core/auth/utils.ts
 function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
   const left = window.screenX + (window.outerWidth - width) / 2;
@@ -941,17 +1008,7 @@ function createRuntimeNamespace(client) {
       }
       return res;
     },
-    exit: async () => {
-      if (client["internalClientSessionId"] && client["gameId"]) {
-        try {
-          await client["_sessionManager"].endSession(client["internalClientSessionId"], client["gameId"]);
-        } catch (error) {
-          log.error("[Playcademy SDK] Failed to auto-end session:", {
-            sessionId: client["internalClientSessionId"],
-            error
-          });
-        }
-      }
+    exit: () => {
       messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
     },
     onInit: (handler) => {
@@ -1051,401 +1108,6 @@ function createAssetsNamespace(client) {
     }
   };
 }
-// src/namespaces/game/backend.ts
-function normalizePath(path) {
-  return path.startsWith("/") ? path : `/${path}`;
-}
-function createBackendNamespace(client) {
-  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);
-    },
-    async download(path, method = "GET", body, headers) {
-      return client["requestGameBackend"](normalizePath(path), method, body, headers, { raw: true });
-    },
-    url(pathOrStrings, ...values) {
-      if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
-        const strings = pathOrStrings;
-        const path2 = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
-        return `${client.gameUrl}/api${path2.startsWith("/") ? path2 : `/${path2}`}`;
-      }
-      const path = pathOrStrings;
-      return `${client.gameUrl}/api${path.startsWith("/") ? path : `/${path}`}`;
-    }
-  };
-}
-// src/namespaces/game/guard.ts
-function assertPlatformMode(client, operation) {
-  if (client.mode !== "platform") {
-    throw new PlaycademyError(`${operation} requires platform mode (current: ${client.mode}). Check client.mode before calling.`);
-  }
-}
-function assertDemoMode(client, operation) {
-  if (client.mode !== "demo") {
-    throw new PlaycademyError(`${operation} requires demo mode (current: ${client.mode}). Check client.mode before calling.`);
-  }
-}
-
-// src/namespaces/game/demo.ts
-function createDemoNamespace(client) {
-  return {
-    profile: {
-      get: async () => {
-        assertDemoMode(client, "demo.profile.get()");
-        return client["request"]("/users/demo-profile", "GET");
-      },
-      update: async (updates) => {
-        assertDemoMode(client, "demo.profile.update()");
-        return client["request"]("/users/demo-profile", "PATCH", {
-          body: updates
-        });
-      }
-    },
-    end: (score, options) => {
-      assertDemoMode(client, "demo.end()");
-      messaging.send("PLAYCADEMY_DEMO_END" /* DEMO_END */, {
-        score,
-        ...options
-      });
-    }
-  };
-}
-// src/core/cache/permanent-cache.ts
-function createPermanentCache(keyPrefix) {
-  const cache = new Map;
-  async function get(key, loader) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const existing = cache.get(fullKey);
-    if (existing) {
-      return existing;
-    }
-    const promise = loader().catch((error) => {
-      cache.delete(fullKey);
-      throw error;
-    });
-    cache.set(fullKey, promise);
-    return promise;
-  }
-  function clear(key) {
-    if (key === undefined) {
-      cache.clear();
-    } else {
-      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-      cache.delete(fullKey);
-    }
-  }
-  function has(key) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    return cache.has(fullKey);
-  }
-  function size() {
-    return cache.size;
-  }
-  function keys() {
-    const result = [];
-    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
-    for (const fullKey of cache.keys()) {
-      result.push(fullKey.substring(prefixLen));
-    }
-    return result;
-  }
-  return { get, clear, has, size, keys };
-}
-
-// src/namespaces/game/users.ts
-function createUsersNamespace(client) {
-  const itemIdCache = createPermanentCache("items");
-  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  async function resolveItemId(identifier) {
-    if (UUID_REGEX.test(identifier)) {
-      return identifier;
-    }
-    const gameId = client["gameId"];
-    const cacheKey = gameId ? `${identifier}:${gameId}` : identifier;
-    return itemIdCache.get(cacheKey, async () => {
-      const queryParams = new URLSearchParams({ slug: identifier });
-      if (gameId) {
-        queryParams.append("gameId", gameId);
-      }
-      const item = await client["request"](`/items/resolve?${queryParams.toString()}`, "GET");
-      return item.id;
-    });
-  }
-  return {
-    me: async () => {
-      assertPlatformMode(client, "users.me()");
-      return client["request"]("/users/me", "GET");
-    },
-    inventory: {
-      get: async () => {
-        assertPlatformMode(client, "users.inventory.get()");
-        return client["request"](`/inventory`, "GET");
-      },
-      add: async (identifier, qty) => {
-        assertPlatformMode(client, "users.inventory.add()");
-        const itemId = await resolveItemId(identifier);
-        const res = await client["request"](`/inventory/add`, "POST", { body: { itemId, qty } });
-        client["emit"]("inventoryChange", {
-          itemId,
-          delta: qty,
-          newTotal: res.newTotal
-        });
-        return res;
-      },
-      remove: async (identifier, qty) => {
-        assertPlatformMode(client, "users.inventory.remove()");
-        const itemId = await resolveItemId(identifier);
-        const res = await client["request"](`/inventory/remove`, "POST", { body: { itemId, qty } });
-        client["emit"]("inventoryChange", {
-          itemId,
-          delta: -qty,
-          newTotal: res.newTotal
-        });
-        return res;
-      },
-      quantity: async (identifier) => {
-        assertPlatformMode(client, "users.inventory.quantity()");
-        const itemId = await resolveItemId(identifier);
-        const inventory = await client["request"](`/inventory`, "GET");
-        const item = inventory.find((inv) => inv.item?.id === itemId);
-        return item?.quantity ?? 0;
-      },
-      has: async (identifier, minQuantity = 1) => {
-        assertPlatformMode(client, "users.inventory.has()");
-        const itemId = await resolveItemId(identifier);
-        const inventory = await client["request"](`/inventory`, "GET");
-        const item = inventory.find((inv) => inv.item?.id === itemId);
-        const qty = item?.quantity ?? 0;
-        return qty >= minQuantity;
-      }
-    }
-  };
-}
-// ../constants/src/achievements.ts
-var ACHIEVEMENT_IDS = {
-  PLAY_ANY_GAME_DAILY: "play_any_game_daily",
-  DAILY_CHEST_OPEN: "daily_chest_open",
-  LEADERBOARD_TOP3_DAILY: "leaderboard_top3_daily",
-  LEADERBOARD_TOP3_WEEKLY: "leaderboard_top3_weekly",
-  FIRST_SCORE_ANY_GAME: "first_score_any_game",
-  PERSONAL_BEST_ANY_GAME: "personal_best_any_game"
-};
-var ACHIEVEMENT_DEFINITIONS = [
-  {
-    id: ACHIEVEMENT_IDS.PLAY_ANY_GAME_DAILY,
-    title: "Play any game",
-    description: "Play any arcade game for at least 60 seconds in a single session.",
-    scope: "daily",
-    rewardCredits: 10,
-    limit: 1,
-    completionType: "time_played_session",
-    completionConfig: { minSeconds: 60 },
-    target: { anyArcadeGame: true },
-    active: true
-  },
-  {
-    id: ACHIEVEMENT_IDS.DAILY_CHEST_OPEN,
-    title: "Opened the daily chest",
-    description: "Find the chest on the map and open it to claim your reward.",
-    scope: "daily",
-    rewardCredits: 10,
-    limit: 1,
-    completionType: "interaction",
-    completionConfig: { triggerId: "bunny_chest" },
-    target: { map: "arcade" },
-    active: true
-  },
-  {
-    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_DAILY,
-    title: "Daily Champion",
-    description: "Finish in the top 3 of any game leaderboard for the day.",
-    scope: "daily",
-    rewardCredits: 25,
-    limit: 1,
-    completionType: "leaderboard_rank",
-    completionConfig: {
-      rankRewards: [50, 30, 15]
-    },
-    target: { anyArcadeGame: true },
-    active: true
-  },
-  {
-    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_WEEKLY,
-    title: "Weekly Legend",
-    description: "Finish in the top 3 of any game leaderboard for the week.",
-    scope: "weekly",
-    rewardCredits: 50,
-    limit: 1,
-    completionType: "leaderboard_rank",
-    completionConfig: {
-      rankRewards: [100, 60, 30]
-    },
-    target: { anyArcadeGame: true },
-    active: true
-  },
-  {
-    id: ACHIEVEMENT_IDS.FIRST_SCORE_ANY_GAME,
-    title: "First Score",
-    description: "Submit your first score in any arcade game.",
-    scope: "game",
-    rewardCredits: 5,
-    limit: 1,
-    completionType: "first_score",
-    completionConfig: {},
-    target: { anyArcadeGame: true },
-    active: true
-  },
-  {
-    id: ACHIEVEMENT_IDS.PERSONAL_BEST_ANY_GAME,
-    title: "Personal Best",
-    description: "Beat your personal best score in any arcade game.",
-    scope: "daily",
-    rewardCredits: 5,
-    limit: 3,
-    completionType: "personal_best",
-    completionConfig: {},
-    target: { anyArcadeGame: true },
-    active: true
-  }
-];
-// ../constants/src/typescript.ts
-var TypeScriptPackages = {
-  tsc: "tsc",
-  nativePreview: "@typescript/native-preview",
-  nativePreviewBeta: "@typescript/native-preview@beta"
-};
-var TYPESCRIPT_RUNNER = {
-  package: TypeScriptPackages.nativePreviewBeta,
-  bin: "tsgo"
-};
-// ../constants/src/overworld.ts
-var ITEM_SLUGS = {
-  PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
-  PLAYCADEMY_XP: "PLAYCADEMY_XP",
-  FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
-  EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
-  FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
-  COMMON_SWORD: "COMMON_SWORD",
-  SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
-  SMALL_BACKPACK: "SMALL_BACKPACK",
-  LAVA_LAMP: "LAVA_LAMP",
-  BOOMBOX: "BOOMBOX",
-  CABIN_BED: "CABIN_BED"
-};
-var CURRENCIES = {
-  PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
-  XP: ITEM_SLUGS.PLAYCADEMY_XP
-};
-var BADGES = {
-  FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
-  EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
-  FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
-};
-// ../constants/src/timeback.ts
-var TIMEBACK_ROUTES = {
-  END_ACTIVITY: "/integrations/timeback/end-activity",
-  GET_XP: "/integrations/timeback/xp",
-  HEARTBEAT: "/integrations/timeback/heartbeat",
-  ADVANCE_COURSE: "/integrations/timeback/advance-course"
-};
-// src/core/cache/singleton-cache.ts
-function createSingletonCache() {
-  let cachedValue;
-  let hasValue = false;
-  async function get(loader) {
-    if (hasValue) {
-      return cachedValue;
-    }
-    const value = await loader();
-    cachedValue = value;
-    hasValue = true;
-    return value;
-  }
-  function clear() {
-    cachedValue = undefined;
-    hasValue = false;
-  }
-  function has() {
-    return hasValue;
-  }
-  return { get, clear, has };
-}
-
-// src/namespaces/game/credits.ts
-function createCreditsNamespace(client) {
-  const creditsIdCache = createSingletonCache();
-  async function getCreditsItemId() {
-    return creditsIdCache.get(async () => {
-      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");
-      }
-      return creditsItem.id;
-    });
-  }
-  return {
-    balance: async () => {
-      assertPlatformMode(client, "credits.balance()");
-      const inventory = await client["request"]("/inventory", "GET");
-      const primaryCurrencyInventoryItem = inventory.find((item) => item.item?.slug === CURRENCIES.PRIMARY);
-      return primaryCurrencyInventoryItem?.quantity ?? 0;
-    },
-    add: async (amount) => {
-      assertPlatformMode(client, "credits.add()");
-      if (amount <= 0) {
-        throw new Error("Amount must be positive");
-      }
-      const creditsItemId = await getCreditsItemId();
-      const result = await client["request"]("/inventory/add", "POST", {
-        body: {
-          itemId: creditsItemId,
-          qty: amount
-        }
-      });
-      client["emit"]("inventoryChange", {
-        itemId: creditsItemId,
-        delta: amount,
-        newTotal: result.newTotal
-      });
-      return result.newTotal;
-    },
-    spend: async (amount) => {
-      assertPlatformMode(client, "credits.spend()");
-      if (amount <= 0) {
-        throw new Error("Amount must be positive");
-      }
-      const creditsItemId = await getCreditsItemId();
-      const result = await client["request"]("/inventory/remove", "POST", {
-        body: {
-          itemId: creditsItemId,
-          qty: amount
-        }
-      });
-      client["emit"]("inventoryChange", {
-        itemId: creditsItemId,
-        delta: -amount,
-        newTotal: result.newTotal
-      });
-      return result.newTotal;
-    }
-  };
-}
 // src/namespaces/game/scores.ts
 function createScoresNamespace(client) {
   return {
@@ -1460,18 +1122,6 @@ function createScoresNamespace(client) {
     }
   };
 }
-// src/namespaces/game/realtime.ts
-function createRealtimeNamespace(client) {
-  return {
-    token: {
-      get: async () => {
-        assertPlatformMode(client, "realtime.token.get()");
-        const endpoint = client["gameId"] ? `/games/${client["gameId"]}/realtime/token` : "/realtime/token";
-        return client["request"](endpoint, "POST");
-      }
-    }
-  };
-}
 // src/core/guards.ts
 var VALID_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
 var VALID_SUBJECTS = [
@@ -1491,7 +1141,13 @@ function isValidGrade(value) {
 function isValidSubject(value) {
   return typeof value === "string" && VALID_SUBJECTS.includes(value);
 }
-
+// ../constants/src/timeback.ts
+var TIMEBACK_ROUTES = {
+  END_ACTIVITY: "/integrations/timeback/end-activity",
+  GET_XP: "/integrations/timeback/xp",
+  HEARTBEAT: "/integrations/timeback/heartbeat",
+  ADVANCE_COURSE: "/integrations/timeback/advance-course"
+};
 // src/core/cache/ttl-cache.ts
 function createTTLCache(options) {
   const cache = new Map;
@@ -1953,17 +1609,21 @@ function createTimebackActivityTracker(client) {
     }
   }
   return {
+    currentRunId() {
+      return currentActivity?.runId;
+    },
     startActivity(metadata, options) {
       if (options?.runId !== undefined && !isValidUUID(options.runId)) {
         throw new Error(`startActivity: \`runId\` must be a UUID (received \`${JSON.stringify(options.runId)}\`). Use crypto.randomUUID() or persist a previously-generated UUID.`);
       }
       cleanupListeners();
       const now = Date.now();
+      const runId = options?.runId ?? crypto.randomUUID();
       const heartbeatIntervalMs = normalizeDelayMs(options?.heartbeatIntervalMs, DEFAULT_HEARTBEAT_INTERVAL_MS, false);
       const pausedHeartbeatTimeoutMs = normalizeDelayMs(options?.pausedHeartbeatTimeoutMs ?? options?.hiddenTimeoutMs, DEFAULT_PAUSED_HEARTBEAT_TIMEOUT_MS, false);
       const inactivityTimeoutMs = normalizeDelayMs(options?.inactivityTimeoutMs, DEFAULT_INACTIVITY_TIMEOUT_MS, false);
       currentActivity = {
-        runId: options?.runId ?? crypto.randomUUID(),
+        runId,
         resumeId: crypto.randomUUID(),
         startTime: now,
         metadata,
@@ -2006,6 +1666,7 @@ function createTimebackActivityTracker(client) {
       messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
       messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
       syncInactivityTracking();
+      return { runId };
     },
     pauseActivity() {
       if (!currentActivity) {
@@ -2189,6 +1850,7 @@ function createTimebackEngine(client) {
       }
     },
     activity: {
+      currentRunId: activityTracker.currentRunId,
       start: activityTracker.startActivity,
       pause: activityTracker.pauseActivity,
       resume: activityTracker.resumeActivity,
@@ -2249,9 +1911,13 @@ function createTimebackNamespace(client) {
         }
       };
     },
+    get currentRunId() {
+      assertPlatformMode(client, "timeback.currentRunId");
+      return engine.activity.currentRunId();
+    },
     startActivity: (metadata, options) => {
       assertPlatformMode(client, "timeback.startActivity()");
-      engine.activity.start(metadata, options);
+      return engine.activity.start(metadata, options);
     },
     pauseActivity: () => {
       assertPlatformMode(client, "timeback.pauseActivity()");
@@ -2274,6 +1940,15 @@ function createTimebackNamespace(client) {
     }
   };
 }
+// src/namespaces/game/users.ts
+function createUsersNamespace(client) {
+  return {
+    me: async () => {
+      assertPlatformMode(client, "users.me()");
+      return client["request"]("/users/me", "GET");
+    }
+  };
+}
 // src/namespaces/platform/leaderboard.ts
 async function fetchInternalLeaderboardEntries(client, options) {
   const params = new URLSearchParams({
@@ -2386,231 +2061,6 @@ function createAuthStrategy(token, tokenType) {
   return new GameJwtAuth(token);
 }
 
-// src/core/connection/monitor.ts
-class ConnectionMonitor {
-  state = "online";
-  callbacks = new Set;
-  heartbeatInterval;
-  consecutiveFailures = 0;
-  isMonitoring = false;
-  config;
-  constructor(config) {
-    this.config = {
-      baseUrl: config.baseUrl,
-      heartbeatInterval: config.heartbeatInterval ?? 1e4,
-      heartbeatTimeout: config.heartbeatTimeout ?? 5000,
-      failureThreshold: config.failureThreshold ?? 2,
-      enableHeartbeat: config.enableHeartbeat ?? true,
-      enableOfflineEvents: config.enableOfflineEvents ?? true
-    };
-    this._detectInitialState();
-  }
-  start() {
-    if (this.isMonitoring) {
-      return;
-    }
-    this.isMonitoring = true;
-    if (this.config.enableOfflineEvents && typeof globalThis.window !== "undefined") {
-      globalThis.addEventListener("online", this._handleOnline);
-      globalThis.addEventListener("offline", this._handleOffline);
-    }
-    if (this.config.enableHeartbeat) {
-      this._startHeartbeat();
-    }
-  }
-  stop() {
-    if (!this.isMonitoring) {
-      return;
-    }
-    this.isMonitoring = false;
-    if (typeof globalThis.window !== "undefined") {
-      globalThis.removeEventListener("online", this._handleOnline);
-      globalThis.removeEventListener("offline", this._handleOffline);
-    }
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = undefined;
-    }
-  }
-  onChange(callback) {
-    this.callbacks.add(callback);
-    return () => this.callbacks.delete(callback);
-  }
-  getState() {
-    return this.state;
-  }
-  async checkNow() {
-    await this._performHeartbeat();
-    return this.state;
-  }
-  reportRequestFailure(error) {
-    const isNetworkError = error instanceof TypeError || error instanceof Error && error.message.includes("fetch");
-    if (!isNetworkError) {
-      return;
-    }
-    this.consecutiveFailures++;
-    if (this.consecutiveFailures >= this.config.failureThreshold) {
-      this._setState("degraded", "Multiple consecutive request failures");
-    }
-  }
-  reportRequestSuccess() {
-    if (this.consecutiveFailures > 0) {
-      this.consecutiveFailures = 0;
-      if (this.state === "degraded") {
-        this._setState("online", "Requests succeeding again");
-      }
-    }
-  }
-  _detectInitialState() {
-    if (typeof navigator !== "undefined" && !navigator.onLine) {
-      this.state = "offline";
-    }
-  }
-  _handleOnline = () => {
-    this.consecutiveFailures = 0;
-    this._setState("online", "Browser online event");
-  };
-  _handleOffline = () => {
-    this._setState("offline", "Browser offline event");
-  };
-  _startHeartbeat() {
-    this._performHeartbeat();
-    this.heartbeatInterval = setInterval(() => {
-      this._performHeartbeat();
-    }, this.config.heartbeatInterval);
-  }
-  async _performHeartbeat() {
-    if (typeof navigator !== "undefined" && !navigator.onLine) {
-      return;
-    }
-    try {
-      const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), this.config.heartbeatTimeout);
-      const response = await fetch(`${this.config.baseUrl}/ping`, {
-        method: "GET",
-        signal: controller.signal,
-        cache: "no-store"
-      });
-      clearTimeout(timeoutId);
-      if (response.ok) {
-        this.consecutiveFailures = 0;
-        if (this.state !== "online") {
-          this._setState("online", "Heartbeat successful");
-        }
-      } else {
-        this._handleHeartbeatFailure("Heartbeat returned non-OK status");
-      }
-    } catch (error) {
-      this._handleHeartbeatFailure(error instanceof Error ? error.message : "Heartbeat failed");
-    }
-  }
-  _handleHeartbeatFailure(reason) {
-    this.consecutiveFailures++;
-    if (this.consecutiveFailures >= this.config.failureThreshold) {
-      if (typeof navigator !== "undefined" && !navigator.onLine) {
-        this._setState("offline", reason);
-      } else {
-        this._setState("degraded", reason);
-      }
-    }
-  }
-  _setState(newState, reason) {
-    if (this.state === newState) {
-      return;
-    }
-    const oldState = this.state;
-    this.state = newState;
-    console.debug(`[ConnectionMonitor] ${oldState} → ${newState}: ${reason}`);
-    this.callbacks.forEach((callback) => {
-      try {
-        callback(newState, reason);
-      } catch (error) {
-        console.error("[ConnectionMonitor] Error in callback:", error);
-      }
-    });
-  }
-}
-// src/core/connection/utils.ts
-function createDisplayAlert(authContext) {
-  return (message, options) => {
-    if (authContext?.isInIframe && typeof globalThis.window !== "undefined" && globalThis.window.parent !== globalThis.window) {
-      window.parent.postMessage({
-        type: "PLAYCADEMY_DISPLAY_ALERT",
-        message,
-        options
-      }, "*");
-    } else {
-      const prefixMap = { error: "❌", warning: "⚠️", info: "ℹ️" };
-      const prefix = (options?.type && prefixMap[options.type]) ?? "ℹ️";
-      console.log(`${prefix} ${message}`);
-    }
-  };
-}
-
-// src/core/connection/manager.ts
-class ConnectionManager {
-  monitor;
-  authContext;
-  disconnectHandler;
-  connectionChangeCallback;
-  currentState = "online";
-  additionalDisconnectHandlers = new Set;
-  constructor(config) {
-    this.authContext = config.authContext;
-    this.disconnectHandler = config.onDisconnect;
-    this.connectionChangeCallback = config.onConnectionChange;
-    if (config.authContext?.isInIframe) {
-      this._setupPlatformListener();
-    }
-  }
-  getState() {
-    return this.monitor?.getState() ?? this.currentState;
-  }
-  async checkNow() {
-    if (!this.monitor) {
-      return this.currentState;
-    }
-    return await this.monitor.checkNow();
-  }
-  reportRequestSuccess() {
-    this.monitor?.reportRequestSuccess();
-  }
-  reportRequestFailure(error) {
-    this.monitor?.reportRequestFailure(error);
-  }
-  onDisconnect(callback) {
-    this.additionalDisconnectHandlers.add(callback);
-    return () => {
-      this.additionalDisconnectHandlers.delete(callback);
-    };
-  }
-  stop() {
-    this.monitor?.stop();
-  }
-  _setupPlatformListener() {
-    messaging.listen("PLAYCADEMY_CONNECTION_STATE" /* CONNECTION_STATE */, ({ state, reason }) => {
-      this.currentState = state;
-      this._handleConnectionChange(state, reason);
-    });
-  }
-  _handleConnectionChange(state, reason) {
-    this.connectionChangeCallback?.(state, reason);
-    if (state === "offline" || state === "degraded") {
-      const context = {
-        state,
-        reason,
-        timestamp: Date.now(),
-        displayAlert: createDisplayAlert(this.authContext)
-      };
-      if (this.disconnectHandler) {
-        this.disconnectHandler(context);
-      }
-      this.additionalDisconnectHandlers.forEach((handler) => {
-        handler(context);
-      });
-    }
-  }
-}
 // src/core/transport/retry.ts
 var RETRY_DELAYS_MS = [500, 1500];
 function wait(ms) {
@@ -2760,15 +2210,9 @@ class PlaycademyBaseClient {
   gameId;
   config;
   listeners = {};
-  internalClientSessionId;
   authContext;
   initPayload;
-  connectionManager;
   launchId;
-  _sessionManager = {
-    startSession: async (gameId) => this.request(`/games/${gameId}/sessions`, "POST"),
-    endSession: async (sessionId, gameId) => this.request(`/games/${gameId}/sessions/${sessionId}`, "DELETE")
-  };
   constructor(config) {
     this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
     this.gameUrl = config?.gameUrl;
@@ -2778,8 +2222,6 @@ class PlaycademyBaseClient {
     this.config = config || {};
     this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
     this._detectAuthContext();
-    this._initializeInternalSession().catch(() => {});
-    this._initializeConnectionMonitor();
   }
   getBaseUrl() {
     const isRelative = this.baseUrl.startsWith("/");
@@ -2817,21 +2259,6 @@ class PlaycademyBaseClient {
   onAuthChange(callback) {
     this.on("authChange", (payload) => callback(payload.token));
   }
-  onDisconnect(callback) {
-    if (!this.connectionManager) {
-      return () => {};
-    }
-    return this.connectionManager.onDisconnect(callback);
-  }
-  getConnectionState() {
-    return this.connectionManager?.getState() ?? "unknown";
-  }
-  async checkConnection() {
-    if (!this.connectionManager) {
-      return "unknown";
-    }
-    return await this.connectionManager.checkNow();
-  }
   _setAuthContext(context) {
     this.authContext = context;
   }
@@ -2861,44 +2288,30 @@ class PlaycademyBaseClient {
       ...this.authStrategy.getHeaders(),
       ...this.launchId ? { "x-playcademy-launch-id": this.launchId } : {}
     };
-    try {
-      const result = await request({
-        path,
-        method,
-        body: options?.body,
-        baseUrl: this.baseUrl,
-        extraHeaders: effectiveHeaders,
-        raw: options?.raw,
-        retryPolicy: options?.retryPolicy
-      });
-      this.connectionManager?.reportRequestSuccess();
-      return result;
-    } catch (error) {
-      this.connectionManager?.reportRequestFailure(error);
-      throw error;
-    }
+    return request({
+      path,
+      method,
+      body: options?.body,
+      baseUrl: this.baseUrl,
+      extraHeaders: effectiveHeaders,
+      raw: options?.raw,
+      retryPolicy: options?.retryPolicy
+    });
   }
   async requestGameBackend(path, method, body, headers, options) {
     const effectiveHeaders = {
       ...headers,
       ...this.authStrategy.getHeaders()
     };
-    try {
-      const result = await request({
-        path,
-        method,
-        body,
-        baseUrl: this.getGameBackendUrl(),
-        extraHeaders: effectiveHeaders,
-        raw: options?.raw,
-        retryPolicy: options?.retryPolicy
-      });
-      this.connectionManager?.reportRequestSuccess();
-      return result;
-    } catch (error) {
-      this.connectionManager?.reportRequestFailure(error);
-      throw error;
-    }
+    return request({
+      path,
+      method,
+      body,
+      baseUrl: this.getGameBackendUrl(),
+      extraHeaders: effectiveHeaders,
+      raw: options?.raw,
+      retryPolicy: options?.retryPolicy
+    });
   }
   _ensureGameId() {
     if (!this.gameId) {
@@ -2909,49 +2322,6 @@ class PlaycademyBaseClient {
   _detectAuthContext() {
     this.authContext = { isInIframe: isInIframe() };
   }
-  _initializeConnectionMonitor() {
-    if (typeof globalThis.window === "undefined") {
-      return;
-    }
-    const isEnabled = this.config.enableConnectionMonitoring ?? true;
-    if (!isEnabled) {
-      return;
-    }
-    try {
-      this.connectionManager = new ConnectionManager({
-        baseUrl: this.baseUrl,
-        authContext: this.authContext,
-        onDisconnect: this.config.onDisconnect,
-        onConnectionChange: (state, reason) => {
-          this.emit("connectionChange", { state, reason });
-        }
-      });
-    } catch (error) {
-      log.error("[Playcademy SDK] Failed to initialize connection manager:", { error });
-    }
-  }
-  async _initializeInternalSession() {
-    if (!this.gameId || this.internalClientSessionId) {
-      return;
-    }
-    const shouldAutoStart = this.config.autoStartSession ?? true;
-    if (!shouldAutoStart) {
-      return;
-    }
-    try {
-      const response = await this._sessionManager.startSession(this.gameId);
-      this.internalClientSessionId = response.sessionId;
-      log.debug("[Playcademy SDK] Auto-started game session", {
-        gameId: this.gameId,
-        sessionId: this.internalClientSessionId
-      });
-    } catch (error) {
-      log.error("[Playcademy SDK] Auto-starting session failed for game", {
-        gameId: this.gameId,
-        error
-      });
-    }
-  }
   users = createUsersNamespace(this);
 }
 
@@ -2960,11 +2330,9 @@ class PlaycademyClient extends PlaycademyBaseClient {
   identity = createIdentityNamespace(this);
   runtime = createRuntimeNamespace(this);
   timeback = createTimebackNamespace(this);
-  credits = createCreditsNamespace(this);
   scores = createScoresNamespace(this);
   leaderboard = createLeaderboardFetchNamespace(this);
   demo = createDemoNamespace(this);
-  realtime = createRealtimeNamespace(this);
   backend = createBackendNamespace(this);
   static init = init;
   static login = login;
@@ -2976,7 +2344,5 @@ export {
   PlaycademyError,
   PlaycademyClient,
   MessageEvents,
-  ConnectionMonitor,
-  ConnectionManager,
   ApiError
 };