@playcademy/sdk 0.16.1-beta.1 → 0.16.1-beta.10

package/dist/index.js

@@ -26,9 +26,35 @@ var MessageEvents;
   MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
   MessageEvents2["DEMO_END"] = "PLAYCADEMY_DEMO_END";
   MessageEvents2["TIMEBACK_HEARTBEAT_RELAY"] = "PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY";
+  MessageEvents2["TIMEBACK_ACTIVITY_START"] = "PLAYCADEMY_TIMEBACK_ACTIVITY_START";
+  MessageEvents2["TIMEBACK_ACTIVITY_END"] = "PLAYCADEMY_TIMEBACK_ACTIVITY_END";
+  MessageEvents2["CHECKPOINT"] = "PLAYCADEMY_CHECKPOINT";
   MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
   MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
 })(MessageEvents ||= {});
+function isFromParentWindow(event) {
+  return globalThis.window.parent !== globalThis.window && event.source === globalThis.window.parent;
+}
+var MESSAGE_DIRECTION = {
+  ["PLAYCADEMY_INIT" /* INIT */]: "launcher-to-game",
+  ["PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */]: "launcher-to-game",
+  ["PLAYCADEMY_PAUSE" /* PAUSE */]: "launcher-to-game",
+  ["PLAYCADEMY_RESUME" /* RESUME */]: "launcher-to-game",
+  ["PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */]: "launcher-to-game",
+  ["PLAYCADEMY_OVERLAY" /* OVERLAY */]: "launcher-to-game",
+  ["PLAYCADEMY_READY" /* READY */]: "game-to-launcher",
+  ["PLAYCADEMY_INIT_ERROR" /* INIT_ERROR */]: "game-to-launcher",
+  ["PLAYCADEMY_EXIT" /* EXIT */]: "game-to-launcher",
+  ["PLAYCADEMY_TELEMETRY" /* TELEMETRY */]: "game-to-launcher",
+  ["PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */]: "game-to-launcher",
+  ["PLAYCADEMY_DEMO_END" /* DEMO_END */]: "game-to-launcher",
+  ["PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */]: "game-to-launcher",
+  ["PLAYCADEMY_TIMEBACK_ACTIVITY_START" /* TIMEBACK_ACTIVITY_START */]: "game-to-launcher",
+  ["PLAYCADEMY_TIMEBACK_ACTIVITY_END" /* TIMEBACK_ACTIVITY_END */]: "game-to-launcher",
+  ["PLAYCADEMY_CHECKPOINT" /* CHECKPOINT */]: "game-to-launcher",
+  ["PLAYCADEMY_AUTH_STATE_CHANGE" /* AUTH_STATE_CHANGE */]: "unscoped",
+  ["PLAYCADEMY_AUTH_CALLBACK" /* AUTH_CALLBACK */]: "unscoped"
+};
 
 class PlaycademyMessaging {
   listeners = new Map;
@@ -44,12 +70,17 @@ class PlaycademyMessaging {
       this.sendViaCustomEvent(type, payload);
     }
   }
-  listen(type, handler) {
+  listen(type, handler, options) {
+    const gateToParent = options?.fromParent ?? MESSAGE_DIRECTION[type] === "launcher-to-game";
     function postMessageListener(event) {
       const messageEvent = event;
-      if (messageEvent.data?.type === type) {
-        handler(messageEvent.data.payload || messageEvent.data);
+      if (messageEvent.data?.type !== type) {
+        return;
+      }
+      if (gateToParent && !isFromParentWindow(messageEvent)) {
+        return;
       }
+      handler(messageEvent.data.payload || messageEvent.data);
     }
     function customEventListener(event) {
       handler(event.detail);
@@ -80,16 +111,7 @@ class PlaycademyMessaging {
   }
   getMessagingContext(eventType) {
     const isIframe = typeof globalThis.window !== "undefined" && globalThis.self !== window.top;
-    const iframeToParentEvents = [
-      "PLAYCADEMY_READY" /* READY */,
-      "PLAYCADEMY_INIT_ERROR" /* INIT_ERROR */,
-      "PLAYCADEMY_EXIT" /* EXIT */,
-      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
-      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */,
-      "PLAYCADEMY_DEMO_END" /* DEMO_END */,
-      "PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */
-    ];
-    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    const shouldUsePostMessage = isIframe && MESSAGE_DIRECTION[eventType] === "game-to-launcher";
     return {
       shouldUsePostMessage,
       target: shouldUsePostMessage ? window.parent : undefined,
@@ -108,8 +130,60 @@ class PlaycademyMessaging {
   }
 }
 var messaging = new PlaycademyMessaging;
+function isTrustedIframeMessage(event, iframeWindow, origin) {
+  if (!iframeWindow || event.source !== iframeWindow || event.origin === "null") {
+    return false;
+  }
+  return origin === "*" || event.origin === origin;
+}
 
-// src/core/static/init.ts
+// src/core/launch/handshake.ts
+var INIT_WAIT_TIMEOUT_MS = 25000;
+var HANDSHAKE_RESEND_INTERVAL_MS = 300;
+var HANDSHAKE_MAX_DURATION_MS = 30000;
+function beginInitHandshake({
+  iframe,
+  origin,
+  payload,
+  onTimeout,
+  onSendError
+}) {
+  let intervalId = null;
+  let timeoutId = null;
+  function sendInitOnce() {
+    if (!iframe.contentWindow) {
+      return;
+    }
+    try {
+      messaging.send("PLAYCADEMY_INIT" /* INIT */, payload, {
+        target: iframe.contentWindow,
+        origin
+      });
+    } catch (error) {
+      stop();
+      onSendError?.(error);
+    }
+  }
+  function stop() {
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  }
+  sendInitOnce();
+  intervalId = setInterval(sendInitOnce, HANDSHAKE_RESEND_INTERVAL_MS);
+  timeoutId = setTimeout(() => {
+    stop();
+    onTimeout();
+  }, HANDSHAKE_MAX_DURATION_MS);
+  return stop;
+}
+
+// src/core/launch/context.ts
 async function getPlaycademyConfig(allowedParentOrigins) {
   const preloaded = globalThis.PLAYCADEMY;
   if (preloaded?.token) {
@@ -148,7 +222,6 @@ function isOriginAllowed(origin, allowlist) {
 async function waitForPlaycademyInit(allowedParentOrigins) {
   return new Promise((resolve, reject) => {
     let contextReceived = false;
-    const timeoutDuration = 25000;
     const allowlist = buildAllowedOrigins(allowedParentOrigins);
     let hasWarnedAboutUntrustedOrigin = false;
     function warnAboutUntrustedOrigin(origin) {
@@ -179,11 +252,11 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
     const timeoutId = setTimeout(() => {
       if (!contextReceived) {
         window.removeEventListener("message", handleMessage);
-        const reason = `${"PLAYCADEMY_INIT" /* INIT */} not received within ${timeoutDuration}ms`;
+        const reason = `${"PLAYCADEMY_INIT" /* INIT */} not received within ${INIT_WAIT_TIMEOUT_MS}ms`;
         messaging.send("PLAYCADEMY_INIT_ERROR" /* INIT_ERROR */, { reason });
         reject(new Error(reason));
       }
-    }, timeoutDuration);
+    }, INIT_WAIT_TIMEOUT_MS);
   });
 }
 function createStandaloneConfig() {
@@ -198,6 +271,8 @@ function createStandaloneConfig() {
   globalThis.PLAYCADEMY = mockConfig;
   return mockConfig;
 }
+
+// src/core/static/init.ts
 async function init(options) {
   if (typeof globalThis.window === "undefined") {
     throw new Error("Playcademy SDK must run in a browser context");
@@ -677,6 +752,16 @@ function assertPlatformMode(client, operation) {
     throw new PlaycademyError(`${operation} requires platform mode (current: ${client.mode}). Check client.mode before calling.`);
   }
 }
+function assertNonAnonymousMode(client, operation) {
+  if (client.mode !== "platform" && client.mode !== "child") {
+    throw new PlaycademyError(`${operation} requires a real user (platform or child mode; current: ${client.mode}). Check client.mode before calling.`);
+  }
+}
+function assertNotChildMode(client, operation, hint) {
+  if (client.mode === "child") {
+    throw new PlaycademyError(`${operation} is not available when child-launched. ${hint}`);
+  }
+}
 function assertDemoMode(client, operation) {
   if (client.mode !== "demo") {
     throw new PlaycademyError(`${operation} requires demo mode (current: ${client.mode}). Check client.mode before calling.`);
@@ -707,538 +792,761 @@ function createDemoNamespace(client) {
     }
   };
 }
-// src/core/auth/utils.ts
-function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
-  const left = window.screenX + (window.outerWidth - width) / 2;
-  const top = window.screenY + (window.outerHeight - height) / 2;
-  const features = [
-    `width=${width}`,
-    `height=${height}`,
-    `left=${left}`,
-    `top=${top}`,
-    "toolbar=no",
-    "menubar=no",
-    "location=yes",
-    "status=yes",
-    "scrollbars=yes",
-    "resizable=yes"
-  ].join(",");
-  return window.open(url, name, features);
+// ../constants/src/auth.ts
+var DEFAULT_PERSONAL_API_KEY_PERMISSIONS = {
+  games: ["read", "write", "delete"],
+  users: ["read:self", "write:self"],
+  dev: ["read", "write"]
+};
+// ../constants/src/platform.ts
+var PLAYCADEMY_BROWSER_TIME_ZONE_HEADER = "x-playcademy-browser-time-zone";
+// ../constants/src/timeback.ts
+var TIMEBACK_ROUTES = {
+  END_ACTIVITY: "/integrations/timeback/end-activity",
+  GET_XP: "/integrations/timeback/xp",
+  GET_MASTERY: "/integrations/timeback/mastery",
+  GET_HIGHEST_GRADE_MASTERED: "/integrations/timeback/highest-grade-mastered",
+  HEARTBEAT: "/integrations/timeback/heartbeat",
+  ADVANCE_COURSE: "/integrations/timeback/advance-course",
+  UNENROLL_COURSE: "/integrations/timeback/unenroll-course",
+  ASSESSMENTS: "/integrations/timeback/assessments"
+};
+var TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
+var TIMEBACK_SUBJECTS = [
+  "Reading",
+  "Language",
+  "Vocabulary",
+  "Social Studies",
+  "Writing",
+  "Science",
+  "FastMath",
+  "Math",
+  "None"
+];
+var ASSESSMENT_PURPOSES = ["end_of_course", "diagnostic", "review", "mastery"];
+var TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS = {
+  standards: 20,
+  itemsPerStandard: 5,
+  standardFieldLength: 128
+};
+var VALID_E_LEVELS = ["E1", "E2", "E3", "E4"];
+var TIMEBACK_GAME_METRIC_DECIMAL_PLACES = {
+  xp: 1,
+  mastery: 0,
+  score: 2
+};
+var TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE = {
+  xp: 0.5 / 10 ** TIMEBACK_GAME_METRIC_DECIMAL_PLACES.xp,
+  mastery: 0,
+  time: 60,
+  score: 0.5 / 10 ** TIMEBACK_GAME_METRIC_DECIMAL_PLACES.score
+};
+// ../utils/src/error.ts
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-function isInIframe() {
-  if (typeof globalThis.window === "undefined") {
+
+// src/core/launch/exclusivity.ts
+var liveSessions = new WeakSet;
+function registerLiveSession(client) {
+  liveSessions.add(client);
+}
+function releaseLiveSession(client) {
+  liveSessions.delete(client);
+}
+function hasLiveSession(client) {
+  return liveSessions.has(client);
+}
+var pauseProbes = new WeakMap;
+function registerPauseProbe(client, probe) {
+  pauseProbes.set(client, probe);
+}
+function isActivityManuallyPaused(client) {
+  return pauseProbes.get(client)?.() ?? false;
+}
+
+// src/core/guards.ts
+var VALID_GRADES = TIMEBACK_GRADES;
+var VALID_SUBJECTS = TIMEBACK_SUBJECTS;
+function isValidGrade(value) {
+  return typeof value === "number" && Number.isInteger(value) && VALID_GRADES.includes(value);
+}
+function isValidSubject(value) {
+  return typeof value === "string" && VALID_SUBJECTS.includes(value);
+}
+function isAssessmentPurpose(value) {
+  return typeof value === "string" && ASSESSMENT_PURPOSES.includes(value);
+}
+function isValidELevel(value) {
+  return typeof value === "string" && VALID_E_LEVELS.includes(value);
+}
+
+// src/core/launch/guards.ts
+function isValidLaunchIntent(value) {
+  if (typeof value !== "object" || value === null) {
     return false;
   }
+  const intent = value;
+  return typeof intent.lessonId === "string" && intent.lessonId !== "" && isValidELevel(intent.eLevel);
+}
+function isValidTimebackRecording(recording) {
+  return typeof recording.activityId === "string" && recording.activityId !== "" && isValidGrade(recording.grade) && isValidSubject(recording.subject);
+}
+
+// src/core/launch/resume-store.ts
+function isResumeStore(resume) {
+  return "load" in resume && typeof resume.load === "function";
+}
+function resolveResumePolicy(request) {
+  const { resume } = request;
+  if (resume === false || resume === null) {
+    return {};
+  }
+  if (resume !== undefined) {
+    return isResumeStore(resume) ? { store: resume } : { envelope: resume };
+  }
+  const userId = tokenUserId(request.token);
+  if (!userId) {
+    console.warn("[Playcademy SDK] embed.launch(): could not identify the user from the token, so this launch will not be resumable. Pass resume: false to opt out explicitly.");
+    return {};
+  }
+  const store = createLocalStorageResumeStore(buildResumeStorageKey({
+    userId,
+    parentGameId: request.parentGameId,
+    slug: request.slug,
+    intent: request.intent
+  }));
+  if (!store) {
+    console.warn("[Playcademy SDK] embed.launch(): localStorage is unavailable, so this launch will not be resumable. Pass resume: false to opt out explicitly.");
+    return {};
+  }
+  return { store };
+}
+function tokenUserId(token) {
+  const segments = token.split(".");
+  if (segments.length !== 3 || !segments[1]) {
+    return null;
+  }
   try {
-    return globalThis.self !== window.top;
+    const base64 = segments[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const claims = JSON.parse(atob(padded));
+    return typeof claims.uid === "string" && claims.uid ? claims.uid : null;
   } catch {
-    return true;
+    return null;
+  }
+}
+function buildResumeStorageKey(identity2) {
+  const parts = [
+    identity2.userId,
+    identity2.parentGameId,
+    identity2.slug,
+    identity2.intent.lessonId,
+    identity2.intent.eLevel
+  ];
+  return `playcademy:embed:resume:v1:${parts.map(encodeURIComponent).join(":")}`;
+}
+function isResumeEnvelope(value) {
+  return typeof value === "object" && value !== null && "state" in value;
+}
+function getLocalStorage() {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+function createLocalStorageResumeStore(key) {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return null;
   }
+  let warned = false;
+  return {
+    load() {
+      let raw;
+      try {
+        raw = storage.getItem(key);
+      } catch {
+        return null;
+      }
+      if (raw === null) {
+        return null;
+      }
+      try {
+        const parsed = JSON.parse(raw);
+        if (isResumeEnvelope(parsed)) {
+          return parsed;
+        }
+      } catch {}
+      try {
+        storage.removeItem(key);
+      } catch {}
+      return null;
+    },
+    save(envelope) {
+      try {
+        storage.setItem(key, JSON.stringify(envelope));
+      } catch (error) {
+        if (!warned) {
+          warned = true;
+          console.warn("[Playcademy SDK] embed: resume persistence failed; this launch will not be resumable across reloads:", errorMessage(error));
+        }
+      }
+    },
+    clear() {
+      try {
+        storage.removeItem(key);
+      } catch {}
+    }
+  };
 }
 
-// src/core/auth/flows/popup.ts
-async function initiatePopupFlow(options) {
-  const { provider, callbackUrl, onStateChange, oauth } = options;
+// src/core/launch/session.ts
+function buildParentContext(gameId, intent, resume) {
+  const context = { gameId, intent };
+  if (resume) {
+    context.resume = resume.state;
+  }
+  if (resume?.childRunId) {
+    context.resumeRunId = resume.childRunId;
+  }
+  return context;
+}
+var EMBED_IFRAME_STYLE = "border:none;width:100%;height:100%;display:block;";
+var FORWARD_INTERVAL_MS = 15000;
+var MAX_FORWARDS_PER_TICK = 3;
+var WATCHDOG_INTERVAL_MS = 5000;
+function isCheckpointRelay(payload) {
+  return typeof payload === "object" && payload !== null && "state" in payload;
+}
+function isValidHeartbeatRelay(windowStartedAtMs, activeMs, pausedMs) {
+  return typeof windowStartedAtMs === "number" && Number.isFinite(windowStartedAtMs) && Number.isFinite(activeMs) && Number.isFinite(pausedMs) && activeMs >= 0 && pausedMs >= 0;
+}
+function isValidEndReport(report) {
+  if (!report) {
+    return false;
+  }
+  return typeof report.activityData?.activityId === "string" && Number.isFinite(report.scoreData?.correctQuestions) && Number.isFinite(report.scoreData?.totalQuestions) && Number.isFinite(report.timingData?.durationSeconds) && report.scoreData.correctQuestions >= 0 && report.scoreData.totalQuestions >= 0 && report.timingData.durationSeconds >= 0;
+}
+function reconcileSessionTiming(totals, forwardedActiveMs, forwardedPausedMs) {
+  const remainder = {
+    activeSeconds: Math.max(0, totals.activeSeconds - forwardedActiveMs / 1000)
+  };
+  if (totals.inactiveSeconds !== undefined) {
+    remainder.inactiveSeconds = Math.max(0, totals.inactiveSeconds - forwardedPausedMs / 1000);
+  }
+  return remainder;
+}
+function isValidSessionTiming(timing) {
+  if (timing === undefined) {
+    return true;
+  }
+  if (!Number.isFinite(timing.activeSeconds) || timing.activeSeconds < 0) {
+    return false;
+  }
+  return timing.inactiveSeconds === undefined || Number.isFinite(timing.inactiveSeconds) && timing.inactiveSeconds >= 0;
+}
+function isTrackerRelay(type) {
+  return type === "PLAYCADEMY_TIMEBACK_ACTIVITY_START" /* TIMEBACK_ACTIVITY_START */ || type === "PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */ || type === "PLAYCADEMY_TIMEBACK_ACTIVITY_END" /* TIMEBACK_ACTIVITY_END */;
+}
+async function tryStore(operation, label) {
   try {
-    onStateChange?.({
-      status: "opening_popup",
-      message: "Opening authentication window..."
+    await operation();
+  } catch (error) {
+    console.warn(`[Playcademy SDK] embed: resume ${label} failed:`, errorMessage(error));
+  }
+}
+
+class ChildSession {
+  iframe;
+  finished;
+  closed;
+  #options;
+  #bridge;
+  #resolveFinished;
+  #resolveClosed;
+  #settled = false;
+  #torndown = false;
+  #childOrigin = "";
+  #childGameId;
+  #stopHandshake = null;
+  #loadDeadline = null;
+  #watchdogTimer = null;
+  #wasConnected = false;
+  #relayedWindows = new Map;
+  #parentRunId = null;
+  #parentResumeId = null;
+  #forwardTimer = null;
+  #dirtyWindows = new Set;
+  #pendingForwards = new Set;
+  #forwardedActiveMs = 0;
+  #forwardedPausedMs = 0;
+  #checkpointState = null;
+  #hasCheckpoint = false;
+  #childAnnouncedRunId = null;
+  #resumeAccepted = false;
+  #resumeEnvelope;
+  #resumeCleared = false;
+  #storeChain = Promise.resolve();
+  #warnedSettledRelay = false;
+  #sawReady = false;
+  #closedWindows = new Set;
+  #currentWindowKey = null;
+  constructor(options) {
+    this.#options = options;
+    this.#resumeEnvelope = options.resume ?? null;
+    this.#bridge = options.timeback && options.reporter ? { recording: options.timeback, reporter: options.reporter } : null;
+    this.iframe = document.createElement("iframe");
+    this.iframe.style.cssText = EMBED_IFRAME_STYLE;
+    options.container.appendChild(this.iframe);
+    this.#watchdogTimer = setInterval(() => {
+      if (this.iframe.isConnected) {
+        this.#wasConnected = true;
+      } else if (this.#wasConnected) {
+        this.close();
+      }
+    }, WATCHDOG_INTERVAL_MS);
+    this.finished = new Promise((resolve) => {
+      this.#resolveFinished = resolve;
     });
-    const defaults = getOAuthConfig(provider);
-    const config = oauth ? { ...defaults, ...oauth } : defaults;
-    if (!config.clientId) {
-      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
-    }
-    const stateData = options.stateData;
-    const state = await generateOAuthState(stateData);
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: config.clientId,
-      redirect_uri: callbackUrl,
-      state
+    this.closed = new Promise((resolve) => {
+      this.#resolveClosed = resolve;
     });
-    if (config.scope) {
-      params.set("scope", config.scope);
-    }
-    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
-    const popup = openPopupWindow(authUrl, "playcademy-auth");
-    if (!popup || popup.closed) {
-      throw new Error("Popup blocked. Please enable popups and try again.");
+    this.#open();
+  }
+  close() {
+    this.#abandon();
+    this.#teardown();
+  }
+  get checkpoint() {
+    if (!this.#hasCheckpoint) {
+      return null;
     }
-    onStateChange?.({
-      status: "exchanging_token",
-      message: "Waiting for authentication..."
-    });
-    return await waitForServerMessage(popup, onStateChange);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
-    onStateChange?.({
-      status: "error",
-      message: errorMessage,
-      error: error instanceof Error ? error : new Error(errorMessage)
+    return {
+      state: this.#checkpointState,
+      childRunId: this.#childAnnouncedRunId ?? undefined,
+      parentRunId: this.#parentRunId ?? undefined
+    };
+  }
+  #open() {
+    this.#boot().catch((error) => {
+      this.#fail(error instanceof PlaycademyError ? error : new PlaycademyError(`embed.launch() could not launch '${this.#options.slug}': ${errorMessage(error)}`));
     });
-    throw error;
   }
-}
-async function waitForServerMessage(popup, onStateChange) {
-  return new Promise((resolve) => {
-    let resolved = false;
-    function handleMessage(event) {
-      if (event.origin !== globalThis.location.origin) {
+  async#boot() {
+    this.#loadDeadline = setTimeout(() => {
+      this.#fail(new PlaycademyError(`Child game '${this.#options.slug}' did not become ready within ${HANDSHAKE_MAX_DURATION_MS / 1000}s.`));
+    }, HANDSHAKE_MAX_DURATION_MS);
+    const store = this.#options.resumeStore;
+    if (store) {
+      try {
+        this.#resumeEnvelope = await store.load() ?? null;
+      } catch (error) {
+        console.warn("[Playcademy SDK] embed: resume load failed; starting fresh:", errorMessage(error));
+      }
+    }
+    if (this.#torndown) {
+      return;
+    }
+    const envelope = this.#resumeEnvelope;
+    const { childUrl, payload } = await this.#options.resolveTarget(envelope ? { state: envelope.state, childRunId: envelope.childRunId } : undefined);
+    if (this.#torndown) {
+      return;
+    }
+    this.#childOrigin = new URL(childUrl).origin;
+    this.#childGameId = payload.gameId;
+    window.addEventListener("message", this.#onChildMessage);
+    messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, this.#onTokenRefresh);
+    messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, this.#onLauncherPause);
+    messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, this.#onLauncherResume);
+    this.iframe.addEventListener("load", () => {
+      this.#clearLoadDeadline();
+      if (this.#torndown) {
         return;
       }
-      const data = event.data;
-      if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
-        resolved = true;
-        window.removeEventListener("message", handleMessage);
-        if (data.authenticated && data.user) {
-          onStateChange?.({
-            status: "complete",
-            message: "Authentication successful"
-          });
-          resolve({
-            success: true,
-            user: data.user
-          });
-        } else {
-          const error = new Error(data.error || "Authentication failed");
-          onStateChange?.({
-            status: "error",
-            message: error.message,
-            error
-          });
-          resolve({
-            success: false,
-            error
-          });
+      this.#stopHandshake = beginInitHandshake({
+        iframe: this.iframe,
+        origin: this.#childOrigin,
+        payload,
+        onTimeout: () => {
+          this.#fail(new PlaycademyError(`Child game '${this.#options.slug}' did not answer INIT within ${HANDSHAKE_MAX_DURATION_MS / 1000}s.`));
+        },
+        onSendError: (error) => {
+          this.#fail(new PlaycademyError(`Child game '${this.#options.slug}' INIT could not be posted: ${errorMessage(error)}. The payload (including any resume state) must be structured-cloneable.`));
         }
-      }
-    }
-    window.addEventListener("message", handleMessage);
-    const checkClosed = setInterval(() => {
-      if (popup.closed && !resolved) {
-        clearInterval(checkClosed);
-        window.removeEventListener("message", handleMessage);
-        const error = new Error("Authentication cancelled");
-        onStateChange?.({
-          status: "error",
-          message: error.message,
-          error
-        });
-        resolve({
-          success: false,
-          error
-        });
-      }
-    }, 500);
-    setTimeout(() => {
-      if (!resolved) {
-        window.removeEventListener("message", handleMessage);
-        clearInterval(checkClosed);
-        const error = new Error("Authentication timeout");
-        onStateChange?.({
-          status: "error",
-          message: error.message,
-          error
-        });
-        resolve({
-          success: false,
-          error
+      });
+    }, { once: true });
+    this.iframe.src = childUrl;
+  }
+  #clearLoadDeadline() {
+    if (this.#loadDeadline) {
+      clearTimeout(this.#loadDeadline);
+      this.#loadDeadline = null;
+    }
+  }
+  #teardown() {
+    if (this.#torndown) {
+      return;
+    }
+    this.#torndown = true;
+    this.#stopHandshake?.();
+    this.#stopHandshake = null;
+    this.#clearLoadDeadline();
+    if (this.#forwardTimer) {
+      clearInterval(this.#forwardTimer);
+      this.#forwardTimer = null;
+    }
+    if (this.#watchdogTimer) {
+      clearInterval(this.#watchdogTimer);
+      this.#watchdogTimer = null;
+    }
+    this.#markOpenWindowFlushable();
+    this.#forwardDirtyWindows();
+    window.removeEventListener("message", this.#onChildMessage);
+    window.removeEventListener("pagehide", this.#onPageHide);
+    messaging.unlisten("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, this.#onTokenRefresh);
+    messaging.unlisten("PLAYCADEMY_PAUSE" /* PAUSE */, this.#onLauncherPause);
+    messaging.unlisten("PLAYCADEMY_RESUME" /* RESUME */, this.#onLauncherResume);
+    this.iframe.remove();
+    this.#resolveClosed();
+  }
+  #fail(error) {
+    if (!this.#settled) {
+      this.#settled = true;
+      this.#resolveFinished({ status: "failed", error });
+    }
+    this.#teardown();
+  }
+  #abandon() {
+    if (this.#settled) {
+      return;
+    }
+    this.#settled = true;
+    const activity = {
+      status: "abandoned",
+      timing: this.#relayedTiming()
+    };
+    const resume = this.checkpoint;
+    if (resume) {
+      activity.resume = resume;
+    }
+    this.#resolveFinished(activity);
+  }
+  #relayedTiming() {
+    let activeMs = 0;
+    let pausedMs = 0;
+    for (const snapshot of this.#relayedWindows.values()) {
+      activeMs += snapshot.activeMs;
+      pausedMs += snapshot.pausedMs;
+    }
+    return {
+      activeSeconds: Math.round(activeMs / 1000),
+      inactiveSeconds: Math.round(pausedMs / 1000)
+    };
+  }
+  #complete(childReport) {
+    if (this.#settled) {
+      return;
+    }
+    this.#settled = true;
+    this.#clearResume();
+    let endMemo = null;
+    this.#resolveFinished({
+      status: "completed",
+      correct: childReport.scoreData.correctQuestions,
+      total: childReport.scoreData.totalQuestions,
+      timing: this.#completedTiming(childReport),
+      childReport,
+      end: (scores) => {
+        if (!this.#bridge) {
+          return Promise.reject(new PlaycademyError("end() requires the timeback option at launch; this launch was a pure UX embed."));
+        }
+        endMemo ??= this.#postCompletion(this.#bridge, childReport, scores).catch((error) => {
+          endMemo = null;
+          throw error;
         });
+        return endMemo;
       }
-    }, 5 * 60 * 1000);
-  });
-}
-
-// src/core/auth/flows/redirect.ts
-async function initiateRedirectFlow(options) {
-  const { provider, callbackUrl, onStateChange, oauth } = options;
-  try {
-    onStateChange?.({
-      status: "opening_popup",
-      message: "Redirecting to authentication provider..."
     });
-    const defaults = getOAuthConfig(provider);
-    const config = oauth ? { ...defaults, ...oauth } : defaults;
-    if (!config.clientId) {
-      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+  }
+  #completedTiming(childReport) {
+    if (this.#relayedWindows.size > 0) {
+      return this.#relayedTiming();
     }
-    const stateData = options.stateData;
-    const state = await generateOAuthState(stateData);
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: config.clientId,
-      redirect_uri: callbackUrl,
-      state
-    });
-    if (config.scope) {
-      params.set("scope", config.scope);
+    return {
+      activeSeconds: childReport.timingData.durationSeconds,
+      inactiveSeconds: childReport.sessionTimingData?.inactiveSeconds
+    };
+  }
+  #ensureBridgeRun() {
+    if (!this.#bridge || this.#parentRunId) {
+      return;
     }
-    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
-    globalThis.location.href = authUrl;
-    return new Promise(() => {});
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Authentication failed";
-    onStateChange?.({
-      status: "error",
-      message: errorMessage,
-      error: error instanceof Error ? error : new Error(errorMessage)
-    });
-    throw error;
+    this.#parentRunId = this.#resumeAccepted && this.#resumeEnvelope?.parentRunId ? this.#resumeEnvelope.parentRunId : crypto.randomUUID();
+    this.#parentResumeId = crypto.randomUUID();
+    if (this.#torndown) {
+      return;
+    }
+    this.#forwardTimer ??= setInterval(() => this.#forwardDirtyWindows(MAX_FORWARDS_PER_TICK), FORWARD_INTERVAL_MS);
+    window.addEventListener("pagehide", this.#onPageHide);
   }
-}
-
-// src/core/auth/flows/unified.ts
-async function initiateUnifiedFlow(options) {
-  const { mode = "auto" } = options;
-  let effectiveMode;
-  if (mode === "auto") {
-    effectiveMode = isInIframe() ? "popup" : "redirect";
-  } else {
-    effectiveMode = mode;
+  #forwardDirtyWindows(limit = Number.POSITIVE_INFINITY) {
+    const bridge = this.#bridge;
+    if (!bridge) {
+      return;
+    }
+    this.#drainDirtyWindows(limit, (body, windowStartedAtMs) => {
+      const forward = bridge.reporter.postHeartbeat(body).then(() => {
+        this.#forwardedActiveMs += body.timingData.activeMs;
+        this.#forwardedPausedMs += body.timingData.pausedMs;
+      }).catch((error) => {
+        this.#dirtyWindows.add(windowStartedAtMs);
+        console.warn("[Playcademy SDK] embed heartbeat forward failed:", errorMessage(error));
+      }).finally(() => {
+        this.#pendingForwards.delete(forward);
+      });
+      this.#pendingForwards.add(forward);
+    });
   }
-  switch (effectiveMode) {
-    case "popup": {
-      return initiatePopupFlow(options);
+  #onPageHide = () => {
+    const bridge = this.#bridge;
+    if (!bridge) {
+      return;
     }
-    case "redirect": {
-      return initiateRedirectFlow(options);
+    this.#markOpenWindowFlushable();
+    this.#drainDirtyWindows(Number.POSITIVE_INFINITY, (body) => bridge.reporter.postHeartbeatKeepalive(body));
+  };
+  #markOpenWindowFlushable() {
+    const key = this.#currentWindowKey;
+    if (key === null) {
+      return;
     }
-    default: {
-      throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
+    const snapshot = this.#relayedWindows.get(key);
+    this.#currentWindowKey = null;
+    this.#closedWindows.add(key);
+    if (this.#bridge && snapshot && (snapshot.activeMs > 0 || snapshot.pausedMs > 0)) {
+      this.#dirtyWindows.add(key);
     }
   }
-}
-
-// src/core/auth/login.ts
-async function login2(client, options) {
-  try {
-    let stateData = options.stateData;
-    if (!stateData) {
-      try {
-        const currentUser = await client.users.me();
-        if (currentUser?.id) {
-          stateData = { playcademy_user_id: currentUser.id };
-        }
-      } catch {
-        log.debug("[Playcademy SDK] No current user available for state data");
+  #drainDirtyWindows(limit, post) {
+    if (!this.#bridge || !this.#parentRunId || this.#dirtyWindows.size === 0) {
+      return;
+    }
+    const recording = this.#bridge.recording;
+    const runId = this.#parentRunId;
+    const oldestFirst = [...this.#dirtyWindows].toSorted((a, b) => a - b).slice(0, limit);
+    for (const windowStartedAtMs of oldestFirst) {
+      const snapshot = this.#relayedWindows.get(windowStartedAtMs);
+      this.#dirtyWindows.delete(windowStartedAtMs);
+      if (snapshot) {
+        post({
+          runId,
+          resumeId: this.#parentResumeId ?? undefined,
+          activityData: recording,
+          timingData: { activeMs: snapshot.activeMs, pausedMs: snapshot.pausedMs },
+          windowStartedAtMs
+        }, windowStartedAtMs);
       }
     }
-    log.debug("[Playcademy SDK] Starting OAuth login", {
-      provider: options.provider,
-      mode: options.mode || "auto",
-      callbackUrl: options.callbackUrl,
-      hasStateData: Boolean(stateData)
+  }
+  async#postCompletion(bridge, childReport, scores) {
+    this.#ensureBridgeRun();
+    this.#forwardDirtyWindows();
+    await Promise.allSettled(this.#pendingForwards);
+    this.#dirtyWindows.clear();
+    return bridge.reporter.postEndActivity({
+      runId: this.#parentRunId ?? undefined,
+      resumeId: this.#parentResumeId ?? undefined,
+      activityData: bridge.recording,
+      scoreData: {
+        correctQuestions: scores.correctQuestions,
+        totalQuestions: scores.totalQuestions
+      },
+      timingData: {
+        durationSeconds: childReport.timingData.durationSeconds
+      },
+      sessionTimingData: reconcileSessionTiming(this.#reconciliationTotals(childReport.sessionTimingData), this.#forwardedActiveMs, this.#forwardedPausedMs),
+      xpEarned: scores.xpAwarded,
+      masteredUnits: scores.masteredUnits,
+      masteredUnitsAbsolute: scores.masteredUnitsAbsolute,
+      extensions: {
+        ...childReport.extensions,
+        ...scores.extensions,
+        childGameId: this.#childGameId,
+        childRunId: childReport.runId,
+        childActivityId: childReport.activityData.activityId,
+        childXpSuggested: childReport.xpEarned
+      }
     });
-    const optionsWithState = {
-      ...options,
-      stateData
-    };
-    const result = await initiateUnifiedFlow(optionsWithState);
-    if (result.success && result.user) {
-      log.debug("[Playcademy SDK] OAuth login successful", {
-        userId: result.user.sub
-      });
+  }
+  #reconciliationTotals(reported) {
+    if (reported) {
+      return reported;
     }
-    return result;
-  } catch (error) {
-    log.error("[Playcademy SDK] OAuth login failed", { error });
-    const authError = error instanceof Error ? error : new Error("Authentication failed");
+    const relayed = this.#relayedTiming();
     return {
-      success: false,
-      error: authError
+      activeSeconds: relayed.activeSeconds,
+      inactiveSeconds: relayed.inactiveSeconds
     };
   }
-}
-
-// src/namespaces/game/identity.ts
-function createIdentityNamespace(client) {
-  return {
-    connect: (options) => {
-      if (client.mode === "demo") {
-        throw new PlaycademyError("identity.connect() is not available in demo mode. Use platform or standalone mode for OAuth flows.");
+  #onChildMessage = (event) => {
+    if (!isTrustedIframeMessage(event, this.iframe.contentWindow, this.#childOrigin)) {
+      return;
+    }
+    const data = event.data;
+    if (!data) {
+      return;
+    }
+    const type = data.type;
+    if (type === "PLAYCADEMY_READY" /* READY */) {
+      this.#sawReady = true;
+      this.#stopHandshake?.();
+      this.#stopHandshake = null;
+      return;
+    }
+    if (type === "PLAYCADEMY_INIT_ERROR" /* INIT_ERROR */) {
+      const payload = data.payload;
+      const reason = typeof payload?.reason === "string" ? payload.reason : "Child game reported an initialization error";
+      if (this.#sawReady) {
+        console.warn(`[Playcademy SDK] embed: child '${this.#options.slug}' reloaded mid-lesson and could not re-initialize (${reason}); abandoning the launch. A stored checkpoint resumes it on the next launch.`);
+        this.#abandon();
+        this.#teardown();
+        return;
       }
-      return login2(client, options);
-    },
-    _getContext: () => ({
-      isInIframe: client["authContext"]?.isInIframe ?? false
-    })
+      this.#fail(new PlaycademyError(`Child game '${this.#options.slug}' failed to initialize: ${reason}`));
+      return;
+    }
+    if (this.#settled && isTrackerRelay(type)) {
+      if (!this.#warnedSettledRelay) {
+        this.#warnedSettledRelay = true;
+        console.warn("[Playcademy SDK] embed: this launch already reported; ignoring tracker relays from the child. One report per launch: launch again for another lesson.");
+      }
+      return;
+    }
+    if (type === "PLAYCADEMY_TIMEBACK_ACTIVITY_START" /* TIMEBACK_ACTIVITY_START */) {
+      this.#onActivityStartRelay(data.payload);
+      return;
+    }
+    if (type === "PLAYCADEMY_CHECKPOINT" /* CHECKPOINT */) {
+      this.#onCheckpointRelay(data.payload);
+      return;
+    }
+    if (type === "PLAYCADEMY_EXIT" /* EXIT */) {
+      this.#abandon();
+      this.#teardown();
+      return;
+    }
+    if (type === "PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */) {
+      this.#onHeartbeatRelay(data.payload);
+      return;
+    }
+    if (type === "PLAYCADEMY_TIMEBACK_ACTIVITY_END" /* TIMEBACK_ACTIVITY_END */) {
+      this.#onEndRelay(data.payload);
+    }
   };
-}
-// src/namespaces/game/runtime.ts
-function createRuntimeNamespace(client) {
-  const eventListeners = new Map;
-  function trackListener(eventType, handler) {
-    if (!eventListeners.has(eventType)) {
-      eventListeners.set(eventType, new Set);
+  #onActivityStartRelay(payload) {
+    const announced = payload?.runId;
+    if (typeof announced === "string") {
+      this.#childAnnouncedRunId = announced;
+      if (announced === this.#resumeEnvelope?.childRunId) {
+        this.#resumeAccepted = true;
+      }
     }
-    eventListeners.get(eventType).add(handler);
+    this.#ensureBridgeRun();
+    this.#persistCheckpoint();
   }
-  function untrackListener(eventType, handler) {
-    const listeners = eventListeners.get(eventType);
-    if (listeners) {
-      listeners.delete(handler);
-      if (listeners.size === 0) {
-        eventListeners.delete(eventType);
-      }
+  #onCheckpointRelay(payload) {
+    if (isCheckpointRelay(payload)) {
+      this.#checkpointState = payload.state;
+      this.#hasCheckpoint = true;
+      this.#persistCheckpoint();
     }
   }
-  if (typeof globalThis.window !== "undefined" && globalThis.self !== window.top) {
-    let keyListener = function(event) {
-      if (keySet.has(event.key?.toLowerCase() ?? "") || keySet.has(event.code?.toLowerCase() ?? "")) {
-        messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
-          key: event.key,
-          code: event.code,
-          type: event.type
-        });
+  #persistCheckpoint() {
+    const store = this.#options.resumeStore;
+    if (!store || this.#resumeCleared) {
+      return;
+    }
+    const envelope = this.checkpoint;
+    if (!envelope) {
+      return;
+    }
+    this.#enqueueStore(() => store.save(envelope), "save");
+  }
+  #clearResume() {
+    this.#resumeCleared = true;
+    const store = this.#options.resumeStore;
+    if (!store) {
+      return;
+    }
+    this.#enqueueStore(() => store.clear(), "clear");
+  }
+  #enqueueStore(operation, label) {
+    this.#storeChain = this.#storeChain.then(() => tryStore(operation, label));
+  }
+  #onHeartbeatRelay(payload) {
+    const heartbeat = payload;
+    const windowStartedAtMs = heartbeat?.windowStartedAtMs;
+    const activeMs = heartbeat?.timingData?.activeMs ?? 0;
+    const pausedMs = heartbeat?.timingData?.pausedMs ?? 0;
+    if (!isValidHeartbeatRelay(windowStartedAtMs, activeMs, pausedMs)) {
+      return;
+    }
+    this.#relayedWindows.set(windowStartedAtMs, { activeMs, pausedMs });
+    const closed = heartbeat?.windowClosed === true;
+    if (closed) {
+      this.#closedWindows.add(windowStartedAtMs);
+      if (this.#currentWindowKey === windowStartedAtMs) {
+        this.#currentWindowKey = null;
       }
-    };
-    const playcademyConfig = globalThis.PLAYCADEMY;
-    const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
-    const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
-    globalThis.addEventListener("keydown", keyListener);
-    globalThis.addEventListener("keyup", keyListener);
-    trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, () => {
-      globalThis.removeEventListener("keydown", keyListener);
-      globalThis.removeEventListener("keyup", keyListener);
-    });
+    } else {
+      const superseded = this.#currentWindowKey;
+      if (superseded !== null && superseded !== windowStartedAtMs && !this.#closedWindows.has(superseded)) {
+        this.#closedWindows.add(superseded);
+        if (this.#bridge) {
+          this.#dirtyWindows.add(superseded);
+        }
+      }
+      this.#currentWindowKey = windowStartedAtMs;
+    }
+    if (this.#bridge) {
+      this.#ensureBridgeRun();
+      if (closed) {
+        this.#dirtyWindows.add(windowStartedAtMs);
+      }
+    }
   }
-  return {
-    exit: () => {
-      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
-    },
-    onInit: (handler) => {
-      messaging.listen("PLAYCADEMY_INIT" /* INIT */, handler);
-      trackListener("PLAYCADEMY_INIT" /* INIT */, handler);
-    },
-    onTokenRefresh: (handler) => {
-      messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
-      trackListener("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
-    },
-    onPause: (handler) => {
-      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
-      trackListener("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
-    },
-    onResume: (handler) => {
-      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, handler);
-      trackListener("PLAYCADEMY_RESUME" /* RESUME */, handler);
-    },
-    onForceExit: (handler) => {
-      messaging.listen("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
-      trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
-    },
-    onOverlay: (handler) => {
-      messaging.listen("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
-      trackListener("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
-    },
-    ready: () => {
-      messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
-    },
-    sendTelemetry: (data) => {
-      messaging.send("PLAYCADEMY_TELEMETRY" /* TELEMETRY */, data);
-    },
-    removeListener: (eventType, handler) => {
-      messaging.unlisten(eventType, handler);
-      untrackListener(eventType, handler);
-    },
-    removeAllListeners: () => {
-      for (const [eventType, handlers] of eventListeners.entries()) {
-        for (const handler of handlers) {
-          messaging.unlisten(eventType, handler);
-        }
-      }
-      eventListeners.clear();
-    },
-    getListenerCounts: () => {
-      const counts = {};
-      for (const [eventType, handlers] of eventListeners.entries()) {
-        counts[eventType] = handlers.size;
-      }
-      return counts;
-    },
-    assets: createAssetsNamespace(client)
-  };
-}
-function createAssetsNamespace(client) {
-  async function fetchAsset(path, options) {
-    const gameUrl = client["initPayload"]?.gameUrl;
-    if (!gameUrl) {
-      const relativePath = path.startsWith("./") ? path : `./${path}`;
-      return fetch(relativePath, options);
+  #onEndRelay(payload) {
+    const report = payload;
+    if (!isValidEndReport(report)) {
+      console.warn("[Playcademy SDK] embed: ignoring malformed end-activity relay from the child");
+      return;
     }
-    const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-    return fetch(`${gameUrl}${cleanPath}`, options);
+    this.#complete(isValidSessionTiming(report.sessionTimingData) ? report : { ...report, sessionTimingData: undefined });
   }
-  return {
-    url(pathOrStrings, ...values) {
-      const gameUrl = client["initPayload"]?.gameUrl;
-      let path;
-      if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
-        const strings = pathOrStrings;
-        path = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
-      } else {
-        path = pathOrStrings;
-      }
-      if (!gameUrl) {
-        return path.startsWith("./") ? path : `./${path}`;
-      }
-      const cleanPath = path.startsWith("./") ? path.slice(2) : path;
-      return `${gameUrl}${cleanPath}`;
-    },
-    fetch: fetchAsset,
-    json: async (path) => {
-      const response = await fetchAsset(path);
-      return await response.json();
-    },
-    blob: async (path) => {
-      const response = await fetchAsset(path);
-      return response.blob();
-    },
-    text: async (path) => {
-      const response = await fetchAsset(path);
-      return response.text();
-    },
-    arrayBuffer: async (path) => {
-      const response = await fetchAsset(path);
-      return response.arrayBuffer();
-    }
-  };
-}
-// src/namespaces/game/scores.ts
-function createScoresNamespace(client) {
-  return {
-    submit: async (score, metadata) => {
-      const gameId = client["_ensureGameId"]();
-      return client["request"](`/games/${gameId}/scores`, "POST", {
-        body: {
-          score,
-          metadata
-        }
+  #onTokenRefresh = (payload) => {
+    if (this.iframe.contentWindow) {
+      messaging.send("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, payload, {
+        target: this.iframe.contentWindow,
+        origin: this.#childOrigin
       });
     }
   };
-}
-// ../constants/src/platform.ts
-var PLAYCADEMY_BROWSER_TIME_ZONE_HEADER = "x-playcademy-browser-time-zone";
-// ../constants/src/timeback.ts
-var TIMEBACK_ROUTES = {
-  END_ACTIVITY: "/integrations/timeback/end-activity",
-  GET_XP: "/integrations/timeback/xp",
-  GET_MASTERY: "/integrations/timeback/mastery",
-  GET_HIGHEST_GRADE_MASTERED: "/integrations/timeback/highest-grade-mastered",
-  HEARTBEAT: "/integrations/timeback/heartbeat",
-  ADVANCE_COURSE: "/integrations/timeback/advance-course",
-  UNENROLL_COURSE: "/integrations/timeback/unenroll-course",
-  ASSESSMENTS: "/integrations/timeback/assessments"
-};
-var TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
-var TIMEBACK_SUBJECTS = [
-  "Reading",
-  "Language",
-  "Vocabulary",
-  "Social Studies",
-  "Writing",
-  "Science",
-  "FastMath",
-  "Math",
-  "None"
-];
-var ASSESSMENT_PURPOSES = ["end_of_course", "diagnostic"];
-var TIMEBACK_GAME_METRIC_DECIMAL_PLACES = {
-  xp: 1,
-  mastery: 0,
-  score: 2
-};
-var TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE = {
-  xp: 0.5 / 10 ** TIMEBACK_GAME_METRIC_DECIMAL_PLACES.xp,
-  mastery: 0,
-  time: 60,
-  score: 0.5 / 10 ** TIMEBACK_GAME_METRIC_DECIMAL_PLACES.score
-};
-// src/core/guards.ts
-var VALID_GRADES = TIMEBACK_GRADES;
-var VALID_SUBJECTS = TIMEBACK_SUBJECTS;
-function isValidGrade(value) {
-  return typeof value === "number" && Number.isInteger(value) && VALID_GRADES.includes(value);
-}
-function isValidSubject(value) {
-  return typeof value === "string" && VALID_SUBJECTS.includes(value);
-}
-function isAssessmentPurpose(value) {
-  return typeof value === "string" && ASSESSMENT_PURPOSES.includes(value);
-}
-
-// src/core/cache/ttl-cache.ts
-function createTTLCache(options) {
-  const cache = new Map;
-  const { ttl: defaultTTL, keyPrefix = "", onClear } = options;
-  async function get(key, loader, config) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const now = Date.now();
-    const effectiveTTL = config?.ttl !== undefined ? config.ttl : defaultTTL;
-    const force = config?.force || false;
-    const skipCache = config?.skipCache || false;
-    if (effectiveTTL === 0 || skipCache) {
-      return loader();
-    }
-    if (!force) {
-      const cached = cache.get(fullKey);
-      if (cached && cached.expiresAt > now) {
-        return cached.value;
-      }
-    }
-    const promise = loader().catch((error) => {
-      cache.delete(fullKey);
-      throw error;
-    });
-    cache.set(fullKey, {
-      value: promise,
-      expiresAt: now + effectiveTTL
-    });
-    return promise;
-  }
-  function clear(key) {
-    if (key === undefined) {
-      cache.clear();
-      onClear?.();
-    } else {
-      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-      cache.delete(fullKey);
-    }
-  }
-  function size() {
-    return cache.size;
-  }
-  function prune() {
-    const now = Date.now();
-    for (const [key, entry] of cache.entries()) {
-      if (entry.expiresAt <= now) {
-        cache.delete(key);
-      }
-    }
-  }
-  function getKeys() {
-    const keys = [];
-    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
-    for (const fullKey of cache.keys()) {
-      keys.push(fullKey.substring(prefixLen));
-    }
-    return keys;
-  }
-  function has(key) {
-    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
-    const cached = cache.get(fullKey);
-    if (!cached) {
-      return false;
-    }
-    const now = Date.now();
-    if (cached.expiresAt <= now) {
-      cache.delete(fullKey);
-      return false;
+  #onLauncherPause = () => {
+    this.#forwardControlToChild("PLAYCADEMY_PAUSE" /* PAUSE */);
+  };
+  #onLauncherResume = () => {
+    this.#forwardControlToChild("PLAYCADEMY_RESUME" /* RESUME */);
+  };
+  #forwardControlToChild(type) {
+    if (this.iframe.contentWindow) {
+      messaging.send(type, undefined, {
+        target: this.iframe.contentWindow,
+        origin: this.#childOrigin
+      });
     }
-    return true;
   }
-  return { get, clear, size, prune, getKeys, has };
 }
 
 // ../utils/src/uuid.ts
@@ -1250,6 +1558,25 @@ function isValidUUID(value) {
   return UUID_REGEX.test(value);
 }
 
+// src/core/timeback/keepalive.ts
+async function sendHeartbeatKeepalive(client, body) {
+  try {
+    const url = `${client["getGameBackendUrl"]()}${TIMEBACK_ROUTES.HEARTBEAT}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...client["authStrategy"].getHeaders()
+      },
+      body: JSON.stringify(body),
+      keepalive: true
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 // src/core/timeback/activity-tracker.ts
 var DEFAULT_PAUSED_HEARTBEAT_TIMEOUT_MS = 10 * 60 * 1000;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 15000;
@@ -1262,6 +1589,9 @@ var END_ACTIVITY_RETRY_POLICY = {
 };
 var USER_ACTIVITY_EVENTS = ["keydown", "pointerdown", "pointermove", "wheel"];
 var USER_ACTIVITY_LISTENER_OPTIONS = { capture: true };
+function jsonProjection(value) {
+  return JSON.parse(JSON.stringify(value));
+}
 function normalizeDelayMs(value, defaultValue, allowZero = true) {
   if (value === Infinity) {
     return Infinity;
@@ -1321,6 +1651,17 @@ function queueHeartbeatFlush(activity, timing, flush) {
   }
   return activity.flushInFlight;
 }
+function queueClosedWindowRelay(activity, timing, body) {
+  return queueHeartbeatFlush(activity, timing, async () => {
+    try {
+      messaging.send("PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */, {
+        ...body,
+        windowClosed: true
+      });
+    } catch {}
+    return false;
+  });
+}
 function stopHeartbeatInterval(activity) {
   if (activity.heartbeatIntervalId === null) {
     return;
@@ -1369,6 +1710,18 @@ function createTimebackActivityTracker(client) {
   let lastRelayedActiveMs = -1;
   let lastRelayedPausedMs = -1;
   let lastRelayedWindowStart = -1;
+  function relaysToParent() {
+    return client.parent !== null;
+  }
+  let resumeRunIdSpent = false;
+  function adoptResumedRunId() {
+    if (resumeRunIdSpent) {
+      return;
+    }
+    resumeRunIdSpent = true;
+    const resumeRunId = client["initPayload"]?.parent?.resumeRunId;
+    return typeof resumeRunId === "string" && isValidUUID(resumeRunId) ? resumeRunId : undefined;
+  }
   function startHeartbeatInterval(activity) {
     if (activity.heartbeatIntervalMs === Infinity || activity.heartbeatIntervalId !== null) {
       return;
@@ -1546,6 +1899,7 @@ function createTimebackActivityTracker(client) {
       if (!activity) {
         return;
       }
+      applyOverdueInactivity();
       const timing = computeWindowSnapshot(activity);
       if (timing.activeMs === lastRelayedActiveMs && timing.pausedMs === lastRelayedPausedMs && timing.windowStartedAtMs === lastRelayedWindowStart) {
         return;
@@ -1607,223 +1961,811 @@ function createTimebackActivityTracker(client) {
     if (timing.activeMs === 0 && timing.pausedMs === 0) {
       return;
     }
-    const body = buildHeartbeatBody(trackedActivity, timing, isFinal);
-    await queueHeartbeatFlush(trackedActivity, timing, async () => {
-      try {
-        await client["requestGameBackend"](TIMEBACK_ROUTES.HEARTBEAT, "POST", body, undefined, { retryPolicy: HEARTBEAT_RETRY_POLICY });
-        return true;
-      } catch {
-        return false;
+    const body = buildHeartbeatBody(trackedActivity, timing, isFinal);
+    if (relaysToParent()) {
+      await queueClosedWindowRelay(trackedActivity, timing, body);
+      return;
+    }
+    await queueHeartbeatFlush(trackedActivity, timing, async () => {
+      try {
+        await client["requestGameBackend"](TIMEBACK_ROUTES.HEARTBEAT, "POST", body, undefined, { retryPolicy: HEARTBEAT_RETRY_POLICY });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+  function flushFinalHeartbeatBeacon() {
+    applyOverdueInactivity();
+    const activity = currentActivity;
+    if (!activity) {
+      return;
+    }
+    const timing = computeWindowAndReset(activity);
+    if (timing.activeMs === 0 && timing.pausedMs === 0) {
+      return;
+    }
+    const body = buildHeartbeatBody(activity, timing, true);
+    stopRelayInterval();
+    if (relaysToParent()) {
+      queueClosedWindowRelay(activity, timing, body);
+      return;
+    }
+    try {
+      messaging.send("PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */, body);
+    } catch {}
+    if (!client["initPayload"]?.hasHeartbeatRelay) {
+      queueHeartbeatFlush(activity, timing, () => sendHeartbeatKeepalive(client, body));
+    }
+  }
+  function handlePageHide() {
+    flushFinalHeartbeatBeacon();
+  }
+  function cleanupListeners() {
+    if (boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", boundVisibilityHandler);
+      boundVisibilityHandler = null;
+    }
+    if (boundUserInteractionHandler && typeof document !== "undefined") {
+      for (const eventName of USER_ACTIVITY_EVENTS) {
+        document.removeEventListener(eventName, boundUserInteractionHandler, USER_ACTIVITY_LISTENER_OPTIONS);
+      }
+      boundUserInteractionHandler = null;
+    }
+    if (boundShellPauseHandler) {
+      messaging.unlisten("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
+      boundShellPauseHandler = null;
+    }
+    if (boundShellResumeHandler) {
+      messaging.unlisten("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
+      boundShellResumeHandler = null;
+    }
+    if (boundPageHideHandler && typeof globalThis.window !== "undefined") {
+      globalThis.window.removeEventListener("pagehide", boundPageHideHandler);
+      boundPageHideHandler = null;
+    }
+    if (currentActivity) {
+      clearInactivityTimeout(currentActivity);
+      clearPausedHeartbeatTimeout(currentActivity);
+    }
+    if (currentActivity?.heartbeatIntervalId != null) {
+      stopHeartbeatInterval(currentActivity);
+    }
+    stopRelayInterval();
+  }
+  return {
+    currentRunId() {
+      return currentActivity?.runId;
+    },
+    isActivityManuallyPaused() {
+      return currentActivity?.pauseReasons.has("manual") ?? false;
+    },
+    startActivity(rawMetadata, options) {
+      if (hasLiveSession(client)) {
+        throw new PlaycademyError("startActivity() is unavailable while an embedded child session is live: the child owns the clock, and a second clock would double-count the lesson. Await the session's finished (or close() it) first.");
+      }
+      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.`);
+      }
+      const metadata = jsonProjection(rawMetadata);
+      cleanupListeners();
+      const now = Date.now();
+      const resumedRunId = adoptResumedRunId();
+      const runId = options?.runId ?? resumedRunId ?? 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,
+        resumeId: crypto.randomUUID(),
+        startTime: now,
+        metadata,
+        pausedTime: 0,
+        pauseStartTime: null,
+        pauseReasons: new Set,
+        pausedHeartbeatTimeoutId: null,
+        pausedHeartbeatTimedOut: false,
+        pausedHeartbeatTimeoutMs,
+        windowStartTime: now,
+        windowPausedAtStart: 0,
+        heartbeatIntervalId: null,
+        heartbeatIntervalMs,
+        inactivityTimeoutId: null,
+        inactivityTimeoutMs,
+        inactivityTimerStartedAt: null,
+        remainingInactivityMs: inactivityTimeoutMs,
+        flushInFlight: null,
+        totalPersistedActiveMs: 0,
+        totalPersistedPausedMs: 0
+      };
+      if (typeof document !== "undefined") {
+        boundVisibilityHandler = handleVisibilityChange;
+        document.addEventListener("visibilitychange", boundVisibilityHandler);
+        boundUserInteractionHandler = handleUserInteraction;
+        for (const eventName of USER_ACTIVITY_EVENTS) {
+          document.addEventListener(eventName, boundUserInteractionHandler, USER_ACTIVITY_LISTENER_OPTIONS);
+        }
+        if (document.visibilityState === "hidden") {
+          handleVisibilityChange();
+        }
+      }
+      startHeartbeatInterval(currentActivity);
+      startRelayInterval();
+      if (typeof globalThis.window !== "undefined") {
+        boundPageHideHandler = handlePageHide;
+        globalThis.window.addEventListener("pagehide", boundPageHideHandler);
+      }
+      boundShellPauseHandler = handleShellPause;
+      boundShellResumeHandler = handleShellResume;
+      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
+      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
+      syncInactivityTracking();
+      if (relaysToParent()) {
+        messaging.send("PLAYCADEMY_TIMEBACK_ACTIVITY_START" /* TIMEBACK_ACTIVITY_START */, {
+          runId,
+          resumeId: currentActivity.resumeId,
+          activityData: metadata
+        });
+      }
+      return { runId };
+    },
+    pauseActivity() {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before pauseActivity().");
+      }
+      if (currentActivity.pauseReasons.has("manual")) {
+        throw new Error("Activity is already paused.");
+      }
+      addPauseReason("manual");
+    },
+    resumeActivity() {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before resumeActivity().");
+      }
+      if (!currentActivity.pauseReasons.has("manual")) {
+        throw new Error("Activity is not paused.");
+      }
+      if (hasLiveSession(client)) {
+        throw new PlaycademyError("resumeActivity() is unavailable while an embedded child session is live: the child owns the clock, and resuming this game's own clock would double-count the lesson. Resume after the session finishes.");
+      }
+      removePauseReason("manual");
+    },
+    async endActivity(rawData) {
+      if (!currentActivity) {
+        throw new Error("No activity in progress. Call startActivity() before endActivity().");
+      }
+      const data = jsonProjection(rawData);
+      if (!relaysToParent() && typeof data.xpAwarded !== "number") {
+        throw new Error("endActivity() requires xpAwarded when reporting directly. It is optional only in child mode, where the parent game decides the award.");
+      }
+      const activity = currentActivity;
+      applyOverdueInactivity();
+      cleanupListeners();
+      await flushHeartbeat(true);
+      if (activity.pauseStartTime !== null) {
+        activity.pausedTime += Date.now() - activity.pauseStartTime;
+        activity.pauseStartTime = null;
+      }
+      const endTime = Date.now();
+      const totalElapsed = endTime - activity.startTime;
+      const activeTime = Math.max(0, totalElapsed - activity.pausedTime);
+      const durationSeconds = Math.floor(activeTime / 1000);
+      const unreportedActiveMs = Math.max(0, activeTime - activity.totalPersistedActiveMs);
+      const unreportedPausedMs = Math.max(0, activity.pausedTime - activity.totalPersistedPausedMs);
+      const { correctQuestions, totalQuestions } = data;
+      if (data.masteredUnits !== undefined && data.masteredUnitsAbsolute !== undefined) {
+        throw new Error("Cannot provide both masteredUnits and masteredUnitsAbsolute — use one or the other");
+      }
+      const request = {
+        runId: activity.runId,
+        resumeId: activity.resumeId,
+        activityData: activity.metadata,
+        scoreData: {
+          correctQuestions,
+          totalQuestions
+        },
+        timingData: {
+          durationSeconds
+        },
+        sessionTimingData: {
+          activeSeconds: unreportedActiveMs / 1000,
+          ...unreportedPausedMs > 0 ? { inactiveSeconds: unreportedPausedMs / 1000 } : {}
+        },
+        xpEarned: data.xpAwarded,
+        masteredUnits: data.masteredUnits,
+        masteredUnitsAbsolute: data.masteredUnitsAbsolute,
+        extensions: data.extensions
+      };
+      if (relaysToParent()) {
+        messaging.send("PLAYCADEMY_TIMEBACK_ACTIVITY_END" /* TIMEBACK_ACTIVITY_END */, request);
+        if (currentActivity === activity) {
+          currentActivity = null;
+        }
+        return { status: "relayed", runId: activity.runId };
+      }
+      try {
+        const response = await client["requestGameBackend"](TIMEBACK_ROUTES.END_ACTIVITY, "POST", request, undefined, { retryPolicy: END_ACTIVITY_RETRY_POLICY });
+        if (currentActivity === activity) {
+          currentActivity = null;
+        }
+        return response;
+      } catch (error) {
+        if (currentActivity === activity) {
+          currentActivity = null;
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/namespaces/game/embed.ts
+function createEmbedNamespace(client) {
+  return {
+    launch(options) {
+      assertPlatformMode(client, "embed.launch()");
+      if (typeof document === "undefined") {
+        throw new PlaycademyError("embed.launch() requires a browser document to mount the child iframe.");
+      }
+      const tokenAtLaunch = client.getToken();
+      if (!tokenAtLaunch) {
+        throw new PlaycademyError("embed.launch() requires an authenticated client; the child session runs on this token.");
+      }
+      if (!isValidLaunchIntent(options.intent)) {
+        throw new PlaycademyError("embed.launch() intent needs a non-empty lessonId and an eLevel of 'E1' to 'E4'.");
+      }
+      if (options.timeback && !isValidTimebackRecording(options.timeback)) {
+        throw new PlaycademyError("embed.launch() timeback option needs a non-empty activityId, a grade from -1 to 13, and a valid subject.");
+      }
+      const openRunId = client.timeback.currentRunId;
+      if (openRunId !== undefined && !isActivityManuallyPaused(client)) {
+        throw new PlaycademyError(`embed.launch() requires no open activity: this game's own run ${openRunId} is still active, and its clock would double-count the lesson. Pause it (client.timeback.pauseActivity()) or end it before launching, and resume it deliberately afterwards if you mean to.`);
+      }
+      if (hasLiveSession(client)) {
+        throw new PlaycademyError("embed.launch() requires no live child session: an earlier launch is still running and its child owns the clock. close() it or await its finished before launching another lesson.");
+      }
+      const parentGameId = client["_ensureGameId"]();
+      const resume = resolveResumePolicy({
+        resume: options.resume,
+        token: tokenAtLaunch,
+        parentGameId,
+        slug: options.slug,
+        intent: options.intent
+      });
+      const session = new ChildSession({
+        slug: options.slug,
+        container: options.container,
+        timeback: options.timeback,
+        resume: resume.envelope,
+        resumeStore: resume.store,
+        reporter: {
+          postHeartbeat: (body) => client["requestGameBackend"](TIMEBACK_ROUTES.HEARTBEAT, "POST", body, undefined, {
+            retryPolicy: HEARTBEAT_RETRY_POLICY
+          }),
+          postHeartbeatKeepalive: (body) => {
+            sendHeartbeatKeepalive(client, body);
+          },
+          postEndActivity: (body) => client["requestGameBackend"](TIMEBACK_ROUTES.END_ACTIVITY, "POST", body, undefined, { retryPolicy: END_ACTIVITY_RETRY_POLICY })
+        },
+        resolveTarget: async (resumeContext) => {
+          const game2 = await client["request"](`/games/${encodeURIComponent(options.slug)}`, "GET").catch((error) => {
+            if (!options.gameUrl) {
+              throw error;
+            }
+            console.warn(`[Playcademy SDK] embed.launch(): slug '${options.slug}' did not resolve (${errorMessage(error)}). Continuing with gameUrl; the slug stands in as the child's game id.`);
+            return null;
+          });
+          const childGameId = game2?.id ?? options.slug;
+          const deploymentUrl = game2 ? game2.deploymentUrl : undefined;
+          const rawUrl = options.gameUrl ?? deploymentUrl;
+          if (!rawUrl) {
+            throw new PlaycademyError(`Game '${options.slug}' has no deployment URL. Pass gameUrl to embed.launch() to point at one.`);
+          }
+          const childUrl = `${rawUrl.replace(/\/$/, "")}/`;
+          const payload = {
+            baseUrl: client.baseUrl,
+            gameUrl: childUrl,
+            token: client.getToken() ?? tokenAtLaunch,
+            gameId: childGameId,
+            mode: "child",
+            parent: buildParentContext(parentGameId, options.intent, resumeContext),
+            localDay: client["initPayload"]?.localDay,
+            launchId: client["launchId"],
+            hasHeartbeatRelay: true
+          };
+          return { childUrl, payload };
+        }
+      });
+      registerLiveSession(client);
+      session.finished.then(() => releaseLiveSession(client));
+      return session;
+    }
+  };
+}
+// src/core/auth/utils.ts
+function openPopupWindow(url, name = "auth-popup", width = 500, height = 600) {
+  const left = window.screenX + (window.outerWidth - width) / 2;
+  const top = window.screenY + (window.outerHeight - height) / 2;
+  const features = [
+    `width=${width}`,
+    `height=${height}`,
+    `left=${left}`,
+    `top=${top}`,
+    "toolbar=no",
+    "menubar=no",
+    "location=yes",
+    "status=yes",
+    "scrollbars=yes",
+    "resizable=yes"
+  ].join(",");
+  return window.open(url, name, features);
+}
+function isInIframe() {
+  if (typeof globalThis.window === "undefined") {
+    return false;
+  }
+  try {
+    return globalThis.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+
+// src/core/auth/flows/popup.ts
+async function initiatePopupFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Opening authentication window..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    const popup = openPopupWindow(authUrl, "playcademy-auth");
+    if (!popup || popup.closed) {
+      throw new Error("Popup blocked. Please enable popups and try again.");
+    }
+    onStateChange?.({
+      status: "exchanging_token",
+      message: "Waiting for authentication..."
+    });
+    return await waitForServerMessage(popup, onStateChange);
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage2,
+      error: error instanceof Error ? error : new Error(errorMessage2)
+    });
+    throw error;
+  }
+}
+async function waitForServerMessage(popup, onStateChange) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    function handleMessage(event) {
+      if (event.origin !== globalThis.location.origin) {
+        return;
+      }
+      const data = event.data;
+      if (data?.type === "PLAYCADEMY_AUTH_STATE_CHANGE") {
+        resolved = true;
+        window.removeEventListener("message", handleMessage);
+        if (data.authenticated && data.user) {
+          onStateChange?.({
+            status: "complete",
+            message: "Authentication successful"
+          });
+          resolve({
+            success: true,
+            user: data.user
+          });
+        } else {
+          const error = new Error(data.error || "Authentication failed");
+          onStateChange?.({
+            status: "error",
+            message: error.message,
+            error
+          });
+          resolve({
+            success: false,
+            error
+          });
+        }
+      }
+    }
+    window.addEventListener("message", handleMessage);
+    const checkClosed = setInterval(() => {
+      if (popup.closed && !resolved) {
+        clearInterval(checkClosed);
+        window.removeEventListener("message", handleMessage);
+        const error = new Error("Authentication cancelled");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 500);
+    setTimeout(() => {
+      if (!resolved) {
+        window.removeEventListener("message", handleMessage);
+        clearInterval(checkClosed);
+        const error = new Error("Authentication timeout");
+        onStateChange?.({
+          status: "error",
+          message: error.message,
+          error
+        });
+        resolve({
+          success: false,
+          error
+        });
+      }
+    }, 5 * 60 * 1000);
+  });
+}
+
+// src/core/auth/flows/redirect.ts
+async function initiateRedirectFlow(options) {
+  const { provider, callbackUrl, onStateChange, oauth } = options;
+  try {
+    onStateChange?.({
+      status: "opening_popup",
+      message: "Redirecting to authentication provider..."
+    });
+    const defaults = getOAuthConfig(provider);
+    const config = oauth ? { ...defaults, ...oauth } : defaults;
+    if (!config.clientId) {
+      throw new Error(`clientId is required for ${provider} authentication. ` + "Please provide it in the oauth parameter.");
+    }
+    const stateData = options.stateData;
+    const state = await generateOAuthState(stateData);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: callbackUrl,
+      state
+    });
+    if (config.scope) {
+      params.set("scope", config.scope);
+    }
+    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    globalThis.location.href = authUrl;
+    return new Promise(() => {});
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : "Authentication failed";
+    onStateChange?.({
+      status: "error",
+      message: errorMessage2,
+      error: error instanceof Error ? error : new Error(errorMessage2)
+    });
+    throw error;
+  }
+}
+
+// src/core/auth/flows/unified.ts
+async function initiateUnifiedFlow(options) {
+  const { mode = "auto" } = options;
+  let effectiveMode;
+  if (mode === "auto") {
+    effectiveMode = isInIframe() ? "popup" : "redirect";
+  } else {
+    effectiveMode = mode;
+  }
+  switch (effectiveMode) {
+    case "popup": {
+      return initiatePopupFlow(options);
+    }
+    case "redirect": {
+      return initiateRedirectFlow(options);
+    }
+    default: {
+      throw new Error(`Unsupported authentication mode: ${effectiveMode}`);
+    }
+  }
+}
+
+// src/core/auth/login.ts
+async function login2(client, options) {
+  try {
+    let stateData = options.stateData;
+    if (!stateData) {
+      try {
+        const currentUser = await client.users.me();
+        if (currentUser?.id) {
+          stateData = { playcademy_user_id: currentUser.id };
+        }
+      } catch {
+        log.debug("[Playcademy SDK] No current user available for state data");
+      }
+    }
+    log.debug("[Playcademy SDK] Starting OAuth login", {
+      provider: options.provider,
+      mode: options.mode || "auto",
+      callbackUrl: options.callbackUrl,
+      hasStateData: Boolean(stateData)
+    });
+    const optionsWithState = {
+      ...options,
+      stateData
+    };
+    const result = await initiateUnifiedFlow(optionsWithState);
+    if (result.success && result.user) {
+      log.debug("[Playcademy SDK] OAuth login successful", {
+        userId: result.user.sub
+      });
+    }
+    return result;
+  } catch (error) {
+    log.error("[Playcademy SDK] OAuth login failed", { error });
+    const authError = error instanceof Error ? error : new Error("Authentication failed");
+    return {
+      success: false,
+      error: authError
+    };
+  }
+}
+
+// src/namespaces/game/identity.ts
+function createIdentityNamespace(client) {
+  return {
+    connect: (options) => {
+      if (client.mode === "demo") {
+        throw new PlaycademyError("identity.connect() is not available in demo mode. Use platform or standalone mode for OAuth flows.");
+      }
+      assertNotChildMode(client, "identity.connect()", "Account connections belong to the hub or parent context.");
+      return login2(client, options);
+    },
+    _getContext: () => ({
+      isInIframe: client["authContext"]?.isInIframe ?? false
+    })
+  };
+}
+// src/namespaces/game/runtime.ts
+function createRuntimeNamespace(client) {
+  const eventListeners = new Map;
+  function trackListener(eventType, handler) {
+    if (!eventListeners.has(eventType)) {
+      eventListeners.set(eventType, new Set);
+    }
+    eventListeners.get(eventType).add(handler);
+  }
+  function untrackListener(eventType, handler) {
+    const listeners = eventListeners.get(eventType);
+    if (listeners) {
+      listeners.delete(handler);
+      if (listeners.size === 0) {
+        eventListeners.delete(eventType);
+      }
+    }
+  }
+  if (typeof globalThis.window !== "undefined" && globalThis.self !== window.top) {
+    let keyListener = function(event) {
+      if (keySet.has(event.key?.toLowerCase() ?? "") || keySet.has(event.code?.toLowerCase() ?? "")) {
+        messaging.send("PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */, {
+          key: event.key,
+          code: event.code,
+          type: event.type
+        });
+      }
+    };
+    const playcademyConfig = globalThis.PLAYCADEMY;
+    const forwardKeys = Array.isArray(playcademyConfig?.forwardKeys) ? playcademyConfig.forwardKeys : ["Escape"];
+    const keySet = new Set(forwardKeys.map((k) => k.toLowerCase()));
+    globalThis.addEventListener("keydown", keyListener);
+    globalThis.addEventListener("keyup", keyListener);
+    trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, () => {
+      globalThis.removeEventListener("keydown", keyListener);
+      globalThis.removeEventListener("keyup", keyListener);
+    });
+  }
+  return {
+    exit: () => {
+      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
+    },
+    onInit: (handler) => {
+      messaging.listen("PLAYCADEMY_INIT" /* INIT */, handler);
+      trackListener("PLAYCADEMY_INIT" /* INIT */, handler);
+    },
+    onTokenRefresh: (handler) => {
+      messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+      trackListener("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, handler);
+    },
+    onPause: (handler) => {
+      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+      trackListener("PLAYCADEMY_PAUSE" /* PAUSE */, handler);
+    },
+    onResume: (handler) => {
+      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, handler);
+      trackListener("PLAYCADEMY_RESUME" /* RESUME */, handler);
+    },
+    onForceExit: (handler) => {
+      messaging.listen("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+      trackListener("PLAYCADEMY_FORCE_EXIT" /* FORCE_EXIT */, handler);
+    },
+    onOverlay: (handler) => {
+      messaging.listen("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+      trackListener("PLAYCADEMY_OVERLAY" /* OVERLAY */, handler);
+    },
+    ready: () => {
+      messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+    },
+    sendTelemetry: (data) => {
+      messaging.send("PLAYCADEMY_TELEMETRY" /* TELEMETRY */, data);
+    },
+    removeListener: (eventType, handler) => {
+      messaging.unlisten(eventType, handler);
+      untrackListener(eventType, handler);
+    },
+    removeAllListeners: () => {
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        for (const handler of handlers) {
+          messaging.unlisten(eventType, handler);
+        }
+      }
+      eventListeners.clear();
+    },
+    getListenerCounts: () => {
+      const counts = {};
+      for (const [eventType, handlers] of eventListeners.entries()) {
+        counts[eventType] = handlers.size;
+      }
+      return counts;
+    },
+    assets: createAssetsNamespace(client)
+  };
+}
+function createAssetsNamespace(client) {
+  async function fetchAsset(path, options) {
+    const gameUrl = client["initPayload"]?.gameUrl;
+    if (!gameUrl) {
+      const relativePath = path.startsWith("./") ? path : `./${path}`;
+      return fetch(relativePath, options);
+    }
+    const cleanPath = path.startsWith("./") ? path.slice(2) : path;
+    return fetch(`${gameUrl}${cleanPath}`, options);
+  }
+  return {
+    url(pathOrStrings, ...values) {
+      const gameUrl = client["initPayload"]?.gameUrl;
+      let path;
+      if (Array.isArray(pathOrStrings) && "raw" in pathOrStrings) {
+        const strings = pathOrStrings;
+        path = strings.reduce((acc, str, i) => acc + str + (values[i] != null ? String(values[i]) : ""), "");
+      } else {
+        path = pathOrStrings;
+      }
+      if (!gameUrl) {
+        return path.startsWith("./") ? path : `./${path}`;
+      }
+      const cleanPath = path.startsWith("./") ? path.slice(2) : path;
+      return `${gameUrl}${cleanPath}`;
+    },
+    fetch: fetchAsset,
+    json: async (path) => {
+      const response = await fetchAsset(path);
+      return await response.json();
+    },
+    blob: async (path) => {
+      const response = await fetchAsset(path);
+      return response.blob();
+    },
+    text: async (path) => {
+      const response = await fetchAsset(path);
+      return response.text();
+    },
+    arrayBuffer: async (path) => {
+      const response = await fetchAsset(path);
+      return response.arrayBuffer();
+    }
+  };
+}
+// src/namespaces/game/scores.ts
+function createScoresNamespace(client) {
+  return {
+    submit: async (score, metadata) => {
+      assertNotChildMode(client, "scores.submit()", "The parent game owns reporting; the score already reaches it via the activity relay.");
+      const gameId = client["_ensureGameId"]();
+      return client["request"](`/games/${gameId}/scores`, "POST", {
+        body: {
+          score,
+          metadata
+        }
+      });
+    }
+  };
+}
+// src/core/cache/ttl-cache.ts
+function createTTLCache(options) {
+  const cache = new Map;
+  const { ttl: defaultTTL, keyPrefix = "", onClear } = options;
+  async function get(key, loader, config) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const now = Date.now();
+    const effectiveTTL = config?.ttl !== undefined ? config.ttl : defaultTTL;
+    const force = config?.force || false;
+    const skipCache = config?.skipCache || false;
+    if (effectiveTTL === 0 || skipCache) {
+      return loader();
+    }
+    if (!force) {
+      const cached = cache.get(fullKey);
+      if (cached && cached.expiresAt > now) {
+        return cached.value;
       }
+    }
+    const promise = loader().catch((error) => {
+      cache.delete(fullKey);
+      throw error;
+    });
+    cache.set(fullKey, {
+      value: promise,
+      expiresAt: now + effectiveTTL
     });
+    return promise;
   }
-  function flushFinalHeartbeatBeacon() {
-    applyOverdueInactivity();
-    const activity = currentActivity;
-    if (!activity) {
-      return;
-    }
-    const timing = computeWindowAndReset(activity);
-    if (timing.activeMs === 0 && timing.pausedMs === 0) {
-      return;
-    }
-    const body = buildHeartbeatBody(activity, timing, true);
-    stopRelayInterval();
-    try {
-      messaging.send("PLAYCADEMY_TIMEBACK_HEARTBEAT_RELAY" /* TIMEBACK_HEARTBEAT_RELAY */, body);
-    } catch {}
-    if (!client["initPayload"]?.hasHeartbeatRelay) {
-      queueHeartbeatFlush(activity, timing, async () => {
-        try {
-          const baseUrl = client["getGameBackendUrl"]();
-          const url = `${baseUrl}${TIMEBACK_ROUTES.HEARTBEAT}`;
-          const headers = {
-            "Content-Type": "application/json",
-            ...client["authStrategy"].getHeaders()
-          };
-          const response = await fetch(url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            keepalive: true
-          });
-          return response.ok;
-        } catch {
-          return false;
-        }
-      });
+  function clear(key) {
+    if (key === undefined) {
+      cache.clear();
+      onClear?.();
+    } else {
+      const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+      cache.delete(fullKey);
     }
   }
-  function handlePageHide() {
-    flushFinalHeartbeatBeacon();
+  function size() {
+    return cache.size;
   }
-  function cleanupListeners() {
-    if (boundVisibilityHandler && typeof document !== "undefined") {
-      document.removeEventListener("visibilitychange", boundVisibilityHandler);
-      boundVisibilityHandler = null;
-    }
-    if (boundUserInteractionHandler && typeof document !== "undefined") {
-      for (const eventName of USER_ACTIVITY_EVENTS) {
-        document.removeEventListener(eventName, boundUserInteractionHandler, USER_ACTIVITY_LISTENER_OPTIONS);
+  function prune() {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (entry.expiresAt <= now) {
+        cache.delete(key);
       }
-      boundUserInteractionHandler = null;
-    }
-    if (boundShellPauseHandler) {
-      messaging.unlisten("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
-      boundShellPauseHandler = null;
-    }
-    if (boundShellResumeHandler) {
-      messaging.unlisten("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
-      boundShellResumeHandler = null;
     }
-    if (boundPageHideHandler && typeof globalThis.window !== "undefined") {
-      globalThis.window.removeEventListener("pagehide", boundPageHideHandler);
-      boundPageHideHandler = null;
+  }
+  function getKeys() {
+    const keys = [];
+    const prefixLen = keyPrefix ? keyPrefix.length + 1 : 0;
+    for (const fullKey of cache.keys()) {
+      keys.push(fullKey.substring(prefixLen));
     }
-    if (currentActivity) {
-      clearInactivityTimeout(currentActivity);
-      clearPausedHeartbeatTimeout(currentActivity);
+    return keys;
+  }
+  function has(key) {
+    const fullKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const cached = cache.get(fullKey);
+    if (!cached) {
+      return false;
     }
-    if (currentActivity?.heartbeatIntervalId != null) {
-      stopHeartbeatInterval(currentActivity);
+    const now = Date.now();
+    if (cached.expiresAt <= now) {
+      cache.delete(fullKey);
+      return false;
     }
-    stopRelayInterval();
+    return true;
   }
-  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,
-        resumeId: crypto.randomUUID(),
-        startTime: now,
-        metadata,
-        pausedTime: 0,
-        pauseStartTime: null,
-        pauseReasons: new Set,
-        pausedHeartbeatTimeoutId: null,
-        pausedHeartbeatTimedOut: false,
-        pausedHeartbeatTimeoutMs,
-        windowStartTime: now,
-        windowPausedAtStart: 0,
-        heartbeatIntervalId: null,
-        heartbeatIntervalMs,
-        inactivityTimeoutId: null,
-        inactivityTimeoutMs,
-        inactivityTimerStartedAt: null,
-        remainingInactivityMs: inactivityTimeoutMs,
-        flushInFlight: null,
-        totalPersistedActiveMs: 0,
-        totalPersistedPausedMs: 0
-      };
-      if (typeof document !== "undefined") {
-        boundVisibilityHandler = handleVisibilityChange;
-        document.addEventListener("visibilitychange", boundVisibilityHandler);
-        boundUserInteractionHandler = handleUserInteraction;
-        for (const eventName of USER_ACTIVITY_EVENTS) {
-          document.addEventListener(eventName, boundUserInteractionHandler, USER_ACTIVITY_LISTENER_OPTIONS);
-        }
-        if (document.visibilityState === "hidden") {
-          handleVisibilityChange();
-        }
-      }
-      startHeartbeatInterval(currentActivity);
-      startRelayInterval();
-      if (typeof globalThis.window !== "undefined") {
-        boundPageHideHandler = handlePageHide;
-        globalThis.window.addEventListener("pagehide", boundPageHideHandler);
-      }
-      boundShellPauseHandler = handleShellPause;
-      boundShellResumeHandler = handleShellResume;
-      messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
-      messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
-      syncInactivityTracking();
-      return { runId };
-    },
-    pauseActivity() {
-      if (!currentActivity) {
-        throw new Error("No activity in progress. Call startActivity() before pauseActivity().");
-      }
-      if (currentActivity.pauseReasons.has("manual")) {
-        throw new Error("Activity is already paused.");
-      }
-      addPauseReason("manual");
-    },
-    resumeActivity() {
-      if (!currentActivity) {
-        throw new Error("No activity in progress. Call startActivity() before resumeActivity().");
-      }
-      if (!currentActivity.pauseReasons.has("manual")) {
-        throw new Error("Activity is not paused.");
-      }
-      removePauseReason("manual");
-    },
-    async endActivity(data) {
-      if (!currentActivity) {
-        throw new Error("No activity in progress. Call startActivity() before endActivity().");
-      }
-      const activity = currentActivity;
-      applyOverdueInactivity();
-      cleanupListeners();
-      await flushHeartbeat(true);
-      if (activity.pauseStartTime !== null) {
-        activity.pausedTime += Date.now() - activity.pauseStartTime;
-        activity.pauseStartTime = null;
-      }
-      const endTime = Date.now();
-      const totalElapsed = endTime - activity.startTime;
-      const activeTime = Math.max(0, totalElapsed - activity.pausedTime);
-      const durationSeconds = Math.floor(activeTime / 1000);
-      const unreportedActiveMs = Math.max(0, activeTime - activity.totalPersistedActiveMs);
-      const unreportedPausedMs = Math.max(0, activity.pausedTime - activity.totalPersistedPausedMs);
-      const { correctQuestions, totalQuestions } = data;
-      if (data.masteredUnits !== undefined && data.masteredUnitsAbsolute !== undefined) {
-        throw new Error("Cannot provide both masteredUnits and masteredUnitsAbsolute — use one or the other");
-      }
-      const request = {
-        runId: activity.runId,
-        resumeId: activity.resumeId,
-        activityData: activity.metadata,
-        scoreData: {
-          correctQuestions,
-          totalQuestions
-        },
-        timingData: {
-          durationSeconds
-        },
-        sessionTimingData: {
-          activeSeconds: unreportedActiveMs / 1000,
-          ...unreportedPausedMs > 0 ? { inactiveSeconds: unreportedPausedMs / 1000 } : {}
-        },
-        xpEarned: data.xpAwarded,
-        masteredUnits: data.masteredUnits,
-        masteredUnitsAbsolute: data.masteredUnitsAbsolute,
-        extensions: data.extensions
-      };
-      try {
-        const response = await client["requestGameBackend"](TIMEBACK_ROUTES.END_ACTIVITY, "POST", request, undefined, { retryPolicy: END_ACTIVITY_RETRY_POLICY });
-        if (currentActivity === activity) {
-          currentActivity = null;
-        }
-        return response;
-      } catch (error) {
-        if (currentActivity === activity) {
-          currentActivity = null;
-        }
-        throw error;
-      }
-    }
-  };
+  return { get, clear, size, prune, getKeys, has };
 }
 
 // src/core/timeback/user.ts
@@ -1983,6 +2925,7 @@ function createTimebackEngine(client) {
     },
     activity: {
       currentRunId: activityTracker.currentRunId,
+      isManuallyPaused: activityTracker.isActivityManuallyPaused,
       start: activityTracker.startActivity,
       pause: activityTracker.pauseActivity,
       resume: activityTracker.resumeActivity,
@@ -2014,7 +2957,7 @@ var VALID_MASTERY_INCLUDE_OPTIONS = ["perCourse"];
 var ASSESSMENTS_ROUTE = TIMEBACK_ROUTES.ASSESSMENTS;
 function validateAssessmentFilters(options) {
   if (!isAssessmentPurpose(options?.purpose)) {
-    throw new Error("purpose must be end_of_course or diagnostic");
+    throw new Error("purpose must be end_of_course, diagnostic, review, or mastery");
   }
   if (options.grade !== undefined && !isValidGrade(options.grade)) {
     throw new Error(`Invalid grade: ${options.grade}. Valid grades: ${VALID_GRADES.join(", ")}`);
@@ -2022,9 +2965,21 @@ function validateAssessmentFilters(options) {
   if (options.subject !== undefined && !isValidSubject(options.subject)) {
     throw new Error(`Invalid subject: ${options.subject}. Valid subjects: ${VALID_SUBJECTS.join(", ")}`);
   }
+  if (options.purpose === "mastery") {
+    const { standard } = options;
+    const framework = typeof standard?.framework === "string" ? standard.framework.trim() : "";
+    const identifier = typeof standard?.identifier === "string" ? standard.identifier.trim() : "";
+    if (!framework || !identifier) {
+      throw new Error("mastery standard requires a canonical framework and identifier");
+    }
+    if (framework.length > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength || identifier.length > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength) {
+      throw new Error(`mastery standard fields must be at most ${TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength} characters`);
+    }
+  }
 }
 function createTimebackNamespace(client) {
   const engine = createTimebackEngine(client);
+  registerPauseProbe(client, () => engine.activity.isManuallyPaused());
   return {
     assessments: {
       start: async (input) => {
@@ -2033,6 +2988,25 @@ function createTimebackNamespace(client) {
           throw new Error("activityId is required");
         }
         validateAssessmentFilters(input);
+        if (input.purpose === "review") {
+          if (!Array.isArray(input.standards) || input.standards.length === 0) {
+            throw new Error("standards must contain at least one standard for review");
+          }
+          if (input.standards.length > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standards) {
+            throw new Error(`standards must contain at most ${TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standards} standards`);
+          }
+          for (const standard of input.standards) {
+            if (!standard || typeof standard !== "object" || !standard.framework?.trim() || !standard.identifier?.trim()) {
+              throw new Error("review standards require a framework and identifier");
+            }
+            if (standard.framework.trim().length > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength || standard.identifier.trim().length > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength) {
+              throw new Error(`review standard fields must be at most ${TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength} characters`);
+            }
+          }
+          if (input.itemsPerStandard !== undefined && (!Number.isInteger(input.itemsPerStandard) || input.itemsPerStandard <= 0 || input.itemsPerStandard > TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.itemsPerStandard)) {
+            throw new Error(`itemsPerStandard must be a positive integer at most ${TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.itemsPerStandard}`);
+          }
+        }
         return client["requestGameBackend"](`${ASSESSMENTS_ROUTE}/start`, "POST", input);
       },
       latest: async (options) => {
@@ -2045,6 +3019,10 @@ function createTimebackNamespace(client) {
         if (options.grade !== undefined) {
           params.set("grade", String(options.grade));
         }
+        if (options.purpose === "mastery") {
+          params.set("standardFramework", options.standard.framework);
+          params.set("standardIdentifier", options.standard.identifier);
+        }
         return client["requestGameBackend"](`${ASSESSMENTS_ROUTE}/latest?${params.toString()}`, "GET");
       },
       get: async (attemptId) => {
@@ -2079,7 +3057,8 @@ function createTimebackNamespace(client) {
       }
     },
     get user() {
-      assertPlatformMode(client, "timeback.user");
+      assertNonAnonymousMode(client, "timeback.user");
+      assertNotChildMode(client, "timeback.user", "Course and user context belong to the parent game; pass what the lesson needs through the launch intent's extensions.");
       return {
         get id() {
           return engine.user.snapshot()?.id;
@@ -2155,23 +3134,23 @@ function createTimebackNamespace(client) {
       };
     },
     get currentRunId() {
-      assertPlatformMode(client, "timeback.currentRunId");
+      assertNonAnonymousMode(client, "timeback.currentRunId");
       return engine.activity.currentRunId();
     },
     startActivity: (metadata, options) => {
-      assertPlatformMode(client, "timeback.startActivity()");
+      assertNonAnonymousMode(client, "timeback.startActivity()");
       return engine.activity.start(metadata, options);
     },
     pauseActivity: () => {
-      assertPlatformMode(client, "timeback.pauseActivity()");
+      assertNonAnonymousMode(client, "timeback.pauseActivity()");
       engine.activity.pause();
     },
     resumeActivity: () => {
-      assertPlatformMode(client, "timeback.resumeActivity()");
+      assertNonAnonymousMode(client, "timeback.resumeActivity()");
       engine.activity.resume();
     },
     endActivity: async (data) => {
-      assertPlatformMode(client, "timeback.endActivity()");
+      assertNonAnonymousMode(client, "timeback.endActivity()");
       return engine.activity.end(data);
     },
     course: {
@@ -2199,7 +3178,7 @@ function createTimebackNamespace(client) {
 function createUsersNamespace(client) {
   return {
     me: async () => {
-      assertPlatformMode(client, "users.me()");
+      assertNonAnonymousMode(client, "users.me()");
       const user = await client["request"]("/users/me", "GET");
       const initPayload = client["initPayload"];
       if (initPayload) {
@@ -2321,6 +3300,24 @@ function createAuthStrategy(token, tokenType) {
   return new GameJwtAuth(token);
 }
 
+// src/core/launch/checkpoint.ts
+var CHECKPOINT_MAX_CHARS = 64000;
+function sendCheckpointToParent(state) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(state);
+  } catch {}
+  if (serialized === undefined) {
+    console.warn("[Playcademy SDK] parent.checkpoint() dropped a checkpoint that is not JSON-serializable.");
+    return;
+  }
+  if (serialized.length > CHECKPOINT_MAX_CHARS) {
+    console.warn(`[Playcademy SDK] parent.checkpoint() dropped a ${serialized.length}-char checkpoint; the cap is ${CHECKPOINT_MAX_CHARS}.`);
+    return;
+  }
+  messaging.send("PLAYCADEMY_CHECKPOINT" /* CHECKPOINT */, { state: JSON.parse(serialized) });
+}
+
 // src/core/transport/retry.ts
 var RETRY_DELAYS_MS = [500, 1500];
 function wait(ms) {
@@ -2463,7 +3460,7 @@ async function request({
   return rawText && rawText.length > 0 ? rawText : undefined;
 }
 // src/version.ts
-var SDK_VERSION = "0.16.1-beta.1";
+var SDK_VERSION = "0.16.1-beta.10";
 
 // src/clients/base.ts
 class PlaycademyBaseClient {
@@ -2476,6 +3473,7 @@ class PlaycademyBaseClient {
   listeners = {};
   authContext;
   initPayload;
+  parentHandle;
   launchId;
   gameOrigin;
   browserTimeZone;
@@ -2510,6 +3508,20 @@ class PlaycademyBaseClient {
   get localDay() {
     return this.initPayload?.localDay;
   }
+  get parent() {
+    if (this.mode !== "child") {
+      return null;
+    }
+    const context = this.initPayload?.parent;
+    if (!context) {
+      return null;
+    }
+    this.parentHandle ??= {
+      ...context,
+      checkpoint: (state) => sendCheckpointToParent(state)
+    };
+    return this.parentHandle;
+  }
   setToken(token, tokenType) {
     this.authStrategy = createAuthStrategy(token, tokenType);
     this.emit("authChange", { token });
@@ -2635,12 +3647,17 @@ class PlaycademyClient extends PlaycademyBaseClient {
   leaderboard = createLeaderboardFetchNamespace(this);
   demo = createDemoNamespace(this);
   backend = createBackendNamespace(this);
+  embed = createEmbedNamespace(this);
   static init = init;
   static login = login;
   static identity = identity;
 }
+function isChildLaunched(client) {
+  return client.mode === "child" && client.parent !== null;
+}
 export {
   messaging,
+  isChildLaunched,
   extractApiErrorInfo,
   PlaycademyError,
   PlaycademyClient,