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

package/dist/internal.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,24 @@ 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/admin.ts
+function createAdminNamespace(client) {
+  return {
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
+    }
+  };
+}
 // src/namespaces/platform/auth.ts
 function createAuthNamespace(client) {
   return {
@@ -2321,41 +2005,54 @@ function createAuthNamespace(client) {
     }
   };
 }
-// src/namespaces/platform/admin.ts
-function createAdminNamespace(client) {
-  return {
-    games: {
-      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
-      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
-    },
-    items: {
-      create: (props) => client["request"]("/items", "POST", { body: props }),
-      get: (itemId) => client["request"](`/items/${itemId}`, "GET"),
-      list: () => client["request"]("/items", "GET"),
-      update: (itemId, props) => client["request"](`/items/${itemId}`, "PATCH", { body: props }),
-      delete: (itemId) => client["request"](`/items/${itemId}`, "DELETE")
-    },
-    currencies: {
-      create: (props) => client["request"]("/currencies", "POST", { body: props }),
-      get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
-      list: () => client["request"]("/currencies", "GET"),
-      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", {
-        body: props
-      }),
-      delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
-    },
-    shopListings: {
-      create: (props) => client["request"]("/shop-listings", "POST", { body: props }),
-      get: (listingId) => client["request"](`/shop-listings/${listingId}`, "GET"),
-      list: () => client["request"]("/shop-listings", "GET"),
-      update: (listingId, props) => client["request"](`/shop-listings/${listingId}`, "PATCH", {
-        body: props
-      }),
-      delete: (listingId) => client["request"](`/shop-listings/${listingId}`, "DELETE")
+// src/core/deploy.ts
+var S3_ERROR_HINTS = {
+  ExpiredToken: "the AWS credentials used to sign the upload URL have expired",
+  TokenRefreshRequired: "the AWS credentials used to sign the upload URL have expired",
+  AccessDenied: "the presigned URL was rejected, the upload token may have expired",
+  SignatureDoesNotMatch: "upload signature mismatch, likely a Content-Type header discrepancy"
+};
+async function parseS3Error(response) {
+  try {
+    const xml = await response.text();
+    const code = xml.match(/<Code>(.+?)<\/Code>/)?.[1];
+    const message = xml.match(/<Message>(.+?)<\/Message>/)?.[1];
+    const hint = code ? S3_ERROR_HINTS[code] : undefined;
+    if (hint) {
+      return `${response.status} (${hint})`;
+    }
+    if (code && message) {
+      return `${response.status} (S3 ${code}: ${message})`;
+    }
+    if (code) {
+      return `${response.status} (S3 error: ${code})`;
+    }
+    return `${response.status} ${response.statusText}`;
+  } catch {
+    return `${response.status} ${response.statusText}`;
+  }
+}
+function parseS3ErrorFromXHR(xhr) {
+  try {
+    const xml = xhr.responseText;
+    const code = xml.match(/<Code>(.+?)<\/Code>/)?.[1];
+    const message = xml.match(/<Message>(.+?)<\/Message>/)?.[1];
+    const hint = code ? S3_ERROR_HINTS[code] : undefined;
+    if (hint) {
+      return `${xhr.status} (${hint})`;
     }
-  };
+    if (code && message) {
+      return `${xhr.status} (S3 ${code}: ${message})`;
+    }
+    if (code) {
+      return `${xhr.status} (S3 error: ${code})`;
+    }
+    return `${xhr.status} ${xhr.statusText}`;
+  } catch {
+    return `${xhr.status} ${xhr.statusText}`;
+  }
 }
-// src/core/deploy.ts
+
 class DeployPipeline {
   static POLL_INTERVAL_MS = 1000;
   static INACTIVITY_TIMEOUT_MS = 60 * 1000;
@@ -2439,7 +2136,8 @@ class DeployPipeline {
       headers: { "Content-Type": "application/javascript" }
     });
     if (!res.ok) {
-      throw new Error(`Backend code upload failed: ${res.status} ${res.statusText}`);
+      const detail = await parseS3Error(res);
+      throw new Error(`Backend code upload failed: ${detail}`);
     }
     return uploadToken;
   }
@@ -2450,7 +2148,8 @@ class DeployPipeline {
       headers: { "Content-Type": contentType }
     });
     if (!res.ok) {
-      throw new Error(`File upload failed: ${res.status} ${res.statusText}`);
+      const detail = await parseS3Error(res);
+      throw new Error(`File upload failed: ${detail}`);
     }
   }
   uploadViaXHR(url, body, contentType, hooks) {
@@ -2474,7 +2173,8 @@ class DeployPipeline {
         if (xhr.status >= 200 && xhr.status < 300) {
           resolve();
         } else {
-          reject(new Error(`File upload failed: ${xhr.status} ${xhr.statusText}`));
+          const detail = parseS3ErrorFromXHR(xhr);
+          reject(new Error(`File upload failed: ${detail}`));
         }
       });
       xhr.addEventListener("error", () => reject(new Error("File upload failed: network error")));
@@ -2665,30 +2365,6 @@ function createDevNamespace(client) {
       logs: {
         getToken: async (slug, environment) => client["request"](`/games/${slug}/logs/token`, "POST", { body: { environment } })
       }
-    },
-    items: {
-      create: (gameId, slug, itemData) => client["request"](`/games/${gameId}/items`, "POST", {
-        body: {
-          slug,
-          ...itemData
-        }
-      }),
-      update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}`, "PATCH", {
-        body: 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) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "POST", { body: listingData }),
-        get: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "GET"),
-        update: (gameId, itemId, updates) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "PATCH", { body: updates }),
-        delete: (gameId, itemId) => client["request"](`/games/${gameId}/items/${itemId}/shop-listing`, "DELETE"),
-        list: (gameId) => client["request"](`/games/${gameId}/shop-listings`, "GET")
-      }
     }
   };
 }
@@ -2734,17 +2410,6 @@ function createGamesNamespace(client) {
       search: (gameId, query) => client["request"](`/games/${gameId}/members/search?q=${encodeURIComponent(query)}`, "GET")
     },
     getSubjects: () => client["request"]("/games/subjects", "GET"),
-    startSession: async (gameId) => {
-      const idToUse = gameId ?? client["_ensureGameId"]();
-      return client["request"](`/games/${idToUse}/sessions`, "POST", {});
-    },
-    endSession: async (sessionId, gameId) => {
-      const effectiveGameIdToEnd = gameId ?? client["_ensureGameId"]();
-      if (client["internalClientSessionId"] && sessionId === client["internalClientSessionId"] && effectiveGameIdToEnd === client["gameId"]) {
-        client["internalClientSessionId"] = undefined;
-      }
-      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
-    },
     token: {
       create: async (gameId, options) => {
         const res = await client["request"](`/games/${gameId}/token`, "POST");
@@ -2770,83 +2435,6 @@ function createGamesNamespace(client) {
     }
   };
 }
-// src/namespaces/platform/character.ts
-function createCharacterNamespace(client) {
-  const componentCache = createTTLCache({
-    ttl: 5 * 60 * 1000,
-    keyPrefix: "character.components"
-  });
-  return {
-    get: async (userId) => {
-      try {
-        const path = userId ? `/character/${userId}` : "/character";
-        return await client["request"](path, "GET");
-      } catch (error) {
-        if (error instanceof Error) {
-          if (error.message.includes("404")) {
-            return null;
-          }
-        }
-        throw error;
-      }
-    },
-    create: async (characterData) => client["request"]("/character", "POST", {
-      body: characterData
-    }),
-    update: async (updates) => client["request"]("/character", "PATCH", { body: updates }),
-    components: {
-      list: async (options) => {
-        const cacheKey = options?.level === undefined ? "all" : String(options.level);
-        return componentCache.get(cacheKey, async () => {
-          const path = options?.level !== undefined ? `/character/components?level=${options.level}` : "/character/components";
-          const components = await client["request"](path, "GET");
-          return components || [];
-        }, options);
-      },
-      clearCache: (key) => componentCache.clear(key),
-      getCacheKeys: () => componentCache.getKeys()
-    },
-    accessories: {
-      equip: async (slot, componentId) => client["request"]("/character/accessories/equip", "POST", { body: { slot, accessoryComponentId: componentId } }),
-      remove: async (slot) => client["request"](`/character/accessories/${slot}`, "DELETE"),
-      list: async () => {
-        const character2 = await client.character.get();
-        return character2?.accessories || [];
-      }
-    }
-  };
-}
-// src/namespaces/platform/achievements.ts
-function createAchievementsNamespace(client) {
-  const achievementsListCache = createTTLCache({
-    ttl: 5 * 1000,
-    keyPrefix: "achievements.list"
-  });
-  const achievementsHistoryCache = createTTLCache({
-    ttl: 5 * 1000,
-    keyPrefix: "achievements.history"
-  });
-  return {
-    list: (options) => achievementsListCache.get("current", () => client["request"]("/achievements/current", "GET"), options),
-    history: {
-      list: async (queryOptions, cacheOptions) => {
-        const params = new URLSearchParams;
-        if (queryOptions?.limit) {
-          params.append("limit", String(queryOptions.limit));
-        }
-        const qs = params.toString();
-        const path = qs ? `/achievements/history?${qs}` : "/achievements/history";
-        const cacheKey = qs ? `history-${qs}` : "history";
-        return achievementsHistoryCache.get(cacheKey, () => client["request"](path, "GET"), cacheOptions);
-      }
-    },
-    progress: {
-      submit: async (achievementId) => client["request"]("/achievements/progress", "POST", {
-        body: { achievementId }
-      })
-    }
-  };
-}
 // src/namespaces/platform/leaderboard.ts
 async function fetchInternalLeaderboardEntries(client, options) {
   const params = new URLSearchParams({
@@ -2879,215 +2467,6 @@ function createLeaderboardFetchNamespace(client) {
     fetch: async (options) => fetchPublicLeaderboardEntries(client, options)
   };
 }
-// src/core/cache/cooldown-cache.ts
-function createCooldownCache(defaultCooldownMs) {
-  const lastFetchTime = new Map;
-  const pendingRequests = new Map;
-  const lastResults = new Map;
-  async function get(key, loader, config) {
-    const now = Date.now();
-    const lastFetch = lastFetchTime.get(key) || 0;
-    const timeSinceLastFetch = now - lastFetch;
-    const effectiveCooldown = config?.cooldown !== undefined ? config.cooldown : defaultCooldownMs;
-    const force = config?.force || false;
-    const pending = pendingRequests.get(key);
-    if (pending) {
-      return pending;
-    }
-    if (!force && timeSinceLastFetch < effectiveCooldown) {
-      const cachedResult = lastResults.get(key);
-      if (cachedResult !== undefined) {
-        return Promise.resolve(cachedResult);
-      }
-    }
-    const promise = loader().then((result) => {
-      pendingRequests.delete(key);
-      lastFetchTime.set(key, Date.now());
-      lastResults.set(key, result);
-      return result;
-    }).catch((error) => {
-      pendingRequests.delete(key);
-      throw error;
-    });
-    pendingRequests.set(key, promise);
-    return promise;
-  }
-  function clear(key) {
-    if (key === undefined) {
-      lastFetchTime.clear();
-      pendingRequests.clear();
-      lastResults.clear();
-    } else {
-      lastFetchTime.delete(key);
-      pendingRequests.delete(key);
-      lastResults.delete(key);
-    }
-  }
-  return { get, clear };
-}
-
-// src/namespaces/platform/levels.ts
-function createLevelsNamespace(client) {
-  const progressCache = createCooldownCache(5000);
-  return {
-    get: async () => client["request"]("/users/level", "GET"),
-    progress: async (options) => progressCache.get("user-progress", () => client["request"]("/users/level/progress", "GET"), options),
-    config: {
-      list: async () => client["request"]("/levels/config", "GET"),
-      get: async (level) => client["request"](`/levels/config/${level}`, "GET")
-    }
-  };
-}
-// src/namespaces/platform/shop.ts
-function createShopNamespace(client) {
-  return {
-    view: () => client["request"]("/shop/view", "GET")
-  };
-}
-// src/namespaces/platform/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}`, "PATCH", {
-        body: {
-          id: notificationId,
-          status: "seen"
-        }
-      });
-      notificationsListCache.clear();
-      return result;
-    },
-    markAsClicked: async (notificationId) => {
-      const result = await client["request"](`/notifications/${notificationId}`, "PATCH", {
-        body: {
-          id: notificationId,
-          status: "clicked"
-        }
-      });
-      notificationsListCache.clear();
-      return result;
-    },
-    dismiss: async (notificationId) => {
-      const result = await client["request"](`/notifications/${notificationId}`, "PATCH", {
-        body: {
-          id: notificationId,
-          status: "dismissed"
-        }
-      });
-      notificationsListCache.clear();
-      return result;
-    },
-    markAsDelivered: async (notificationId, method = "realtime") => {
-      const result = await client["request"](`/notifications/${notificationId}`, "PATCH", {
-        body: {
-          id: notificationId,
-          status: "delivered",
-          method
-        }
-      });
-      notificationsListCache.clear();
-      return result;
-    },
-    deliverPending: async () => {
-      const result = await client["request"]("/notifications/deliver", "POST");
-      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);
-      }
-    }
-  };
-}
-// src/namespaces/platform/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, 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", {
-        body: objectData
-      }),
-      delete: (mapId, objectId) => client["request"](`/maps/${mapId}/objects/${objectId}`, "DELETE")
-    }
-  };
-}
-// src/namespaces/platform/sprites.ts
-function createSpritesNamespace(client) {
-  const templateUrlCache = createPermanentCache("sprite-template-urls");
-  return {
-    templates: {
-      get: async (slug) => {
-        if (!slug) {
-          throw new Error("Sprite template slug is required");
-        }
-        const templateMeta = await templateUrlCache.get(slug, async () => client["request"](`/sprites/templates/${slug}`, "GET"));
-        if (!templateMeta.url) {
-          throw new Error(`Template ${slug} has no URL in database`);
-        }
-        const response = await fetch(templateMeta.url);
-        if (!response.ok) {
-          throw new Error(`Failed to fetch template JSON from ${templateMeta.url}: ${response.statusText}`);
-        }
-        return await response.json();
-      }
-    }
-  };
-}
-// src/namespaces/platform/telemetry.ts
-function createTelemetryNamespace(client) {
-  return {
-    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", { body: metrics })
-  };
-}
 // src/namespaces/platform/scores.ts
 function createScoresNamespace2(client) {
   return {
@@ -3157,7 +2536,10 @@ function createTimebackNamespace2(client) {
       };
     },
     populateStudent: async (names) => client["request"]("/timeback/populate-student", "POST", names ? { body: names } : undefined),
-    startActivity: (_metadata) => {
+    get currentRunId() {
+      throw new Error(NOT_SUPPORTED);
+    },
+    startActivity: (_metadata, _options) => {
       throw new Error(NOT_SUPPORTED);
     },
     pauseActivity: () => {
@@ -3180,50 +2562,6 @@ function createTimebackNamespace2(client) {
       getIntegrationConfig: (gameId, courseId) => client["request"](`/timeback/integrations/${gameId}/${courseId}`, "GET"),
       getConfig: (gameId) => client["request"](`/timeback/config/${gameId}`, "GET")
     },
-    xp: {
-      today: async (options) => {
-        const params = new URLSearchParams;
-        if (options?.date) {
-          params.set("date", options.date);
-        }
-        if (options?.timezone) {
-          params.set("tz", options.timezone);
-        }
-        const query = params.toString();
-        const endpoint = query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
-        return client["request"](endpoint, "GET");
-      },
-      total: async () => client["request"]("/timeback/xp/total", "GET"),
-      history: async (options) => {
-        const params = new URLSearchParams;
-        if (options?.startDate) {
-          params.set("startDate", options.startDate);
-        }
-        if (options?.endDate) {
-          params.set("endDate", options.endDate);
-        }
-        const query = params.toString();
-        const endpoint = query ? `/timeback/xp/history?${query}` : "/timeback/xp/history";
-        return client["request"](endpoint, "GET");
-      },
-      summary: async (options) => {
-        const [today, total] = await Promise.all([
-          client["request"]((() => {
-            const params = new URLSearchParams;
-            if (options?.date) {
-              params.set("date", options.date);
-            }
-            if (options?.timezone) {
-              params.set("tz", options.timezone);
-            }
-            const query = params.toString();
-            return query ? `/timeback/xp/today?${query}` : "/timeback/xp/today";
-          })(), "GET"),
-          client["request"]("/timeback/xp/total", "GET")
-        ]);
-        return { today, total };
-      }
-    },
     students: {
       get: async (timebackId, options) => studentCache.get(timebackId, async () => client["request"](`/timeback/user/${timebackId}`, "GET"), options),
       clearCache: (timebackId) => {
@@ -3376,231 +2714,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) {
@@ -3750,15 +2863,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;
@@ -3768,8 +2875,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("/");
@@ -3807,21 +2912,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;
   }
@@ -3851,44 +2941,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) {
@@ -3899,49 +2975,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);
 }
 
@@ -3949,22 +2982,12 @@ class PlaycademyBaseClient {
 class PlaycademyInternalClient extends PlaycademyBaseClient {
   identity = createIdentityNamespace(this);
   runtime = createRuntimeNamespace(this);
-  credits = createCreditsNamespace(this);
-  realtime = createRealtimeNamespace(this);
   backend = createBackendNamespace(this);
   auth = createAuthNamespace(this);
   admin = createAdminNamespace(this);
   dev = createDevNamespace(this);
   games = createGamesNamespace(this);
-  character = createCharacterNamespace(this);
-  achievements = createAchievementsNamespace(this);
   leaderboard = createLeaderboardNamespace(this);
-  levels = createLevelsNamespace(this);
-  shop = createShopNamespace(this);
-  notifications = createNotificationsNamespace(this);
-  maps = createMapsNamespace(this);
-  sprites = createSpritesNamespace(this);
-  telemetry = createTelemetryNamespace(this);
   scores = createScoresNamespace2(this);
   timeback = createTimebackNamespace2(this);
   static init = init;
@@ -3978,7 +3001,5 @@ export {
   PlaycademyError,
   PlaycademyInternalClient as PlaycademyClient,
   MessageEvents,
-  ConnectionMonitor,
-  ConnectionManager,
   ApiError
 };