@playcademy/vite-plugin 0.2.23 → 0.2.24-beta.10

package/dist/index.js

@@ -24406,7 +24406,8 @@ var TIMEBACK_COMPONENT_RESOURCE_DEFAULTS;
 var init_timeback2 = __esm(() => {
   TIMEBACK_ROUTES = {
     END_ACTIVITY: "/integrations/timeback/end-activity",
-    GET_XP: "/integrations/timeback/xp"
+    GET_XP: "/integrations/timeback/xp",
+    HEARTBEAT: "/integrations/timeback/heartbeat"
   };
   TIMEBACK_COURSE_DEFAULTS = {
     gradingScheme: "STANDARD",
@@ -24447,6 +24448,7 @@ var init_timeback2 = __esm(() => {
 });
 var WORKER_NAMING;
 var SECRETS_PREFIX = "secrets_";
+var CLOUDFLARE_COMPATIBILITY_DATE = "2025-10-11";
 var init_workers = __esm(() => {
   WORKER_NAMING = {
     STAGING_PREFIX: "staging-",
@@ -25334,7 +25336,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.3.16",
+    version: "0.3.17-beta.13",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -29949,6 +29951,7 @@ var init_esm = __esm(() => {
 function createMinimalConfig(overrides) {
   return apiConfigSchema.parse({
     stage: "local",
+    isLocal: false,
     ...overrides
   });
 }
@@ -29976,6 +29979,7 @@ var init_schema = __esm(() => {
   });
   apiConfigSchema = exports_external.object({
     stage: stageSchema,
+    isLocal: exports_external.boolean().default(false),
     baseUrl: exports_external.string().url().optional(),
     gameDomain: exports_external.string().optional(),
     lti: ltiConfigSchema.optional(),
@@ -35610,7 +35614,7 @@ var init_table6 = __esm(() => {
   init_drizzle_orm();
   init_pg_core();
   init_table5();
-  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer"]);
+  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer", "teacher"]);
   developerStatusEnum = pgEnum("developer_status", ["none", "pending", "approved"]);
   users = pgTable("user", {
     id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
@@ -47627,13 +47631,11 @@ var dedent;
 var init_dedent = __esm(() => {
   dedent = createDedent({});
 });
-var DEFAULT_COMPATIBILITY_DATE;
 var init_workers2 = __esm(() => {
   init_dedent();
   init_src2();
   init_assets();
   init_multipart();
-  DEFAULT_COMPATIBILITY_DATE = new Date().toISOString().slice(0, 10);
 });
 var init_namespaces = __esm(() => {
   init_d1();
@@ -47650,12 +47652,10 @@ var init_core = __esm(() => {
 });
 var CUSTOM_DOMAINS_KV_NAME = "cademy-custom-domains";
 var QUEUE_NAME_PREFIX = "playcademy";
-var DEFAULT_COMPATIBILITY_DATE2;
 var GAME_WORKER_DOMAIN_PRODUCTION;
 var GAME_WORKER_DOMAIN_STAGING;
 var init_constants2 = __esm(() => {
   init_src();
-  DEFAULT_COMPATIBILITY_DATE2 = new Date().toISOString().slice(0, 10);
   GAME_WORKER_DOMAIN_PRODUCTION = GAME_WORKER_DOMAINS.production;
   GAME_WORKER_DOMAIN_STAGING = GAME_WORKER_DOMAINS.staging;
 });
@@ -50332,6 +50332,7 @@ class DeployService {
     try {
       result = await this.timeStep("Cloudflare deploy", () => cf.deploy(deploymentId, request.code, env, {
         ...deploymentOptions,
+        compatibilityDate: request.compatibilityDate ?? CLOUDFLARE_COMPATIBILITY_DATE,
         compatibilityFlags: request.compatibilityFlags,
         existingResources: activeDeployment?.resources ?? undefined,
         assetsPath: frontendAssetsPath,
@@ -50433,6 +50434,7 @@ var logger3;
 var init_deploy_service = __esm(() => {
   init_drizzle_orm();
   init_playcademy();
+  init_src();
   init_tables_index();
   init_src2();
   init_config2();
@@ -50499,453 +50501,555 @@ var init_developer_service = __esm(() => {
   init_errors();
   logger4 = log.scope("DeveloperService");
 });
-
-class GameService {
-  deps;
-  static MANIFEST_FETCH_TIMEOUT_MS = 5000;
-  static MAX_FETCH_ERROR_MESSAGE_LENGTH = 512;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  static getManifestHost(manifestUrl) {
-    try {
-      return new URL(manifestUrl).host;
-    } catch {
-      return manifestUrl;
-    }
+function sleep(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
   }
-  static getFetchErrorMessage(error) {
-    let raw;
-    if (error instanceof Error) {
-      raw = error.message;
-    } else if (typeof error === "string") {
-      raw = error;
-    }
-    if (!raw) {
-      return;
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var logger5;
+var inFlightManifestFetches;
+var GameService;
+var init_game_service = __esm(() => {
+  init_drizzle_orm();
+  init_tables_index();
+  init_src2();
+  init_errors();
+  init_deployment_util();
+  logger5 = log.scope("GameService");
+  inFlightManifestFetches = new Map;
+  GameService = class GameService2 {
+    deps;
+    static MANIFEST_FETCH_ATTEMPT_TIMEOUT_MS = 1e4;
+    static MANIFEST_FETCH_MAX_RETRIES = 2;
+    static MANIFEST_FETCH_RETRY_BACKOFF_MS = [250, 750];
+    static MANIFEST_CACHE_TTL_SECONDS = 60;
+    static MANIFEST_CACHE_KEY_PREFIX = "game:manifest";
+    static MAX_FETCH_ERROR_MESSAGE_LENGTH = 512;
+    constructor(deps) {
+      this.deps = deps;
+    }
+    static getManifestHost(manifestUrl) {
+      try {
+        return new URL(manifestUrl).host;
+      } catch {
+        return manifestUrl;
+      }
     }
-    const normalized = raw.replace(/\s+/g, " ").trim();
-    if (!normalized) {
-      return;
+    static getFetchErrorMessage(error) {
+      let raw;
+      if (error instanceof Error) {
+        raw = error.message;
+      } else if (typeof error === "string") {
+        raw = error;
+      }
+      if (!raw) {
+        return;
+      }
+      const normalized = raw.replace(/\s+/g, " ").trim();
+      if (!normalized) {
+        return;
+      }
+      return normalized.slice(0, GameService2.MAX_FETCH_ERROR_MESSAGE_LENGTH);
     }
-    return normalized.slice(0, GameService.MAX_FETCH_ERROR_MESSAGE_LENGTH);
-  }
-  static isRetryableStatus(status) {
-    return status === 429 || status >= 500;
-  }
-  async list(caller) {
-    const db2 = this.deps.db;
-    const isAdmin = caller?.role === "admin";
-    const isDeveloper = caller?.role === "developer";
-    let whereClause;
-    if (isAdmin) {
-      whereClause = undefined;
-    } else if (isDeveloper && caller?.id) {
-      whereClause = or(ne(games.visibility, "internal"), eq(games.developerId, caller.id));
-    } else {
-      whereClause = ne(games.visibility, "internal");
+    static isRetryableStatus(status) {
+      return status === 429 || status >= 500;
     }
-    return db2.query.games.findMany({
-      where: whereClause,
-      orderBy: [desc(games.createdAt)]
-    });
-  }
-  async listManageable(user) {
-    this.validateDeveloperStatus(user);
-    const db2 = this.deps.db;
-    return db2.query.games.findMany({
-      where: user.role === "admin" ? undefined : eq(games.developerId, user.id),
-      orderBy: [desc(games.createdAt)]
-    });
-  }
-  async getSubjects() {
-    const db2 = this.deps.db;
-    const integrations = await db2.query.gameTimebackIntegrations.findMany({
-      columns: { gameId: true, subject: true },
-      orderBy: [asc(gameTimebackIntegrations.createdAt)]
-    });
-    const subjectMap = {};
-    for (const integration of integrations) {
-      if (!(integration.gameId in subjectMap)) {
-        subjectMap[integration.gameId] = integration.subject;
+    static getRetryBackoffMs(attemptIndex) {
+      const backoff = GameService2.MANIFEST_FETCH_RETRY_BACKOFF_MS;
+      if (backoff.length === 0) {
+        return 0;
       }
+      return backoff[Math.min(attemptIndex, backoff.length - 1)] ?? 0;
     }
-    return subjectMap;
-  }
-  async getById(gameId, caller) {
-    const db2 = this.deps.db;
-    const game = await db2.query.games.findFirst({
-      where: eq(games.id, gameId)
-    });
-    if (!game) {
-      throw new NotFoundError("Game", gameId);
+    static normalizeDeploymentUrl(deploymentUrl) {
+      return deploymentUrl.replace(/\/$/, "");
     }
-    this.enforceVisibility(game, caller, gameId);
-    return game;
-  }
-  async getBySlug(slug, caller) {
-    const db2 = this.deps.db;
-    const game = await db2.query.games.findFirst({
-      where: eq(games.slug, slug)
-    });
-    if (!game) {
-      throw new NotFoundError("Game", slug);
+    static getManifestCacheKey(deploymentUrl) {
+      return `${GameService2.MANIFEST_CACHE_KEY_PREFIX}:${deploymentUrl}`;
     }
-    this.enforceVisibility(game, caller, slug);
-    return game;
-  }
-  async getManifest(gameId, caller) {
-    const game = await this.getById(gameId, caller);
-    if (game.gameType !== "hosted" || !game.deploymentUrl) {
-      throw new BadRequestError("Game does not have a deployment manifest");
-    }
-    const deploymentUrl = game.deploymentUrl;
-    const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
-    const manifestHost = GameService.getManifestHost(manifestUrl);
-    const startedAt = Date.now();
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), GameService.MANIFEST_FETCH_TIMEOUT_MS);
-    function buildDetails(fetchOutcome, manifestErrorKind, extra = {}) {
-      return {
-        manifestUrl,
-        manifestHost,
-        deploymentUrl,
-        fetchOutcome,
-        retryCount: 0,
-        durationMs: Date.now() - startedAt,
-        manifestErrorKind,
-        ...extra
-      };
+    async list(caller) {
+      const db2 = this.deps.db;
+      const isAdmin = caller?.role === "admin";
+      const isDeveloper = caller?.role === "developer";
+      let whereClause;
+      if (isAdmin) {
+        whereClause = undefined;
+      } else if (isDeveloper && caller?.id) {
+        whereClause = or(ne(games.visibility, "internal"), eq(games.developerId, caller.id));
+      } else {
+        whereClause = ne(games.visibility, "internal");
+      }
+      return db2.query.games.findMany({
+        where: whereClause,
+        orderBy: [desc(games.createdAt)]
+      });
     }
-    let response;
-    try {
-      response = await fetch(manifestUrl, {
-        method: "GET",
-        headers: {
-          Accept: "application/json"
-        },
-        signal: controller.signal
+    async listManageable(user) {
+      const seesAllGames = user.role === "admin" || user.role === "teacher";
+      if (!seesAllGames) {
+        this.validateDeveloperStatus(user);
+      }
+      const db2 = this.deps.db;
+      return db2.query.games.findMany({
+        where: seesAllGames ? undefined : eq(games.developerId, user.id),
+        orderBy: [desc(games.createdAt)]
       });
-    } catch (error) {
-      clearTimeout(timeout);
-      const fetchErrorMessage = GameService.getFetchErrorMessage(error);
-      const details = buildDetails("network_error", "temporary", fetchErrorMessage ? { fetchErrorMessage } : {});
-      logger5.error("Failed to fetch game manifest", {
-        gameId,
-        manifestUrl,
-        error,
-        details
+    }
+    async getSubjects() {
+      const db2 = this.deps.db;
+      const integrations = await db2.query.gameTimebackIntegrations.findMany({
+        columns: { gameId: true, subject: true },
+        orderBy: [asc(gameTimebackIntegrations.createdAt)]
       });
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new TimeoutError("Timed out loading game manifest", details);
+      const subjectMap = {};
+      for (const integration of integrations) {
+        if (!(integration.gameId in subjectMap)) {
+          subjectMap[integration.gameId] = integration.subject;
+        }
       }
-      throw new ServiceUnavailableError("Failed to load game manifest", details);
-    } finally {
-      clearTimeout(timeout);
+      return subjectMap;
     }
-    if (!response.ok) {
-      const resolvedManifestUrl = response.url || manifestUrl;
-      const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
-      const manifestErrorKind = GameService.isRetryableStatus(response.status) ? "temporary" : "permanent";
-      const details = buildDetails("bad_status", manifestErrorKind, {
-        manifestUrl: resolvedManifestUrl,
-        manifestHost: resolvedManifestHost,
-        status: response.status,
-        contentType: response.headers.get("content-type") ?? undefined,
-        cfRay: response.headers.get("cf-ray") ?? undefined,
-        redirected: response.redirected,
-        ...response.redirected ? {
-          originalManifestUrl: manifestUrl,
-          originalManifestHost: manifestHost
-        } : {}
-      });
-      const message = `Failed to fetch manifest: ${response.status} ${response.statusText}`;
-      logger5.error("Game manifest returned non-ok response", {
-        gameId,
-        manifestUrl,
-        status: response.status,
-        details
+    async getById(gameId, caller) {
+      const db2 = this.deps.db;
+      const game = await db2.query.games.findFirst({
+        where: eq(games.id, gameId)
       });
-      if (manifestErrorKind === "temporary") {
-        throw new ServiceUnavailableError(message, details);
+      if (!game) {
+        throw new NotFoundError("Game", gameId);
       }
-      throw new BadRequestError(message, details);
+      this.enforceVisibility(game, caller, gameId);
+      return game;
     }
-    try {
-      return await response.json();
-    } catch (error) {
-      const resolvedManifestUrl = response.url || manifestUrl;
-      const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
-      const details = buildDetails("invalid_body", "permanent", {
-        manifestUrl: resolvedManifestUrl,
-        manifestHost: resolvedManifestHost,
-        status: response.status,
-        contentType: response.headers.get("content-type") ?? undefined,
-        cfRay: response.headers.get("cf-ray") ?? undefined,
-        redirected: response.redirected,
-        ...response.redirected ? {
-          originalManifestUrl: manifestUrl,
-          originalManifestHost: manifestHost
-        } : {}
-      });
-      logger5.error("Failed to parse game manifest", {
-        gameId,
-        manifestUrl,
-        error,
-        details
+    async getBySlug(slug, caller) {
+      const db2 = this.deps.db;
+      const game = await db2.query.games.findFirst({
+        where: eq(games.slug, slug)
       });
-      throw new BadRequestError("Failed to parse game manifest", details);
-    }
-  }
-  enforceVisibility(game, caller, lookupIdentifier) {
-    if (game.visibility !== "internal") {
-      return;
-    }
-    const isAdmin = caller?.role === "admin";
-    const isOwner = caller?.id != null && caller.id === game.developerId;
-    if (!isAdmin && !isOwner) {
-      throw new NotFoundError("Game", lookupIdentifier);
-    }
-  }
-  async upsertBySlug(slug, data, user) {
-    const db2 = this.deps.db;
-    const existingGame = await db2.query.games.findFirst({
-      where: eq(games.slug, slug)
-    });
-    const isUpdate = Boolean(existingGame);
-    const gameId = existingGame?.id ?? crypto.randomUUID();
-    if (isUpdate) {
-      await this.validateDeveloperAccess(user, gameId);
-    } else {
-      this.validateDeveloperStatus(user);
-    }
-    const gameDataForDb = {
-      displayName: data.displayName,
-      platform: data.platform,
-      metadata: data.metadata,
-      mapElementId: data.mapElementId,
-      gameType: data.gameType,
-      ...data.visibility && { visibility: data.visibility },
-      externalUrl: data.externalUrl || null,
-      updatedAt: new Date
-    };
-    let gameResponse;
-    if (isUpdate) {
-      const [updatedGame] = await db2.update(games).set(gameDataForDb).where(eq(games.id, gameId)).returning();
-      if (!updatedGame) {
-        logger5.error("Game update returned no rows", { gameId, slug });
-        throw new InternalError("DB update failed to return result for existing game");
-      }
-      gameResponse = updatedGame;
-    } else {
-      const insertData = {
-        ...gameDataForDb,
-        id: gameId,
-        slug,
-        developerId: user.id,
-        metadata: data.metadata || {},
-        version: data.gameType === "external" ? "external" : "",
-        deploymentUrl: null,
-        createdAt: new Date
-      };
-      const [createdGame] = await db2.insert(games).values(insertData).returning();
-      if (!createdGame) {
-        logger5.error("Game insert returned no rows", { slug, developerId: user.id });
-        throw new InternalError("DB insert failed to return result for new game");
+      if (!game) {
+        throw new NotFoundError("Game", slug);
       }
-      gameResponse = createdGame;
+      this.enforceVisibility(game, caller, slug);
+      return game;
     }
-    if (data.mapElementId) {
-      try {
-        await db2.update(mapElements).set({
-          interactionType: "game_entry",
-          gameId: gameResponse.id
-        }).where(eq(mapElements.id, data.mapElementId));
-      } catch (mapError) {
-        logger5.warn("Failed to update map element", {
-          mapElementId: data.mapElementId,
-          error: mapError
+    async getManifest(gameId, caller) {
+      const game = await this.getById(gameId, caller);
+      if (game.gameType !== "hosted" || !game.deploymentUrl) {
+        throw new BadRequestError("Game does not have a deployment manifest");
+      }
+      const deploymentUrl = GameService2.normalizeDeploymentUrl(game.deploymentUrl);
+      const cacheKey2 = GameService2.getManifestCacheKey(deploymentUrl);
+      const cached = await this.deps.cache.get(cacheKey2);
+      if (cached) {
+        return cached;
+      }
+      const inFlight = inFlightManifestFetches.get(deploymentUrl);
+      if (inFlight) {
+        return inFlight;
+      }
+      const promise = this.fetchManifestFromOrigin({ gameId, deploymentUrl }).then(async (manifest) => {
+        try {
+          await this.deps.cache.set(cacheKey2, manifest, GameService2.MANIFEST_CACHE_TTL_SECONDS);
+        } catch (cacheError) {
+          logger5.warn("Failed to cache game manifest", {
+            gameId,
+            deploymentUrl,
+            cacheKey: cacheKey2,
+            error: cacheError
+          });
+        }
+        return manifest;
+      }).finally(() => {
+        inFlightManifestFetches.delete(deploymentUrl);
+      });
+      inFlightManifestFetches.set(deploymentUrl, promise);
+      return promise;
+    }
+    async fetchManifestFromOrigin(args2) {
+      const { gameId, deploymentUrl } = args2;
+      const manifestUrl = `${deploymentUrl}/playcademy.manifest.json`;
+      const manifestHost = GameService2.getManifestHost(manifestUrl);
+      const startedAt = Date.now();
+      const maxAttempts = GameService2.MANIFEST_FETCH_MAX_RETRIES + 1;
+      for (let attempt = 0;attempt < maxAttempts; attempt++) {
+        const isLastAttempt = attempt === maxAttempts - 1;
+        const outcome = await this.attemptManifestFetch({
+          manifestUrl,
+          manifestHost,
+          deploymentUrl,
+          startedAt,
+          retryCount: attempt
         });
+        if (outcome.kind === "success") {
+          return outcome.manifest;
+        }
+        if (!outcome.retryable || isLastAttempt) {
+          logger5.error("Failed to fetch game manifest", {
+            gameId,
+            manifestUrl,
+            attempt: attempt + 1,
+            maxAttempts,
+            retryable: outcome.retryable,
+            details: outcome.details,
+            throwable: outcome.throwable,
+            cause: outcome.cause
+          });
+          throw outcome.throwable;
+        }
+        const backoffMs = GameService2.getRetryBackoffMs(attempt);
+        logger5.warn("Retrying game manifest fetch after transient failure", {
+          gameId,
+          manifestUrl,
+          attempt: attempt + 1,
+          maxAttempts,
+          backoffMs,
+          details: outcome.details,
+          cause: outcome.cause
+        });
+        await sleep(backoffMs);
       }
+      throw new InternalError("Exhausted manifest fetch retries without result");
     }
-    logger5.info("Upserted game", {
-      gameId: gameResponse.id,
-      slug: gameResponse.slug,
-      operation: isUpdate ? "update" : "create",
-      displayName: gameResponse.displayName
-    });
-    return gameResponse;
-  }
-  async delete(gameId, user) {
-    await this.validateDeveloperAccess(user, gameId);
-    const db2 = this.deps.db;
-    const gameToDelete = await db2.query.games.findFirst({
-      where: eq(games.id, gameId),
-      columns: { id: true, slug: true, displayName: true }
-    });
-    if (!gameToDelete?.slug) {
-      throw new NotFoundError("Game", gameId);
-    }
-    const activeDeployment = await db2.query.gameDeployments.findFirst({
-      where: and(eq(gameDeployments.gameId, gameId), eq(gameDeployments.isActive, true)),
-      columns: { deploymentId: true, provider: true, resources: true }
-    });
-    const customHostnames = await db2.select({
-      hostname: gameCustomHostnames.hostname,
-      cloudflareId: gameCustomHostnames.cloudflareId,
-      environment: gameCustomHostnames.environment
-    }).from(gameCustomHostnames).where(eq(gameCustomHostnames.gameId, gameId));
-    const result = await db2.delete(games).where(eq(games.id, gameId)).returning({ id: games.id });
-    if (result.length === 0) {
-      throw new NotFoundError("Game", gameId);
-    }
-    logger5.info("Deleted game", {
-      gameId: result[0].id,
-      slug: gameToDelete.slug,
-      hadActiveDeployment: Boolean(activeDeployment),
-      customDomainsCount: customHostnames.length
-    });
-    this.deps.alerts.notifyGameDeletion({
-      slug: gameToDelete.slug,
-      displayName: gameToDelete.displayName,
-      developer: { id: user.id, email: user.email }
-    }).catch((error) => {
-      logger5.warn("Failed to send deletion alert", { error });
-    });
-    if (activeDeployment?.provider === "cloudflare" && this.deps.cloudflare) {
+    async attemptManifestFetch(args2) {
+      const { manifestUrl, manifestHost, deploymentUrl, startedAt, retryCount } = args2;
+      function buildDetails(fetchOutcome, manifestErrorKind, extra = {}) {
+        return {
+          manifestUrl,
+          manifestHost,
+          deploymentUrl,
+          fetchOutcome,
+          retryCount,
+          durationMs: Date.now() - startedAt,
+          manifestErrorKind,
+          ...extra
+        };
+      }
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), GameService2.MANIFEST_FETCH_ATTEMPT_TIMEOUT_MS);
+      let response;
       try {
-        await this.deps.cloudflare.delete(activeDeployment.deploymentId, {
-          deleteBindings: true,
-          resources: activeDeployment.resources ?? undefined,
-          customDomains: customHostnames.length > 0 ? customHostnames : undefined,
-          gameSlug: gameToDelete.slug
-        });
-        logger5.info("Cleaned up Cloudflare resources", {
-          gameId,
-          deploymentId: activeDeployment.deploymentId,
-          customDomainsDeleted: customHostnames.length
+        response = await fetch(manifestUrl, {
+          method: "GET",
+          headers: {
+            Accept: "application/json"
+          },
+          signal: controller.signal
         });
-      } catch (cfError) {
-        logger5.warn("Failed to cleanup Cloudflare resources", {
-          gameId,
-          deploymentId: activeDeployment.deploymentId,
-          error: cfError
+      } catch (error) {
+        const fetchErrorMessage = GameService2.getFetchErrorMessage(error);
+        const details = buildDetails("network_error", "temporary", fetchErrorMessage ? { fetchErrorMessage } : {});
+        const throwable = error instanceof Error && error.name === "AbortError" ? new TimeoutError("Timed out loading game manifest", details) : new ServiceUnavailableError("Failed to load game manifest", details);
+        return { kind: "failure", retryable: true, throwable, details, cause: error };
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!response.ok) {
+        const resolvedManifestUrl = response.url || manifestUrl;
+        const resolvedManifestHost = GameService2.getManifestHost(resolvedManifestUrl);
+        const manifestErrorKind = GameService2.isRetryableStatus(response.status) ? "temporary" : "permanent";
+        const details = buildDetails("bad_status", manifestErrorKind, {
+          manifestUrl: resolvedManifestUrl,
+          manifestHost: resolvedManifestHost,
+          status: response.status,
+          contentType: response.headers.get("content-type") ?? undefined,
+          cfRay: response.headers.get("cf-ray") ?? undefined,
+          redirected: response.redirected,
+          ...response.redirected ? {
+            originalManifestUrl: manifestUrl,
+            originalManifestHost: manifestHost
+          } : {}
         });
+        const message = `Failed to fetch manifest: ${response.status} ${response.statusText}`;
+        const throwable = manifestErrorKind === "temporary" ? new ServiceUnavailableError(message, details) : new BadRequestError(message, details);
+        return {
+          kind: "failure",
+          retryable: manifestErrorKind === "temporary",
+          throwable,
+          details
+        };
       }
       try {
-        const deletedKeyId = await this.deps.deleteApiKeyByName(getGameWorkerApiKeyName(gameToDelete.slug), user.id);
-        if (deletedKeyId) {
-          logger5.info("Cleaned up API key for deleted game", {
-            gameId,
-            slug: gameToDelete.slug,
-            keyId: deletedKeyId
+        const manifest = await response.json();
+        return { kind: "success", manifest };
+      } catch (error) {
+        const resolvedManifestUrl = response.url || manifestUrl;
+        const resolvedManifestHost = GameService2.getManifestHost(resolvedManifestUrl);
+        const details = buildDetails("invalid_body", "permanent", {
+          manifestUrl: resolvedManifestUrl,
+          manifestHost: resolvedManifestHost,
+          status: response.status,
+          contentType: response.headers.get("content-type") ?? undefined,
+          cfRay: response.headers.get("cf-ray") ?? undefined,
+          redirected: response.redirected,
+          ...response.redirected ? {
+            originalManifestUrl: manifestUrl,
+            originalManifestHost: manifestHost
+          } : {}
+        });
+        return {
+          kind: "failure",
+          retryable: false,
+          throwable: new BadRequestError("Failed to parse game manifest", details),
+          details,
+          cause: error
+        };
+      }
+    }
+    enforceVisibility(game, caller, lookupIdentifier) {
+      if (game.visibility !== "internal") {
+        return;
+      }
+      const isAdmin = caller?.role === "admin";
+      const isOwner = caller?.id != null && caller.id === game.developerId;
+      if (!isAdmin && !isOwner) {
+        throw new NotFoundError("Game", lookupIdentifier);
+      }
+    }
+    async upsertBySlug(slug, data, user) {
+      const db2 = this.deps.db;
+      const existingGame = await db2.query.games.findFirst({
+        where: eq(games.slug, slug)
+      });
+      const isUpdate = Boolean(existingGame);
+      const gameId = existingGame?.id ?? crypto.randomUUID();
+      if (isUpdate) {
+        await this.validateDeveloperAccess(user, gameId);
+      } else {
+        this.validateDeveloperStatus(user);
+      }
+      const gameDataForDb = {
+        displayName: data.displayName,
+        platform: data.platform,
+        metadata: data.metadata,
+        mapElementId: data.mapElementId,
+        gameType: data.gameType,
+        ...data.visibility && { visibility: data.visibility },
+        externalUrl: data.externalUrl || null,
+        updatedAt: new Date
+      };
+      let gameResponse;
+      if (isUpdate) {
+        const [updatedGame] = await db2.update(games).set(gameDataForDb).where(eq(games.id, gameId)).returning();
+        if (!updatedGame) {
+          logger5.error("Game update returned no rows", { gameId, slug });
+          throw new InternalError("DB update failed to return result for existing game");
+        }
+        gameResponse = updatedGame;
+      } else {
+        const insertData = {
+          ...gameDataForDb,
+          id: gameId,
+          slug,
+          developerId: user.id,
+          metadata: data.metadata || {},
+          version: data.gameType === "external" ? "external" : "",
+          deploymentUrl: null,
+          createdAt: new Date
+        };
+        const [createdGame] = await db2.insert(games).values(insertData).returning();
+        if (!createdGame) {
+          logger5.error("Game insert returned no rows", { slug, developerId: user.id });
+          throw new InternalError("DB insert failed to return result for new game");
+        }
+        gameResponse = createdGame;
+      }
+      if (data.mapElementId) {
+        try {
+          await db2.update(mapElements).set({
+            interactionType: "game_entry",
+            gameId: gameResponse.id
+          }).where(eq(mapElements.id, data.mapElementId));
+        } catch (mapError) {
+          logger5.warn("Failed to update map element", {
+            mapElementId: data.mapElementId,
+            error: mapError
           });
         }
-      } catch (keyError) {
-        logger5.warn("Failed to cleanup API key", { gameId, error: keyError });
       }
+      logger5.info("Upserted game", {
+        gameId: gameResponse.id,
+        slug: gameResponse.slug,
+        operation: isUpdate ? "update" : "create",
+        displayName: gameResponse.displayName
+      });
+      return gameResponse;
     }
-    return {
-      slug: gameToDelete.slug,
-      displayName: gameToDelete.displayName
-    };
-  }
-  async validateOwnership(user, gameId) {
-    if (user.role === "admin") {
-      const gameExists = await this.deps.db.query.games.findFirst({
+    async delete(gameId, user) {
+      await this.validateDeveloperAccess(user, gameId);
+      const db2 = this.deps.db;
+      const gameToDelete = await db2.query.games.findFirst({
         where: eq(games.id, gameId),
-        columns: { id: true }
+        columns: { id: true, slug: true, displayName: true }
       });
-      if (!gameExists) {
+      if (!gameToDelete?.slug) {
         throw new NotFoundError("Game", gameId);
       }
-      return;
+      const activeDeployment = await db2.query.gameDeployments.findFirst({
+        where: and(eq(gameDeployments.gameId, gameId), eq(gameDeployments.isActive, true)),
+        columns: { deploymentId: true, provider: true, resources: true }
+      });
+      const customHostnames = await db2.select({
+        hostname: gameCustomHostnames.hostname,
+        cloudflareId: gameCustomHostnames.cloudflareId,
+        environment: gameCustomHostnames.environment
+      }).from(gameCustomHostnames).where(eq(gameCustomHostnames.gameId, gameId));
+      const result = await db2.delete(games).where(eq(games.id, gameId)).returning({ id: games.id });
+      if (result.length === 0) {
+        throw new NotFoundError("Game", gameId);
+      }
+      logger5.info("Deleted game", {
+        gameId: result[0].id,
+        slug: gameToDelete.slug,
+        hadActiveDeployment: Boolean(activeDeployment),
+        customDomainsCount: customHostnames.length
+      });
+      this.deps.alerts.notifyGameDeletion({
+        slug: gameToDelete.slug,
+        displayName: gameToDelete.displayName,
+        developer: { id: user.id, email: user.email }
+      }).catch((error) => {
+        logger5.warn("Failed to send deletion alert", { error });
+      });
+      if (activeDeployment?.provider === "cloudflare" && this.deps.cloudflare) {
+        try {
+          await this.deps.cloudflare.delete(activeDeployment.deploymentId, {
+            deleteBindings: true,
+            resources: activeDeployment.resources ?? undefined,
+            customDomains: customHostnames.length > 0 ? customHostnames : undefined,
+            gameSlug: gameToDelete.slug
+          });
+          logger5.info("Cleaned up Cloudflare resources", {
+            gameId,
+            deploymentId: activeDeployment.deploymentId,
+            customDomainsDeleted: customHostnames.length
+          });
+        } catch (cfError) {
+          logger5.warn("Failed to cleanup Cloudflare resources", {
+            gameId,
+            deploymentId: activeDeployment.deploymentId,
+            error: cfError
+          });
+        }
+        try {
+          const deletedKeyId = await this.deps.deleteApiKeyByName(getGameWorkerApiKeyName(gameToDelete.slug), user.id);
+          if (deletedKeyId) {
+            logger5.info("Cleaned up API key for deleted game", {
+              gameId,
+              slug: gameToDelete.slug,
+              keyId: deletedKeyId
+            });
+          }
+        } catch (keyError) {
+          logger5.warn("Failed to cleanup API key", { gameId, error: keyError });
+        }
+      }
+      return {
+        slug: gameToDelete.slug,
+        displayName: gameToDelete.displayName
+      };
     }
-    const db2 = this.deps.db;
-    const gameOwnership = await db2.query.games.findFirst({
-      where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
-      columns: { id: true }
-    });
-    if (!gameOwnership) {
-      const gameExists = await db2.query.games.findFirst({
-        where: eq(games.id, gameId),
+    async validateOwnership(user, gameId) {
+      if (user.role === "admin") {
+        const gameExists = await this.deps.db.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        return;
+      }
+      const db2 = this.deps.db;
+      const gameOwnership = await db2.query.games.findFirst({
+        where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
         columns: { id: true }
       });
-      if (!gameExists) {
-        throw new NotFoundError("Game", gameId);
+      if (!gameOwnership) {
+        const gameExists = await db2.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        throw new AccessDeniedError("You do not own this game");
       }
-      throw new AccessDeniedError("You do not own this game");
     }
-  }
-  async validateDeveloperAccess(user, gameId) {
-    this.validateDeveloperStatus(user);
-    if (user.role === "admin") {
-      const gameExists = await this.deps.db.query.games.findFirst({
-        where: eq(games.id, gameId),
+    async validateDeveloperAccess(user, gameId) {
+      this.validateDeveloperStatus(user);
+      if (user.role === "admin") {
+        const gameExists = await this.deps.db.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        return;
+      }
+      const db2 = this.deps.db;
+      const existingGame = await db2.query.games.findFirst({
+        where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
         columns: { id: true }
       });
-      if (!gameExists) {
+      if (!existingGame) {
         throw new NotFoundError("Game", gameId);
       }
-      return;
     }
-    const db2 = this.deps.db;
-    const existingGame = await db2.query.games.findFirst({
-      where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
-      columns: { id: true }
-    });
-    if (!existingGame) {
-      throw new NotFoundError("Game", gameId);
+    async validateGameManagementAccess(user, gameId) {
+      if (user.role === "admin" || user.role === "teacher") {
+        const gameExists = await this.deps.db.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        return;
+      }
+      return this.validateDeveloperAccess(user, gameId);
     }
-  }
-  async validateDeveloperAccessBySlug(user, slug) {
-    this.validateDeveloperStatus(user);
-    const db2 = this.deps.db;
-    if (user.role === "admin") {
-      const game2 = await db2.query.games.findFirst({
-        where: eq(games.slug, slug)
+    async validateDeveloperAccessBySlug(user, slug) {
+      this.validateDeveloperStatus(user);
+      const db2 = this.deps.db;
+      if (user.role === "admin") {
+        const game2 = await db2.query.games.findFirst({
+          where: eq(games.slug, slug)
+        });
+        if (!game2) {
+          throw new NotFoundError("Game", slug);
+        }
+        return game2;
+      }
+      const game = await db2.query.games.findFirst({
+        where: and(eq(games.slug, slug), eq(games.developerId, user.id))
       });
-      if (!game2) {
+      if (!game) {
         throw new NotFoundError("Game", slug);
       }
-      return game2;
-    }
-    const game = await db2.query.games.findFirst({
-      where: and(eq(games.slug, slug), eq(games.developerId, user.id))
-    });
-    if (!game) {
-      throw new NotFoundError("Game", slug);
-    }
-    return game;
-  }
-  validateDeveloperStatus(user) {
-    if (user.role === "admin") {
-      return;
+      return game;
     }
-    if (user.developerStatus !== "approved") {
-      const status = user.developerStatus || "none";
-      if (status === "pending") {
-        throw new AccessDeniedError("Developer application is pending approval. You will be notified when approved.");
-      } else {
-        throw new AccessDeniedError("Developer status required. Apply for developer access to create and manage games.");
+    validateDeveloperStatus(user) {
+      if (user.role === "admin") {
+        return;
+      }
+      if (user.developerStatus !== "approved") {
+        const status = user.developerStatus || "none";
+        if (status === "pending") {
+          throw new AccessDeniedError("Developer application is pending approval. You will be notified when approved.");
+        } else {
+          throw new AccessDeniedError("Developer status required. Apply for developer access to create and manage games.");
+        }
       }
     }
-  }
-}
-var logger5;
-var init_game_service = __esm(() => {
-  init_drizzle_orm();
-  init_tables_index();
-  init_src2();
-  init_errors();
-  init_deployment_util();
-  logger5 = log.scope("GameService");
+  };
 });
 function createGameServices(deps) {
   const { db: db2, config: config2, cloudflare, auth: auth2, storage, cache, alerts } = deps;
   const game = new GameService({
     db: db2,
     alerts,
+    cache,
     cloudflare,
     deleteApiKeyByName: auth2.deleteApiKeyByName.bind(auth2)
   });
@@ -50973,6 +51077,7 @@ function createGameServices(deps) {
     validators: {
       validateDeveloperAccessBySlug: (user, slug) => game.validateDeveloperAccessBySlug(user, slug),
       validateDeveloperAccess: (user, gameId) => game.validateDeveloperAccess(user, gameId),
+      validateGameManagementAccess: (user, gameId) => game.validateGameManagementAccess(user, gameId),
       validateOwnership: (user, gameId) => game.validateOwnership(user, gameId)
     }
   };
@@ -52598,7 +52703,8 @@ var init_constants3 = __esm(() => {
     HEALTH: "/api/health",
     TIMEBACK: {
       END_ACTIVITY: `/api${TIMEBACK_ROUTES.END_ACTIVITY}`,
-      GET_XP: `/api${TIMEBACK_ROUTES.GET_XP}`
+      GET_XP: `/api${TIMEBACK_ROUTES.GET_XP}`,
+      HEARTBEAT: `/api${TIMEBACK_ROUTES.HEARTBEAT}`
     }
   };
 });
@@ -52736,7 +52842,8 @@ class SeedService {
         PLAYCADEMY_BASE_URL: ""
       }, {
         bindings: { d1: [deploymentId], r2: [], kv: [] },
-        keepAssets: false
+        keepAssets: false,
+        compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
       });
       logger14.info("Worker deployed", { seedDeploymentId, url: result.url });
       if (secrets && Object.keys(secrets).length > 0) {
@@ -52866,6 +52973,7 @@ class SeedService {
 }
 var logger14;
 var init_seed_service = __esm(() => {
+  init_src();
   init_setup2();
   init_src2();
   init_config2();
@@ -54090,6 +54198,36 @@ var init_pure = __esm(() => {
 var init_src4 = __esm(() => {
   init_pure();
 });
+function toAttributionEventTime(date3) {
+  if (!date3) {
+    return;
+  }
+  const match = date3.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) {
+    throw new ValidationError("Date must be in YYYY-MM-DD format");
+  }
+  const [, yearStr, monthStr, dayStr] = match;
+  const year = Number(yearStr);
+  const month = Number(monthStr);
+  const day = Number(dayStr);
+  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
+    throw new ValidationError("Date must be in YYYY-MM-DD format");
+  }
+  const eventTime = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
+  if (eventTime.getUTCFullYear() !== year || eventTime.getUTCMonth() + 1 !== month || eventTime.getUTCDate() !== day) {
+    throw new ValidationError("Date must be a valid calendar date");
+  }
+  return eventTime.toISOString();
+}
+function resolveAdminEventTime(data) {
+  if (data.useCurrentTime) {
+    return new Date().toISOString();
+  }
+  return toAttributionEventTime(data.date);
+}
+var init_timeback_admin_util = __esm(() => {
+  init_errors();
+});
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -54134,14 +54272,6 @@ function getPlaycademyMetadata(event) {
   const extensions = getMergedCaliperExtensions(event);
   return isRecord2(extensions.playcademy) ? extensions.playcademy : undefined;
 }
-function getAssessmentPlaycademyMetadata(assessment) {
-  return isRecord2(assessment.metadata?.playcademy) ? assessment.metadata.playcademy : undefined;
-}
-function isRemediationAssessmentResult(assessment) {
-  const playcademy = getAssessmentPlaycademyMetadata(assessment);
-  const eventKind = getStringValue(playcademy?.eventKind);
-  return eventKind === "remediation-xp" || eventKind === "remediation-time" || eventKind === "remediation-mastery";
-}
 function getActivityId(event, playcademy) {
   const metadataActivityId = getStringValue(playcademy?.activityId);
   if (metadataActivityId) {
@@ -54158,8 +54288,8 @@ function getActivityId(event, playcademy) {
   const trimmed = objectId.replace(/\/$/, "");
   const segments = trimmed.split("/");
   const activityIndex = segments.lastIndexOf("activities");
-  if (activityIndex !== -1 && segments.length >= activityIndex + 4) {
-    const candidate = segments[activityIndex + 3];
+  if (activityIndex !== -1 && segments.length >= activityIndex + 3) {
+    const candidate = segments[activityIndex + 2];
     return candidate ? decodeURIComponent(candidate) : undefined;
   }
   return;
@@ -54212,38 +54342,96 @@ function mapAssessmentsToXpEvents(userId, assessments) {
     };
   });
 }
-function isMasteryCompletionEntry(assessment) {
-  return isRecord2(assessment.metadata) && assessment.metadata.isMasteryCompletion === true;
+function getDurationSecondsFromExtensions(event) {
+  const extensions = getMergedCaliperExtensions(event);
+  const playcademy = isRecord2(extensions.playcademy) ? extensions.playcademy : undefined;
+  const rawValue = extensions.durationSeconds ?? playcademy?.durationSeconds;
+  const value = typeof rawValue === "number" ? rawValue : Number(rawValue);
+  return Number.isFinite(value) ? value : undefined;
+}
+function getCanonicalRunId(session2) {
+  const sessionId = getStringValue(session2?.id);
+  if (!sessionId) {
+    return;
+  }
+  return sessionId.replace(/^urn:uuid:/, "");
+}
+function getResumeId(event) {
+  const playcademy = getPlaycademyMetadata(event);
+  return getStringValue(playcademy?.resumeId);
 }
-function mapAssessmentResultToRecentActivity(assessment, relevantCourseIds, courseIdByLineItemId) {
-  if (!assessment.scoreDate || !assessment.assessmentLineItem?.sourcedId) {
+function isCaliperRemediationOrCompletionEvent(event) {
+  const playcademy = getPlaycademyMetadata(event);
+  return REMEDIATION_OR_COMPLETION_EVENT_KINDS.has(getStringValue(playcademy?.eventKind) || "");
+}
+function groupCaliperEventsByRun(events) {
+  const groups = new Map;
+  for (const event of events) {
+    const objectId = getStringValue(event.object.id) || "unknown-activity";
+    const groupKey = `${objectId}::${getStringValue(event.session?.id) || event.externalId}`;
+    const existing = groups.get(groupKey);
+    if (existing) {
+      existing.push(event);
+    } else {
+      groups.set(groupKey, [event]);
+    }
+  }
+  return groups;
+}
+function mapCaliperEventGroupToActivity(events, relevantCourseIds) {
+  if (events.length === 0) {
     return null;
   }
-  if (isRemediationAssessmentResult(assessment)) {
+  const sortedEvents = events.toSorted((a, b) => a.eventTime.localeCompare(b.eventTime));
+  const activityEvent = [...sortedEvents].toReversed().find((event) => event.type === "ActivityEvent");
+  const contextSource = activityEvent || sortedEvents.at(-1);
+  if (!contextSource) {
     return null;
   }
-  const courseId = courseIdByLineItemId?.get(assessment.assessmentLineItem.sourcedId) || [...relevantCourseIds].find((course) => assessment.assessmentLineItem.sourcedId.startsWith(`${course}-`));
-  if (!courseId) {
+  const ctx = parseCaliperEventContext(contextSource, relevantCourseIds);
+  if (!ctx) {
     return null;
   }
-  if (isMasteryCompletionEntry(assessment)) {
+  const score = activityEvent !== undefined ? (() => {
+    const totalQuestions = getGeneratedMetricValue(activityEvent, "totalQuestions");
+    const correctQuestions = getGeneratedMetricValue(activityEvent, "correctQuestions");
+    if (totalQuestions === undefined || correctQuestions === undefined || totalQuestions <= 0) {
+      return;
+    }
+    return correctQuestions / totalQuestions * 100;
+  })() : undefined;
+  const xpEarned = activityEvent !== undefined ? getGeneratedMetricValue(activityEvent, "xpEarned") : undefined;
+  const masteredUnits = activityEvent !== undefined ? getGeneratedMetricValue(activityEvent, "masteredUnits") : undefined;
+  const timeSpentEvents = sortedEvents.filter((event) => event.type === "TimeSpentEvent");
+  let totalActiveTimeSeconds;
+  if (timeSpentEvents.length > 0) {
+    totalActiveTimeSeconds = timeSpentEvents.reduce((sum2, event) => sum2 + (getGeneratedMetricValue(event, "active") ?? 0), 0);
+  } else if (activityEvent !== undefined) {
+    totalActiveTimeSeconds = getDurationSecondsFromExtensions(activityEvent);
+  }
+  const fallbackActivityId = getActivityId(contextSource, getPlaycademyMetadata(contextSource));
+  const occurredAt = getStringValue(activityEvent?.eventTime) || getStringValue(sortedEvents.at(-1)?.eventTime);
+  const runId = getCanonicalRunId(contextSource.session);
+  const resumeIds = new Set(sortedEvents.map((event) => getResumeId(event)).filter((resumeId) => resumeId !== undefined));
+  const sessionCount = resumeIds.size > 0 ? resumeIds.size : 1;
+  const kind = activityEvent !== undefined ? "activity" : "activity-in-progress";
+  if (!occurredAt) {
     return null;
   }
-  const metadata2 = isRecord2(assessment.metadata) ? assessment.metadata : undefined;
-  const activityName = getStringValue(metadata2?.activityName);
-  const xpEarned = typeof metadata2?.xp === "number" && Number.isFinite(metadata2.xp) ? metadata2.xp : undefined;
-  const masteredUnits = typeof metadata2?.masteredUnits === "number" && Number.isFinite(metadata2.masteredUnits) ? metadata2.masteredUnits : undefined;
-  const durationSeconds = typeof metadata2?.durationSeconds === "number" && Number.isFinite(metadata2.durationSeconds) ? metadata2.durationSeconds : undefined;
   return {
-    id: assessment.sourcedId || `${assessment.assessmentLineItem.sourcedId}:${assessment.scoreDate}`,
-    kind: "activity",
-    occurredAt: assessment.scoreDate,
-    courseId,
-    title: activityName || "Activity completed",
-    ...typeof assessment.score === "number" ? { score: assessment.score } : {},
+    id: activityEvent?.externalId || sortedEvents.at(-1)?.externalId || events[0].externalId,
+    kind,
+    occurredAt,
+    courseId: ctx.courseId,
+    title: getStringValue(activityEvent?.object.activity?.name) || ctx.titleFromEvent || (fallbackActivityId ? kebabToTitleCase(fallbackActivityId) : "Activity completed"),
+    ...ctx.activityId ? { activityId: ctx.activityId } : {},
+    ...ctx.appName ? { appName: ctx.appName } : {},
+    ...score !== undefined ? { score } : {},
     ...xpEarned !== undefined ? { xpDelta: xpEarned } : {},
     ...masteredUnits !== undefined ? { masteredUnitsDelta: masteredUnits } : {},
-    ...durationSeconds !== undefined ? { timeDeltaSeconds: durationSeconds } : {}
+    ...totalActiveTimeSeconds !== undefined ? { timeDeltaSeconds: totalActiveTimeSeconds } : {},
+    ...runId ? { runId } : {},
+    ...sessionCount > 0 ? { sessionCount } : {}
   };
 }
 function parseCaliperEventContext(event, relevantCourseIds) {
@@ -54351,8 +54539,16 @@ function mapCaliperEventToRemediationActivity(event, relevantCourseIds) {
   }
   return null;
 }
+var REMEDIATION_OR_COMPLETION_EVENT_KINDS;
 var init_timeback_util = __esm(() => {
   init_types4();
+  REMEDIATION_OR_COMPLETION_EVENT_KINDS = new Set([
+    "remediation-xp",
+    "remediation-time",
+    "remediation-mastery",
+    "course-completed",
+    "course-resumed"
+  ]);
 });
 
 class TimebackAdminService {
@@ -54361,11 +54557,9 @@ class TimebackAdminService {
   static RECENT_ACTIVITY_LIMIT = 20;
   static MAX_STUDENT_ACTIVITY_LIMIT = 200;
   static MAX_STUDENT_ACTIVITY_OFFSET = 1000;
+  static MAX_RECENT_ACTIVITY_EVENT_FETCH = 4000;
   static ANALYTICS_CONCURRENCY = 8;
   static MASTERABLE_UNITS_CONCURRENCY = 4;
-  static RECENT_ACTIVITY_FETCH_CONCURRENCY = 4;
-  static ASSESSMENT_LINE_ITEM_PAGE_SIZE = 1000;
-  static ASSESSMENT_RESULT_LINE_ITEM_CHUNK_SIZE = 20;
   constructor(deps) {
     this.deps = deps;
   }
@@ -54373,27 +54567,6 @@ class TimebackAdminService {
     const rounded = Math.round(value * TimebackAdminService.XP_PRECISION_FACTOR) / TimebackAdminService.XP_PRECISION_FACTOR;
     return Object.is(rounded, -0) ? 0 : rounded;
   }
-  static toAttributionEventTime(date3) {
-    if (!date3) {
-      return;
-    }
-    const match = date3.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-    if (!match) {
-      throw new ValidationError("Date must be in YYYY-MM-DD format");
-    }
-    const [, yearStr, monthStr, dayStr] = match;
-    const year = Number(yearStr);
-    const month = Number(monthStr);
-    const day = Number(dayStr);
-    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
-      throw new ValidationError("Date must be in YYYY-MM-DD format");
-    }
-    const eventTime = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
-    if (eventTime.getUTCFullYear() !== year || eventTime.getUTCMonth() + 1 !== month || eventTime.getUTCDate() !== day) {
-      throw new ValidationError("Date must be a valid calendar date");
-    }
-    return eventTime.toISOString();
-  }
   requireClient() {
     if (!this.deps.timeback) {
       logger16.error("Timeback client not available in context");
@@ -54412,9 +54585,13 @@ class TimebackAdminService {
       });
     });
   }
-  async resolveAdminMutationContext(gameId, courseId, user, studentId) {
+  async resolveAdminMutationContext(gameId, courseId, user, studentId, accessLevel = "developer") {
     const client = this.requireClient();
-    await this.deps.validateDeveloperAccess(user, gameId);
+    if (accessLevel === "dashboard") {
+      await this.deps.validateGameManagementAccess(user, gameId);
+    } else {
+      await this.deps.validateDeveloperAccess(user, gameId);
+    }
     const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
       where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
     });
@@ -54537,7 +54714,7 @@ class TimebackAdminService {
       throw new ValidationError(`Game "${game.slug}" has an invalid deploymentUrl: ${game.deploymentUrl}`);
     }
   }
-  async getGameSensorUrl(gameId) {
+  async getGameActivitySource(gameId) {
     const game = await this.deps.db.query.games.findFirst({
       where: eq(games.id, gameId),
       columns: { slug: true, deploymentUrl: true }
@@ -54545,7 +54722,17 @@ class TimebackAdminService {
     if (!game) {
       throw new NotFoundError("Game", gameId);
     }
-    return this.deriveGameSensorUrl(game);
+    return {
+      gameId,
+      sensorUrl: this.deriveGameSensorUrl(game),
+      sourceMode: this.deps.config.isLocal ? "development" : "production"
+    };
+  }
+  static mapRecentActivityItems(events, relevantCourseIds) {
+    const gameplayEvents = events.filter((event) => (event.type === "ActivityEvent" || event.type === "TimeSpentEvent") && !isCaliperRemediationOrCompletionEvent(event));
+    const groupedGameplayItems = [...groupCaliperEventsByRun(gameplayEvents).values()].map((group) => mapCaliperEventGroupToActivity(group, relevantCourseIds)).filter((item) => Boolean(item));
+    const remediationItems = events.map((event) => mapCaliperEventToRemediationActivity(event, relevantCourseIds)).filter((item) => Boolean(item));
+    return [...groupedGameplayItems, ...remediationItems].toSorted((a, b) => b.occurredAt.localeCompare(a.occurredAt));
   }
   async getStudentEnrollmentsByCourseId(client, studentId, courseIds) {
     const relevantCourseIds = new Set(courseIds);
@@ -54576,105 +54763,35 @@ class TimebackAdminService {
     });
     return new Map(results);
   }
-  async listAssessmentLineItemCourseMap(client, relevantCourseIds) {
-    const lineItemEntries = await TimebackAdminService.runWithConcurrency([...relevantCourseIds], TimebackAdminService.RECENT_ACTIVITY_FETCH_CONCURRENCY, async (courseId) => {
-      const entries = [];
-      let offset = 0;
-      try {
-        while (true) {
-          const items2 = await client.oneroster.assessmentLineItems.list({
-            limit: TimebackAdminService.ASSESSMENT_LINE_ITEM_PAGE_SIZE,
-            offset,
-            filter: `course.sourcedId='${escapeFilterValue(courseId)}'`,
-            fields: "sourcedId,course"
-          });
-          for (const item of items2) {
-            if (item.sourcedId) {
-              entries.push([
-                item.sourcedId,
-                item.course?.sourcedId || courseId
-              ]);
-            }
-          }
-          if (items2.length < TimebackAdminService.ASSESSMENT_LINE_ITEM_PAGE_SIZE) {
-            break;
-          }
-          offset += TimebackAdminService.ASSESSMENT_LINE_ITEM_PAGE_SIZE;
-        }
-      } catch (error) {
-        logger16.warn("Failed to load assessment line items for course", {
-          courseId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-      return entries;
-    });
-    return new Map(lineItemEntries.flat());
-  }
-  static buildAssessmentResultsFilter(studentId, lineItemIds) {
-    const studentFilter = `student.sourcedId='${escapeFilterValue(studentId)}'`;
-    if (lineItemIds.length === 1) {
-      return `${studentFilter} AND assessmentLineItem.sourcedId='${escapeFilterValue(lineItemIds[0])}'`;
-    }
-    return `${studentFilter} AND assessmentLineItem.sourcedId@'${lineItemIds.map(escapeFilterValue).join(",")}'`;
-  }
-  async listRecentAssessmentResultsForStudent(client, studentId, courseIdByLineItemId, perChunkLimit = TimebackAdminService.RECENT_ACTIVITY_LIMIT) {
-    const lineItemIds = [...courseIdByLineItemId.keys()];
-    if (lineItemIds.length === 0) {
-      return [];
-    }
-    const resultPages = await TimebackAdminService.runWithConcurrency(TimebackAdminService.chunkItems(lineItemIds, TimebackAdminService.ASSESSMENT_RESULT_LINE_ITEM_CHUNK_SIZE), TimebackAdminService.RECENT_ACTIVITY_FETCH_CONCURRENCY, async (lineItemChunk) => {
-      try {
-        return await client.oneroster.assessmentResults.list({
-          limit: perChunkLimit,
-          sort: "scoreDate",
-          orderBy: "desc",
-          fields: "sourcedId,assessmentLineItem,score,scoreDate,metadata",
-          filter: TimebackAdminService.buildAssessmentResultsFilter(studentId, lineItemChunk)
-        });
-      } catch (error) {
-        logger16.warn("Failed to load recent assessment results for student", {
-          studentId,
-          lineItemCount: lineItemChunk.length,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return [];
-      }
-    });
-    const uniqueResults = new Map;
-    for (const result of resultPages.flat()) {
-      const key = result.sourcedId || `${result.assessmentLineItem?.sourcedId || "unknown"}:${result.scoreDate || ""}`;
-      uniqueResults.set(key, result);
-    }
-    return [...uniqueResults.values()].toSorted((a, b) => (b.scoreDate || "").localeCompare(a.scoreDate || "")).slice(0, perChunkLimit);
-  }
-  async listRecentActivityForStudent(client, studentId, sensorUrl, relevantCourseIds, maxResults = TimebackAdminService.RECENT_ACTIVITY_LIMIT) {
+  async listRecentActivityForStudent(client, studentId, source, relevantCourseIds, maxResults = TimebackAdminService.RECENT_ACTIVITY_LIMIT) {
     if (relevantCourseIds.size === 0) {
       return [];
     }
-    const courseIdByLineItemId = await this.listAssessmentLineItemCourseMap(client, relevantCourseIds);
-    const assessments = await this.listRecentAssessmentResultsForStudent(client, studentId, courseIdByLineItemId, maxResults);
-    const assessmentRecentItems = assessments.map((assessment) => mapAssessmentResultToRecentActivity(assessment, relevantCourseIds, courseIdByLineItemId)).filter((activity) => Boolean(activity));
-    let caliperRecentItems = [];
     try {
       const actorId = `${client.getBaseUrl().replace(/\/$/, "")}/ims/oneroster/rostering/v1p2/users/${studentId}`;
+      const eventLimit = Math.min(Math.max(200, maxResults * 20), TimebackAdminService.MAX_RECENT_ACTIVITY_EVENT_FETCH);
       const { events } = await client.caliper.events.list({
-        limit: Math.max(100, maxResults),
+        limit: eventLimit,
         actorId,
-        sensor: sensorUrl
+        ...source.sourceMode === "production" ? { sensor: source.sensorUrl } : {},
+        extensions: {
+          gameId: source.gameId
+        }
       });
-      caliperRecentItems = events.map((event) => mapCaliperEventToRemediationActivity(event, relevantCourseIds)).filter((item) => Boolean(item));
+      return TimebackAdminService.mapRecentActivityItems(events, relevantCourseIds).slice(0, maxResults);
     } catch (error) {
       logger16.warn("Failed to load recent Caliper activity", {
         studentId,
+        gameId: source.gameId,
+        sourceMode: source.sourceMode,
         error: error instanceof Error ? error.message : String(error)
       });
+      return [];
     }
-    return [...assessmentRecentItems, ...caliperRecentItems].toSorted((a, b) => b.occurredAt.localeCompare(a.occurredAt)).slice(0, maxResults);
   }
   async listStudentsForCourse(gameId, courseId, user) {
     const client = this.requireClient();
-    await this.deps.validateDeveloperAccess(user, gameId);
+    await this.deps.validateGameManagementAccess(user, gameId);
     const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
       where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
     });
@@ -54712,7 +54829,7 @@ class TimebackAdminService {
   }
   async getStudentOverview(gameId, studentId, user, courseId) {
     const client = this.requireClient();
-    await this.deps.validateDeveloperAccess(user, gameId);
+    await this.deps.validateGameManagementAccess(user, gameId);
     const integrations = await this.deps.db.query.gameTimebackIntegrations.findMany({
       where: courseId ? and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId)) : eq(gameTimebackIntegrations.gameId, gameId)
     });
@@ -54766,12 +54883,12 @@ class TimebackAdminService {
     const client = this.requireClient();
     const safeLimit = Math.max(1, Math.min(limit, TimebackAdminService.MAX_STUDENT_ACTIVITY_LIMIT));
     const safeOffset = Math.max(0, Math.min(offset, TimebackAdminService.MAX_STUDENT_ACTIVITY_OFFSET));
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const [integration, sensorUrl] = await Promise.all([
+    await this.deps.validateGameManagementAccess(user, gameId);
+    const [integration, gameSource] = await Promise.all([
       this.deps.db.query.gameTimebackIntegrations.findFirst({
         where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
       }),
-      this.getGameSensorUrl(gameId)
+      this.getGameActivitySource(gameId)
     ]);
     if (!integration) {
       throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
@@ -54779,7 +54896,7 @@ class TimebackAdminService {
     await this.assertStudentEnrolledInCourse(client, studentId, courseId);
     const relevantCourseIds = new Set([courseId]);
     const fetchLimit = Math.min(safeOffset + safeLimit + 1, TimebackAdminService.MAX_STUDENT_ACTIVITY_OFFSET + TimebackAdminService.MAX_STUDENT_ACTIVITY_LIMIT + 1);
-    const allActivities = await this.listRecentActivityForStudent(client, studentId, sensorUrl, relevantCourseIds, fetchLimit);
+    const allActivities = await this.listRecentActivityForStudent(client, studentId, gameSource, relevantCourseIds, fetchLimit);
     const activities = allActivities.slice(safeOffset, safeOffset + safeLimit);
     const hasMore = allActivities.length > safeOffset + safeLimit;
     return { activities, hasMore };
@@ -54791,7 +54908,7 @@ class TimebackAdminService {
       courseId: data.courseId,
       studentId: data.studentId,
       xpEarned: data.xp,
-      eventTime: TimebackAdminService.toAttributionEventTime(data.date),
+      eventTime: resolveAdminEventTime(data),
       reason: data.reason,
       actor,
       appName,
@@ -54806,7 +54923,7 @@ class TimebackAdminService {
       courseId: data.courseId,
       studentId: data.studentId,
       activeTimeSeconds: data.seconds,
-      eventTime: TimebackAdminService.toAttributionEventTime(data.date),
+      eventTime: resolveAdminEventTime(data),
       reason: data.reason,
       actor,
       appName,
@@ -54821,7 +54938,7 @@ class TimebackAdminService {
       courseId: data.courseId,
       studentId: data.studentId,
       masteredUnits: data.units,
-      eventTime: TimebackAdminService.toAttributionEventTime(data.date),
+      eventTime: resolveAdminEventTime(data),
       reason: data.reason,
       actor,
       appName,
@@ -54830,7 +54947,7 @@ class TimebackAdminService {
     return { status: "ok" };
   }
   async toggleCourseCompletion(data, user) {
-    const { client, sensorUrl, appName, actor } = await this.resolveAdminMutationContext(data.gameId, data.courseId, user, data.studentId);
+    const { client, sensorUrl, appName, actor } = await this.resolveAdminMutationContext(data.gameId, data.courseId, user, data.studentId, "dashboard");
     const historyClient = client;
     const ids = deriveSourcedIds(data.courseId);
     const lineItemId = `${ids.course}-mastery-completion-assessment`;
@@ -54923,6 +55040,77 @@ class TimebackAdminService {
     }
     return { status: "ok" };
   }
+  async searchStudentsForEnrollment(gameId, courseId, query, user) {
+    const client = this.requireClient();
+    await this.deps.validateGameManagementAccess(user, gameId);
+    const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
+      where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
+    });
+    if (!integration) {
+      throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
+    }
+    const trimmedQuery = query.trim();
+    if (trimmedQuery.length < 2) {
+      return { students: [] };
+    }
+    const filterParts = [
+      `givenName~'${escapeFilterValue(trimmedQuery)}'`,
+      `familyName~'${escapeFilterValue(trimmedQuery)}'`,
+      `email~'${escapeFilterValue(trimmedQuery)}'`
+    ];
+    const filter = filterParts.join(" OR ");
+    const params = new URLSearchParams({ filter, limit: "25" });
+    const endpoint = `/ims/oneroster/rostering/v1p2/users?${params}`;
+    let allUsers = [];
+    try {
+      const response = await client["request"](endpoint, "GET");
+      allUsers = response.users || [];
+    } catch (error) {
+      logger16.warn("Failed to search OneRoster users", {
+        query: trimmedQuery,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return { students: [] };
+    }
+    const roster = await client.oneroster.enrollments.listByCourse(courseId, {
+      role: "student",
+      includeUsers: false
+    });
+    const enrolledStudentIds = new Set(roster.map((entry) => entry.enrollment.user.sourcedId));
+    const students = allUsers.filter((entry) => Boolean(entry.sourcedId) && entry.roles?.some((role) => role.role === "student") === true).map((entry) => ({
+      studentId: entry.sourcedId,
+      name: `${entry.givenName || ""} ${entry.familyName || ""}`.trim() || entry.sourcedId,
+      email: entry.email || null,
+      alreadyEnrolled: enrolledStudentIds.has(entry.sourcedId)
+    }));
+    return { students };
+  }
+  async enrollStudent(data, user) {
+    const client = this.requireClient();
+    await this.deps.validateGameManagementAccess(user, data.gameId);
+    const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
+      where: and(eq(gameTimebackIntegrations.gameId, data.gameId), eq(gameTimebackIntegrations.courseId, data.courseId))
+    });
+    if (!integration) {
+      throw new NotFoundError("Timeback integration", `${data.gameId}:${data.courseId}`);
+    }
+    await client.edubridge.enrollments.enroll(data.studentId, data.courseId, {
+      role: "student"
+    });
+    return { status: "ok" };
+  }
+  async unenrollStudent(data, user) {
+    const client = this.requireClient();
+    await this.deps.validateGameManagementAccess(user, data.gameId);
+    const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
+      where: and(eq(gameTimebackIntegrations.gameId, data.gameId), eq(gameTimebackIntegrations.courseId, data.courseId))
+    });
+    if (!integration) {
+      throw new NotFoundError("Timeback integration", `${data.gameId}:${data.courseId}`);
+    }
+    await client.edubridge.enrollments.unenroll(data.studentId, data.courseId);
+    return { status: "ok" };
+  }
   async getCompletionStatus(client, courseId, studentId) {
     const ids = deriveSourcedIds(courseId);
     const lineItemId = `${ids.course}-mastery-completion-assessment`;
@@ -54961,17 +55149,6 @@ class TimebackAdminService {
     }));
     return results;
   }
-  static chunkItems(items2, chunkSize) {
-    if (items2.length === 0) {
-      return [];
-    }
-    const effectiveChunkSize = Math.max(1, chunkSize);
-    const chunks = [];
-    for (let index2 = 0;index2 < items2.length; index2 += effectiveChunkSize) {
-      chunks.push(items2.slice(index2, index2 + effectiveChunkSize));
-    }
-    return chunks;
-  }
 }
 var logger16;
 var init_timeback_admin_service = __esm(() => {
@@ -54983,593 +55160,739 @@ var init_timeback_admin_service = __esm(() => {
   init_utils6();
   init_src4();
   init_errors();
+  init_timeback_admin_util();
   init_timeback_util();
   logger16 = log.scope("TimebackAdminService");
 });
-
-class TimebackService {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  requireClient() {
-    if (!this.deps.timeback) {
-      logger17.error("Timeback client not available in context");
-      throw new ValidationError("Timeback integration not available in this environment");
+var logger17;
+var TimebackService;
+var init_timeback_service = __esm(() => {
+  init_drizzle_orm();
+  init_src();
+  init_tables_index();
+  init_src2();
+  init_types4();
+  init_src4();
+  init_errors();
+  init_timeback_util();
+  logger17 = log.scope("TimebackService");
+  TimebackService = class TimebackService2 {
+    static HEARTBEAT_DEDUPE_TTL_MS = 300000;
+    static processedHeartbeatWindows = new Map;
+    static inFlightHeartbeatWindows = new Map;
+    deps;
+    static cleanHeartbeatDedupeCache(now2 = Date.now()) {
+      for (const [key, timestamp3] of this.processedHeartbeatWindows) {
+        if (now2 - timestamp3 > this.HEARTBEAT_DEDUPE_TTL_MS) {
+          this.processedHeartbeatWindows.delete(key);
+        }
+      }
     }
-    return this.deps.timeback;
-  }
-  async getTodayXp(userId, date3, timezone2) {
-    const db2 = this.deps.db;
-    const tz = timezone2 || PLATFORM_TIMEZONE;
-    const base = date3 ? new Date(date3) : new Date;
-    if (isNaN(base.getTime())) {
-      throw new ValidationError("Invalid date format. Use ISO 8601 format.");
+    static isDuplicateHeartbeatWindow(key) {
+      this.cleanHeartbeatDedupeCache();
+      return this.processedHeartbeatWindows.has(key);
     }
-    try {
-      new Intl.DateTimeFormat(undefined, { timeZone: tz });
-    } catch {
-      throw new ValidationError(`Invalid timezone: ${tz}`);
+    static getInFlightHeartbeatWindow(key) {
+      return this.inFlightHeartbeatWindows.get(key);
     }
-    if (tz === PLATFORM_TIMEZONE) {
-      const todayMidnight = getUtcInstantForMidnight(base, tz);
-      const result2 = await db2.select({ xp: timebackDailyXp.xp, date: timebackDailyXp.date }).from(timebackDailyXp).where(and(eq(timebackDailyXp.userId, userId), eq(timebackDailyXp.date, todayMidnight))).limit(1);
-      if (result2.length === 0) {
-        return { xp: 0, date: todayMidnight.toISOString() };
-      }
-      return { xp: result2[0].xp, date: result2[0].date.toISOString() };
+    static markHeartbeatWindowProcessed(key) {
+      this.processedHeartbeatWindows.set(key, Date.now());
     }
-    const { startOfDay, endOfDay } = getDayBoundariesInTimezone(base, tz);
-    const result = await db2.select({ totalXp: sum(timebackXpEvents.xpDelta) }).from(timebackXpEvents).where(and(eq(timebackXpEvents.userId, userId), gte(timebackXpEvents.occurredAt, startOfDay), lte(timebackXpEvents.occurredAt, new Date(endOfDay.getTime() - 1))));
-    return { xp: Number(result[0]?.totalXp) || 0, date: startOfDay.toISOString() };
-  }
-  async getTotalXp(userId) {
-    const db2 = this.deps.db;
-    const result = await db2.select({ totalXp: sum(timebackDailyXp.xp) }).from(timebackDailyXp).where(eq(timebackDailyXp.userId, userId));
-    return { totalXp: Number(result[0]?.totalXp) || 0 };
-  }
-  async updateTodayXp(userId, data) {
-    const db2 = this.deps.db;
-    const { xp, userTimestamp } = data;
-    let targetDate;
-    if (userTimestamp) {
-      targetDate = new Date(userTimestamp);
-      if (isNaN(targetDate.getTime())) {
-        throw new ValidationError("Invalid userTimestamp format. Use ISO 8601 format.");
-      }
-      targetDate.setHours(0, 0, 0, 0);
-    } else {
-      targetDate = new Date;
-      targetDate.setUTCHours(0, 0, 0, 0);
+    static markHeartbeatWindowInFlight(key, promise) {
+      this.inFlightHeartbeatWindows.set(key, promise);
     }
-    const [result] = await db2.insert(timebackDailyXp).values({ userId, date: targetDate, xp }).onConflictDoUpdate({
-      target: [timebackDailyXp.userId, timebackDailyXp.date],
-      set: { xp: sql`excluded.xp`, updatedAt: new Date }
-    }).returning({ xp: timebackDailyXp.xp, date: timebackDailyXp.date });
-    if (!result) {
-      logger17.error("Daily XP upsert returned no rows", { userId, date: targetDate });
-      throw new InternalError("Failed to update daily XP record");
+    static clearInFlightHeartbeatWindow(key) {
+      this.inFlightHeartbeatWindows.delete(key);
     }
-    return { xp: result.xp, date: result.date.toISOString() };
-  }
-  async getXpHistory(userId, startDate, endDate) {
-    const db2 = this.deps.db;
-    const whereConditions = [eq(timebackDailyXp.userId, userId)];
-    if (startDate) {
-      const start2 = new Date(startDate);
-      start2.setUTCHours(0, 0, 0, 0);
-      whereConditions.push(gte(timebackDailyXp.date, start2));
+    static addResumeIdToExtensions(extensions, resumeId) {
+      const base = extensions ?? {};
+      const existingPlaycademy = base.playcademy;
+      const playcademy = typeof existingPlaycademy === "object" && existingPlaycademy !== null && !Array.isArray(existingPlaycademy) ? existingPlaycademy : {};
+      return {
+        ...base,
+        playcademy: {
+          ...playcademy,
+          resumeId
+        }
+      };
     }
-    if (endDate) {
-      const end = new Date(endDate);
-      end.setUTCHours(23, 59, 59, 999);
-      whereConditions.push(lte(timebackDailyXp.date, end));
+    constructor(deps) {
+      this.deps = deps;
     }
-    const result = await db2.select({ date: timebackDailyXp.date, xp: timebackDailyXp.xp }).from(timebackDailyXp).where(and(...whereConditions)).orderBy(timebackDailyXp.date);
-    return {
-      history: result.map((row) => ({ date: row.date.toISOString(), xp: row.xp }))
-    };
-  }
-  async populateStudent(user, providedNames) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    const dbUser = await db2.query.users.findFirst({
-      where: eq(users.id, user.id),
-      columns: { id: true, timebackId: true }
-    });
-    if (dbUser?.timebackId) {
-      logger17.info("Student already onboarded", { userId: user.id });
-      return { status: "already_populated" };
+    requireClient() {
+      if (!this.deps.timeback) {
+        logger17.error("Timeback client not available in context");
+        throw new ValidationError("Timeback integration not available in this environment");
+      }
+      return this.deps.timeback;
     }
-    let timebackId;
-    let name3;
-    try {
-      const existingUser = await client.oneroster.users.findByEmail(user.email);
-      timebackId = existingUser.sourcedId;
-      name3 = `${existingUser.givenName} ${existingUser.familyName}`;
-      logger17.info("Found existing student in OneRoster", {
-        userId: user.id,
-        timebackId
-      });
-    } catch {
-      if (!providedNames?.firstName || !providedNames?.lastName) {
-        return { status: "no_record" };
+    async getTodayXp(userId, date3, timezone2) {
+      const db2 = this.deps.db;
+      const tz = timezone2 || PLATFORM_TIMEZONE;
+      const base = date3 ? new Date(date3) : new Date;
+      if (isNaN(base.getTime())) {
+        throw new ValidationError("Invalid date format. Use ISO 8601 format.");
       }
-      const sourcedId = crypto.randomUUID();
-      const response = await client.oneroster.users.create({
-        sourcedId,
-        status: "active",
-        enabledUser: true,
-        givenName: providedNames.firstName,
-        familyName: providedNames.lastName,
-        email: user.email,
-        roles: [
-          {
-            roleType: "primary",
-            role: "student",
-            org: { sourcedId: TIMEBACK_ORG_SOURCED_ID }
-          }
-        ]
-      });
-      if (!response.sourcedIdPairs?.allocatedSourcedId) {
-        return { status: "error", message: "Timeback did not return allocatedSourcedId" };
+      try {
+        new Intl.DateTimeFormat(undefined, { timeZone: tz });
+      } catch {
+        throw new ValidationError(`Invalid timezone: ${tz}`);
+      }
+      if (tz === PLATFORM_TIMEZONE) {
+        const todayMidnight = getUtcInstantForMidnight(base, tz);
+        const result2 = await db2.select({ xp: timebackDailyXp.xp, date: timebackDailyXp.date }).from(timebackDailyXp).where(and(eq(timebackDailyXp.userId, userId), eq(timebackDailyXp.date, todayMidnight))).limit(1);
+        if (result2.length === 0) {
+          return { xp: 0, date: todayMidnight.toISOString() };
+        }
+        return { xp: result2[0].xp, date: result2[0].date.toISOString() };
+      }
+      const { startOfDay, endOfDay } = getDayBoundariesInTimezone(base, tz);
+      const result = await db2.select({ totalXp: sum(timebackXpEvents.xpDelta) }).from(timebackXpEvents).where(and(eq(timebackXpEvents.userId, userId), gte(timebackXpEvents.occurredAt, startOfDay), lte(timebackXpEvents.occurredAt, new Date(endOfDay.getTime() - 1))));
+      return { xp: Number(result[0]?.totalXp) || 0, date: startOfDay.toISOString() };
+    }
+    async getTotalXp(userId) {
+      const db2 = this.deps.db;
+      const result = await db2.select({ totalXp: sum(timebackDailyXp.xp) }).from(timebackDailyXp).where(eq(timebackDailyXp.userId, userId));
+      return { totalXp: Number(result[0]?.totalXp) || 0 };
+    }
+    async updateTodayXp(userId, data) {
+      const db2 = this.deps.db;
+      const { xp, userTimestamp } = data;
+      let targetDate;
+      if (userTimestamp) {
+        targetDate = new Date(userTimestamp);
+        if (isNaN(targetDate.getTime())) {
+          throw new ValidationError("Invalid userTimestamp format. Use ISO 8601 format.");
+        }
+        targetDate.setHours(0, 0, 0, 0);
+      } else {
+        targetDate = new Date;
+        targetDate.setUTCHours(0, 0, 0, 0);
+      }
+      const [result] = await db2.insert(timebackDailyXp).values({ userId, date: targetDate, xp }).onConflictDoUpdate({
+        target: [timebackDailyXp.userId, timebackDailyXp.date],
+        set: { xp: sql`excluded.xp`, updatedAt: new Date }
+      }).returning({ xp: timebackDailyXp.xp, date: timebackDailyXp.date });
+      if (!result) {
+        logger17.error("Daily XP upsert returned no rows", { userId, date: targetDate });
+        throw new InternalError("Failed to update daily XP record");
       }
-      timebackId = response.sourcedIdPairs.allocatedSourcedId;
-      name3 = `${providedNames.firstName} ${providedNames.lastName}`;
-      logger17.info("Created student in OneRoster", { userId: user.id, timebackId });
+      return { xp: result.xp, date: result.date.toISOString() };
     }
-    const assessments = await this.fetchAssessments(timebackId);
-    await db2.transaction(async (tx) => {
-      if (assessments.length > 0) {
-        const events = mapAssessmentsToXpEvents(user.id, assessments);
-        for (const event of events) {
-          try {
-            await tx.insert(timebackXpEvents).values(event);
-          } catch {}
+    async getXpHistory(userId, startDate, endDate) {
+      const db2 = this.deps.db;
+      const whereConditions = [eq(timebackDailyXp.userId, userId)];
+      if (startDate) {
+        const start2 = new Date(startDate);
+        start2.setUTCHours(0, 0, 0, 0);
+        whereConditions.push(gte(timebackDailyXp.date, start2));
+      }
+      if (endDate) {
+        const end = new Date(endDate);
+        end.setUTCHours(23, 59, 59, 999);
+        whereConditions.push(lte(timebackDailyXp.date, end));
+      }
+      const result = await db2.select({ date: timebackDailyXp.date, xp: timebackDailyXp.xp }).from(timebackDailyXp).where(and(...whereConditions)).orderBy(timebackDailyXp.date);
+      return {
+        history: result.map((row) => ({ date: row.date.toISOString(), xp: row.xp }))
+      };
+    }
+    async populateStudent(user, providedNames) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      const dbUser = await db2.query.users.findFirst({
+        where: eq(users.id, user.id),
+        columns: { id: true, timebackId: true }
+      });
+      if (dbUser?.timebackId) {
+        logger17.info("Student already onboarded", { userId: user.id });
+        return { status: "already_populated" };
+      }
+      let timebackId;
+      let name3;
+      try {
+        const existingUser = await client.oneroster.users.findByEmail(user.email);
+        timebackId = existingUser.sourcedId;
+        name3 = `${existingUser.givenName} ${existingUser.familyName}`;
+        logger17.info("Found existing student in OneRoster", {
+          userId: user.id,
+          timebackId
+        });
+      } catch {
+        if (!providedNames?.firstName || !providedNames?.lastName) {
+          return { status: "no_record" };
         }
-        const dailyMap = new Map;
-        for (const a of assessments) {
-          const xp = a.metadata?.xp;
-          if (typeof xp === "number" && a.scoreDate) {
-            const day = getUtcInstantForMidnight(new Date(a.scoreDate), PLATFORM_TIMEZONE);
-            const key = day.toISOString();
-            dailyMap.set(key, (dailyMap.get(key) || 0) + xp);
+        const sourcedId = crypto.randomUUID();
+        const response = await client.oneroster.users.create({
+          sourcedId,
+          status: "active",
+          enabledUser: true,
+          givenName: providedNames.firstName,
+          familyName: providedNames.lastName,
+          email: user.email,
+          roles: [
+            {
+              roleType: "primary",
+              role: "student",
+              org: { sourcedId: TIMEBACK_ORG_SOURCED_ID }
+            }
+          ]
+        });
+        if (!response.sourcedIdPairs?.allocatedSourcedId) {
+          return { status: "error", message: "Timeback did not return allocatedSourcedId" };
+        }
+        timebackId = response.sourcedIdPairs.allocatedSourcedId;
+        name3 = `${providedNames.firstName} ${providedNames.lastName}`;
+        logger17.info("Created student in OneRoster", { userId: user.id, timebackId });
+      }
+      const assessments = await this.fetchAssessments(timebackId);
+      await db2.transaction(async (tx) => {
+        if (assessments.length > 0) {
+          const events = mapAssessmentsToXpEvents(user.id, assessments);
+          for (const event of events) {
+            try {
+              await tx.insert(timebackXpEvents).values(event);
+            } catch {}
+          }
+          const dailyMap = new Map;
+          for (const a of assessments) {
+            const xp = a.metadata?.xp;
+            if (typeof xp === "number" && a.scoreDate) {
+              const day = getUtcInstantForMidnight(new Date(a.scoreDate), PLATFORM_TIMEZONE);
+              const key = day.toISOString();
+              dailyMap.set(key, (dailyMap.get(key) || 0) + xp);
+            }
+          }
+          if (dailyMap.size > 0) {
+            const dailyRecords = [...dailyMap.entries()].map(([iso, xp]) => ({
+              userId: user.id,
+              date: new Date(iso),
+              xp
+            }));
+            await tx.insert(timebackDailyXp).values(dailyRecords).onConflictDoUpdate({
+              target: [timebackDailyXp.userId, timebackDailyXp.date],
+              set: { xp: sql`excluded.xp`, updatedAt: new Date }
+            });
           }
         }
-        if (dailyMap.size > 0) {
-          const dailyRecords = [...dailyMap.entries()].map(([iso, xp]) => ({
+        const [updated] = await tx.update(users).set({ timebackId, name: name3 }).where(eq(users.id, user.id)).returning({ id: users.id });
+        if (!updated) {
+          logger17.error("User Timeback ID update returned no rows", {
             userId: user.id,
-            date: new Date(iso),
-            xp
-          }));
-          await tx.insert(timebackDailyXp).values(dailyRecords).onConflictDoUpdate({
-            target: [timebackDailyXp.userId, timebackDailyXp.date],
-            set: { xp: sql`excluded.xp`, updatedAt: new Date }
+            timebackId
           });
+          throw new InternalError("Failed to update user with Timeback ID");
         }
-      }
-      const [updated] = await tx.update(users).set({ timebackId, name: name3 }).where(eq(users.id, user.id)).returning({ id: users.id });
-      if (!updated) {
-        logger17.error("User Timeback ID update returned no rows", {
-          userId: user.id,
-          timebackId
-        });
-        throw new InternalError("Failed to update user with Timeback ID");
-      }
-    });
-    return { status: "ok" };
-  }
-  async fetchAssessments(studentSourcedId) {
-    const client = this.requireClient();
-    const allAssessments = [];
-    const limit = 3000;
-    const fields = "sourcedId,assessmentLineItem,student,score,textScore,scoreDate,scoreStatus,scorePercentile,comment,metadata,inProgress,incomplete,late,missing";
-    let offset = 0;
-    try {
-      while (true) {
-        const results = await client.oneroster.assessmentResults.listByStudent(studentSourcedId, { limit, offset, fields });
-        allAssessments.push(...results);
-        if (results.length < limit) {
-          break;
-        }
-        offset += limit;
-      }
-      logger17.debug("Fetched assessments", {
-        studentSourcedId,
-        totalCount: allAssessments.length
       });
-      return allAssessments;
-    } catch (error) {
-      logger17.warn("Failed to fetch assessments", { studentSourcedId, error });
-      return [];
-    }
-  }
-  async getUserData(userId, gameId) {
-    const db2 = this.deps.db;
-    const userData = await db2.query.users.findFirst({ where: eq(users.id, userId) });
-    if (!userData) {
-      throw new NotFoundError("User", userId);
-    }
-    if (!userData.timebackId) {
-      throw new NotFoundError("Timeback account not found for user");
+      return { status: "ok" };
     }
-    const [profile, allEnrollments] = await Promise.all([
-      this.fetchStudentProfile(userData.timebackId),
-      this.fetchEnrollments(userData.timebackId)
-    ]);
-    const enrollments = gameId ? allEnrollments.filter((e) => e.gameId === gameId) : allEnrollments;
-    const enrollmentOrgIds = new Set(enrollments.map((e) => e.orgId).filter(Boolean));
-    const organizations = gameId && enrollmentOrgIds.size > 0 ? profile.organizations.filter((o) => enrollmentOrgIds.has(o.id)) : profile.organizations;
-    return { id: userData.timebackId, role: profile.role, enrollments, organizations };
-  }
-  async getUserDataByTimebackId(timebackId) {
-    const [profile, enrollments] = await Promise.all([
-      this.fetchStudentProfile(timebackId),
-      this.fetchEnrollments(timebackId)
-    ]);
-    return {
-      id: timebackId,
-      role: profile.role,
-      enrollments,
-      organizations: profile.organizations
-    };
-  }
-  async fetchStudentProfile(timebackId) {
-    const client = this.requireClient();
-    try {
-      const user = await client.oneroster.users.get(timebackId);
-      const primaryRole = user.roles.find((r) => r.roleType === "primary");
-      const role = primaryRole?.role ?? user.roles[0]?.role ?? "student";
-      const orgMap = new Map;
-      if (user.primaryOrg) {
-        orgMap.set(user.primaryOrg.sourcedId, {
-          id: user.primaryOrg.sourcedId,
-          name: user.primaryOrg.name ?? null,
-          type: user.primaryOrg.type || "school",
-          isPrimary: true
+    async fetchAssessments(studentSourcedId) {
+      const client = this.requireClient();
+      const allAssessments = [];
+      const limit = 3000;
+      const fields = "sourcedId,assessmentLineItem,student,score,textScore,scoreDate,scoreStatus,scorePercentile,comment,metadata,inProgress,incomplete,late,missing";
+      let offset = 0;
+      try {
+        while (true) {
+          const results = await client.oneroster.assessmentResults.listByStudent(studentSourcedId, { limit, offset, fields });
+          allAssessments.push(...results);
+          if (results.length < limit) {
+            break;
+          }
+          offset += limit;
+        }
+        logger17.debug("Fetched assessments", {
+          studentSourcedId,
+          totalCount: allAssessments.length
         });
+        return allAssessments;
+      } catch (error) {
+        logger17.warn("Failed to fetch assessments", { studentSourcedId, error });
+        return [];
       }
-      for (const r of user.roles) {
-        if (r.org && !orgMap.has(r.org.sourcedId)) {
-          orgMap.set(r.org.sourcedId, {
-            id: r.org.sourcedId,
-            name: null,
-            type: "school",
-            isPrimary: false
+    }
+    async getUserData(userId, gameId) {
+      const db2 = this.deps.db;
+      const userData = await db2.query.users.findFirst({ where: eq(users.id, userId) });
+      if (!userData) {
+        throw new NotFoundError("User", userId);
+      }
+      if (!userData.timebackId) {
+        throw new NotFoundError("Timeback account not found for user");
+      }
+      const [profile, allEnrollments] = await Promise.all([
+        this.fetchStudentProfile(userData.timebackId),
+        this.fetchEnrollments(userData.timebackId)
+      ]);
+      const enrollments = gameId ? allEnrollments.filter((e) => e.gameId === gameId) : allEnrollments;
+      const enrollmentOrgIds = new Set(enrollments.map((e) => e.orgId).filter(Boolean));
+      const organizations = gameId && enrollmentOrgIds.size > 0 ? profile.organizations.filter((o) => enrollmentOrgIds.has(o.id)) : profile.organizations;
+      return { id: userData.timebackId, role: profile.role, enrollments, organizations };
+    }
+    async getUserDataByTimebackId(timebackId) {
+      const [profile, enrollments] = await Promise.all([
+        this.fetchStudentProfile(timebackId),
+        this.fetchEnrollments(timebackId)
+      ]);
+      return {
+        id: timebackId,
+        role: profile.role,
+        enrollments,
+        organizations: profile.organizations
+      };
+    }
+    async fetchStudentProfile(timebackId) {
+      const client = this.requireClient();
+      try {
+        const user = await client.oneroster.users.get(timebackId);
+        const primaryRole = user.roles.find((r) => r.roleType === "primary");
+        const role = primaryRole?.role ?? user.roles[0]?.role ?? "student";
+        const orgMap = new Map;
+        if (user.primaryOrg) {
+          orgMap.set(user.primaryOrg.sourcedId, {
+            id: user.primaryOrg.sourcedId,
+            name: user.primaryOrg.name ?? null,
+            type: user.primaryOrg.type || "school",
+            isPrimary: true
           });
         }
+        for (const r of user.roles) {
+          if (r.org && !orgMap.has(r.org.sourcedId)) {
+            orgMap.set(r.org.sourcedId, {
+              id: r.org.sourcedId,
+              name: null,
+              type: "school",
+              isPrimary: false
+            });
+          }
+        }
+        return { role, organizations: [...orgMap.values()] };
+      } catch {
+        return { role: "student", organizations: [] };
       }
-      return { role, organizations: [...orgMap.values()] };
-    } catch {
-      return { role: "student", organizations: [] };
     }
-  }
-  async fetchEnrollments(timebackId) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    try {
-      const enrollments = await client.getEnrollments(timebackId);
-      const courseIds = enrollments.map((e) => e.courseId).filter((id) => Boolean(id));
-      if (courseIds.length === 0) {
+    async fetchEnrollments(timebackId) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      try {
+        const enrollments = await client.getEnrollments(timebackId);
+        const courseIds = enrollments.map((e) => e.courseId).filter((id) => Boolean(id));
+        if (courseIds.length === 0) {
+          return [];
+        }
+        const courseToSchool = new Map(enrollments.filter((e) => e.school?.id).map((e) => [e.courseId, e.school.id]));
+        const integrations = await db2.query.gameTimebackIntegrations.findMany({
+          where: inArray(gameTimebackIntegrations.courseId, courseIds)
+        });
+        return integrations.map((i2) => ({
+          gameId: i2.gameId,
+          grade: i2.grade,
+          subject: i2.subject,
+          courseId: i2.courseId,
+          orgId: courseToSchool.get(i2.courseId)
+        }));
+      } catch {
         return [];
       }
-      const courseToSchool = new Map(enrollments.filter((e) => e.school?.id).map((e) => [e.courseId, e.school.id]));
-      const integrations = await db2.query.gameTimebackIntegrations.findMany({
-        where: inArray(gameTimebackIntegrations.courseId, courseIds)
-      });
-      return integrations.map((i2) => ({
-        gameId: i2.gameId,
-        grade: i2.grade,
-        subject: i2.subject,
-        courseId: i2.courseId,
-        orgId: courseToSchool.get(i2.courseId)
-      }));
-    } catch {
-      return [];
     }
-  }
-  async setupIntegration(gameId, request, user) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const { courses, baseConfig, verbose } = request;
-    const existing = await db2.query.gameTimebackIntegrations.findMany({
-      where: eq(gameTimebackIntegrations.gameId, gameId)
-    });
-    const integrations = [];
-    const verboseData = [];
-    for (const courseConfig of courses) {
-      let applySuffix = function(text3) {
-        return suffix ? `${text3} ${suffix}` : text3;
-      };
-      const {
-        subject: subjectInput,
-        grade,
-        title,
-        courseCode,
-        level,
-        metadata: metadata2,
-        totalXp: derivedTotalXp,
-        masterableUnits: derivedMasterableUnits
-      } = courseConfig;
-      if (!isTimebackSubject(subjectInput)) {
-        logger17.warn("Invalid Timeback subject in course config", {
+    async setupIntegration(gameId, request, user) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const { courses, baseConfig, verbose } = request;
+      const existing = await db2.query.gameTimebackIntegrations.findMany({
+        where: eq(gameTimebackIntegrations.gameId, gameId)
+      });
+      const integrations = [];
+      const verboseData = [];
+      for (const courseConfig of courses) {
+        let applySuffix = function(text3) {
+          return suffix ? `${text3} ${suffix}` : text3;
+        };
+        const {
           subject: subjectInput,
-          courseCode,
-          title
-        });
-        throw new ValidationError(`Invalid subject "${subjectInput}"`);
-      }
-      if (!isTimebackGrade(grade)) {
-        logger17.warn("Invalid Timeback grade in course config", {
           grade,
-          courseCode,
-          title
-        });
-        throw new ValidationError(`Invalid grade "${grade}"`);
-      }
-      const subject = subjectInput;
-      const courseMetadata = isCourseMetadata(metadata2) ? metadata2 : undefined;
-      const totalXp = derivedTotalXp ?? courseMetadata?.metrics?.totalXp;
-      const masterableUnits = derivedMasterableUnits ?? (isPlaycademyResourceMetadata(courseMetadata?.playcademy) ? courseMetadata?.playcademy?.mastery?.masterableUnits : undefined);
-      if (typeof totalXp !== "number") {
-        logger17.warn("Course missing totalXp in Timeback config", {
-          courseCode,
-          title
-        });
-        throw new ValidationError(`Course "${title}" is missing totalXp`);
-      }
-      const suffix = baseConfig.component.titleSuffix || "";
-      const fullConfig = {
-        organization: baseConfig.organization,
-        course: {
           title,
-          subjects: [subject],
-          grades: [grade],
           courseCode,
           level,
-          gradingScheme: "STANDARD",
-          metadata: metadata2
-        },
-        component: {
-          ...baseConfig.component,
-          title: applySuffix(baseConfig.component.title || `${title} Activities`)
-        },
-        resource: {
-          ...baseConfig.resource,
-          title: applySuffix(baseConfig.resource.title || `${title} Game`),
-          metadata: buildResourceMetadata({
-            baseMetadata: baseConfig.resource.metadata,
-            subject,
-            grade,
-            totalXp,
-            masterableUnits
-          })
-        },
-        componentResource: {
-          ...baseConfig.componentResource,
-          title: applySuffix(baseConfig.componentResource.title || "")
-        }
-      };
-      const existingIntegration = existing.find((i2) => i2.grade === grade && i2.subject === subject);
-      if (existingIntegration) {
-        await client.update(existingIntegration.courseId, fullConfig);
-        const [updated] = await db2.update(gameTimebackIntegrations).set({ totalXp, updatedAt: new Date }).where(eq(gameTimebackIntegrations.id, existingIntegration.id)).returning();
-        if (updated) {
-          integrations.push(this.toGameTimebackIntegration(updated));
+          metadata: metadata2,
+          totalXp: derivedTotalXp,
+          masterableUnits: derivedMasterableUnits
+        } = courseConfig;
+        if (!isTimebackSubject(subjectInput)) {
+          logger17.warn("Invalid Timeback subject in course config", {
+            subject: subjectInput,
+            courseCode,
+            title
+          });
+          throw new ValidationError(`Invalid subject "${subjectInput}"`);
         }
-      } else {
-        const result = await client.setup(fullConfig, { verbose });
-        const [integration] = await db2.insert(gameTimebackIntegrations).values({ gameId, courseId: result.courseId, grade, subject, totalXp }).returning();
-        if (integration) {
-          const dto = this.toGameTimebackIntegration(integration);
-          integrations.push(dto);
-          if (verbose && result.verboseData) {
-            verboseData.push({ integration: dto, config: result.verboseData });
+        if (!isTimebackGrade(grade)) {
+          logger17.warn("Invalid Timeback grade in course config", {
+            grade,
+            courseCode,
+            title
+          });
+          throw new ValidationError(`Invalid grade "${grade}"`);
+        }
+        const subject = subjectInput;
+        const courseMetadata = isCourseMetadata(metadata2) ? metadata2 : undefined;
+        const totalXp = derivedTotalXp ?? courseMetadata?.metrics?.totalXp;
+        const masterableUnits = derivedMasterableUnits ?? (isPlaycademyResourceMetadata(courseMetadata?.playcademy) ? courseMetadata?.playcademy?.mastery?.masterableUnits : undefined);
+        if (typeof totalXp !== "number") {
+          logger17.warn("Course missing totalXp in Timeback config", {
+            courseCode,
+            title
+          });
+          throw new ValidationError(`Course "${title}" is missing totalXp`);
+        }
+        const suffix = baseConfig.component.titleSuffix || "";
+        const fullConfig = {
+          organization: baseConfig.organization,
+          course: {
+            title,
+            subjects: [subject],
+            grades: [grade],
+            courseCode,
+            level,
+            gradingScheme: "STANDARD",
+            metadata: metadata2
+          },
+          component: {
+            ...baseConfig.component,
+            title: applySuffix(baseConfig.component.title || `${title} Activities`)
+          },
+          resource: {
+            ...baseConfig.resource,
+            title: applySuffix(baseConfig.resource.title || `${title} Game`),
+            metadata: buildResourceMetadata({
+              baseMetadata: baseConfig.resource.metadata,
+              subject,
+              grade,
+              totalXp,
+              masterableUnits
+            })
+          },
+          componentResource: {
+            ...baseConfig.componentResource,
+            title: applySuffix(baseConfig.componentResource.title || "")
+          }
+        };
+        const existingIntegration = existing.find((i2) => i2.grade === grade && i2.subject === subject);
+        if (existingIntegration) {
+          await client.update(existingIntegration.courseId, fullConfig);
+          const [updated] = await db2.update(gameTimebackIntegrations).set({ totalXp, updatedAt: new Date }).where(eq(gameTimebackIntegrations.id, existingIntegration.id)).returning();
+          if (updated) {
+            integrations.push(this.toGameTimebackIntegration(updated));
+          }
+        } else {
+          const result = await client.setup(fullConfig, { verbose });
+          const [integration] = await db2.insert(gameTimebackIntegrations).values({ gameId, courseId: result.courseId, grade, subject, totalXp }).returning();
+          if (integration) {
+            const dto = this.toGameTimebackIntegration(integration);
+            integrations.push(dto);
+            if (verbose && result.verboseData) {
+              verboseData.push({ integration: dto, config: result.verboseData });
+            }
           }
         }
       }
+      return { integrations, ...verbose && verboseData.length > 0 && { verbose: verboseData } };
     }
-    return { integrations, ...verbose && verboseData.length > 0 && { verbose: verboseData } };
-  }
-  async getIntegrations(gameId, user) {
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const rows = await this.deps.db.query.gameTimebackIntegrations.findMany({
-      where: eq(gameTimebackIntegrations.gameId, gameId)
-    });
-    return rows.map((row) => this.toGameTimebackIntegration(row));
-  }
-  async verifyIntegration(gameId, user) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const integrations = await db2.query.gameTimebackIntegrations.findMany({
-      where: eq(gameTimebackIntegrations.gameId, gameId)
-    });
-    if (integrations.length === 0) {
-      throw new NotFoundError("Timeback integration", gameId);
+    async getIntegrations(gameId, user) {
+      await this.deps.validateGameManagementAccess(user, gameId);
+      const rows = await this.deps.db.query.gameTimebackIntegrations.findMany({
+        where: eq(gameTimebackIntegrations.gameId, gameId)
+      });
+      return rows.map((row) => this.toGameTimebackIntegration(row));
     }
-    const now2 = new Date;
-    const results = await Promise.all(integrations.map(async (integration) => {
-      const resources = await client.verify(integration.courseId);
-      const resourceValues = Object.values(resources);
-      const allFound = resourceValues.every((r) => r.found);
-      const errors3 = Object.entries(resources).filter(([_2, r]) => !r.found).map(([name3]) => `${name3} not found`);
-      const status = allFound ? "success" : "error";
-      return {
-        integration: this.toGameTimebackIntegration({
-          ...integration,
-          lastVerifiedAt: now2
-        }),
-        resources,
-        status,
-        ...errors3.length > 0 && { errors: errors3 }
-      };
-    }));
-    await db2.update(gameTimebackIntegrations).set({ lastVerifiedAt: now2 }).where(eq(gameTimebackIntegrations.gameId, gameId));
-    const overallStatus = results.every((r) => r.status === "success") ? "success" : "error";
-    return { status: overallStatus, results };
-  }
-  async getConfig(gameId, user) {
-    const client = this.requireClient();
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
-      where: eq(gameTimebackIntegrations.gameId, gameId)
-    });
-    if (!integration) {
-      throw new NotFoundError("Timeback integration", gameId);
+    async verifyIntegration(gameId, user) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const integrations = await db2.query.gameTimebackIntegrations.findMany({
+        where: eq(gameTimebackIntegrations.gameId, gameId)
+      });
+      if (integrations.length === 0) {
+        throw new NotFoundError("Timeback integration", gameId);
+      }
+      const now2 = new Date;
+      const results = await Promise.all(integrations.map(async (integration) => {
+        const resources = await client.verify(integration.courseId);
+        const resourceValues = Object.values(resources);
+        const allFound = resourceValues.every((r) => r.found);
+        const errors3 = Object.entries(resources).filter(([_2, r]) => !r.found).map(([name3]) => `${name3} not found`);
+        const status = allFound ? "success" : "error";
+        return {
+          integration: this.toGameTimebackIntegration({
+            ...integration,
+            lastVerifiedAt: now2
+          }),
+          resources,
+          status,
+          ...errors3.length > 0 && { errors: errors3 }
+        };
+      }));
+      await db2.update(gameTimebackIntegrations).set({ lastVerifiedAt: now2 }).where(eq(gameTimebackIntegrations.gameId, gameId));
+      const overallStatus = results.every((r) => r.status === "success") ? "success" : "error";
+      return { status: overallStatus, results };
+    }
+    async getConfig(gameId, user) {
+      const client = this.requireClient();
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
+        where: eq(gameTimebackIntegrations.gameId, gameId)
+      });
+      if (!integration) {
+        throw new NotFoundError("Timeback integration", gameId);
+      }
+      return client.getConfig(integration.courseId);
     }
-    return client.getConfig(integration.courseId);
-  }
-  async deleteIntegrations(gameId, user) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const integrations = await db2.query.gameTimebackIntegrations.findMany({
-      where: eq(gameTimebackIntegrations.gameId, gameId)
-    });
-    if (integrations.length === 0) {
-      throw new NotFoundError("Timeback integration", gameId);
+    async deleteIntegrations(gameId, user) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const integrations = await db2.query.gameTimebackIntegrations.findMany({
+        where: eq(gameTimebackIntegrations.gameId, gameId)
+      });
+      if (integrations.length === 0) {
+        throw new NotFoundError("Timeback integration", gameId);
+      }
+      for (const integration of integrations) {
+        await client.cleanup(integration.courseId);
+      }
+      await db2.delete(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId));
     }
-    for (const integration of integrations) {
-      await client.cleanup(integration.courseId);
+    toGameTimebackIntegration(integration) {
+      return {
+        id: integration.id,
+        gameId: integration.gameId,
+        courseId: integration.courseId,
+        grade: integration.grade,
+        subject: integration.subject,
+        totalXp: integration.totalXp ?? null,
+        createdAt: integration.createdAt,
+        updatedAt: integration.updatedAt,
+        lastVerifiedAt: integration.lastVerifiedAt ?? null
+      };
     }
-    await db2.delete(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId));
-  }
-  toGameTimebackIntegration(integration) {
-    return {
-      id: integration.id,
-      gameId: integration.gameId,
-      courseId: integration.courseId,
-      grade: integration.grade,
-      subject: integration.subject,
-      totalXp: integration.totalXp ?? null,
-      createdAt: integration.createdAt,
-      updatedAt: integration.updatedAt,
-      lastVerifiedAt: integration.lastVerifiedAt ?? null
-    };
-  }
-  async endActivity({
-    gameId,
-    studentId,
-    activityData,
-    scoreData,
-    timingData,
-    xpEarned,
-    masteredUnits,
-    extensions,
-    user
-  }) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    await this.deps.validateDeveloperAccess(user, gameId);
-    const integration = await db2.query.gameTimebackIntegrations.findFirst({
-      where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject))
-    });
-    if (!integration) {
-      throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
-    }
-    const scorePercentage = scoreData.totalQuestions > 0 ? scoreData.correctQuestions / scoreData.totalQuestions * 100 : 0;
-    const result = await client.recordProgress(integration.courseId, studentId, {
-      score: scorePercentage,
-      totalQuestions: scoreData.totalQuestions,
-      correctQuestions: scoreData.correctQuestions,
-      durationSeconds: timingData.durationSeconds,
+    async endActivity({
+      gameId,
+      studentId,
+      runId,
+      resumeId,
+      activityData,
+      scoreData,
+      timingData,
+      sessionTimingData,
       xpEarned,
       masteredUnits,
       extensions,
-      activityId: activityData.activityId,
-      activityName: activityData.activityName,
-      subject: activityData.subject,
-      appName: activityData.appName,
-      sensorUrl: activityData.sensorUrl,
-      courseId: activityData.courseId,
-      courseName: activityData.courseName,
-      studentEmail: activityData.studentEmail,
-      courseTotalXp: integration.totalXp
-    });
-    await client.recordSessionEnd(integration.courseId, studentId, {
-      activeTimeSeconds: timingData.durationSeconds,
-      activityId: activityData.activityId,
-      activityName: activityData.activityName,
-      subject: activityData.subject,
-      appName: activityData.appName,
-      sensorUrl: activityData.sensorUrl,
-      courseId: activityData.courseId,
-      courseName: activityData.courseName,
-      studentEmail: activityData.studentEmail
-    });
-    logger17.info("Recorded activity completion", {
+      user
+    }) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      const effectiveResumeId = resumeId ?? runId ?? crypto.randomUUID();
+      const extensionsWithResumeId = TimebackService2.addResumeIdToExtensions(extensions, effectiveResumeId);
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const integration = await db2.query.gameTimebackIntegrations.findFirst({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject))
+      });
+      if (!integration) {
+        throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
+      }
+      const scorePercentage = scoreData.totalQuestions > 0 ? scoreData.correctQuestions / scoreData.totalQuestions * 100 : 0;
+      const result = await client.recordProgress(integration.courseId, studentId, {
+        gameId,
+        score: scorePercentage,
+        totalQuestions: scoreData.totalQuestions,
+        correctQuestions: scoreData.correctQuestions,
+        durationSeconds: timingData.durationSeconds,
+        xpEarned,
+        masteredUnits,
+        extensions: extensionsWithResumeId,
+        activityId: activityData.activityId,
+        activityName: activityData.activityName,
+        subject: activityData.subject,
+        appName: activityData.appName,
+        sensorUrl: activityData.sensorUrl,
+        courseId: activityData.courseId,
+        courseName: activityData.courseName,
+        studentEmail: activityData.studentEmail,
+        courseTotalXp: integration.totalXp,
+        ...runId ? { runId } : {}
+      });
+      const sessionEndActiveSeconds = sessionTimingData?.activeSeconds ?? timingData.durationSeconds;
+      const sessionEndInactiveSeconds = sessionTimingData?.inactiveSeconds;
+      if (sessionEndActiveSeconds > 0 || (sessionEndInactiveSeconds ?? 0) > 0) {
+        await client.recordSessionEnd(integration.courseId, studentId, {
+          gameId,
+          activeTimeSeconds: sessionEndActiveSeconds,
+          ...sessionEndInactiveSeconds !== undefined ? { inactiveTimeSeconds: sessionEndInactiveSeconds } : {},
+          activityId: activityData.activityId,
+          activityName: activityData.activityName,
+          subject: activityData.subject,
+          appName: activityData.appName,
+          sensorUrl: activityData.sensorUrl,
+          courseId: activityData.courseId,
+          courseName: activityData.courseName,
+          studentEmail: activityData.studentEmail,
+          extensions: extensionsWithResumeId,
+          ...runId ? { runId } : {}
+        });
+      }
+      logger17.info("Recorded activity completion", {
+        gameId,
+        courseId: integration.courseId,
+        studentId,
+        runId,
+        score: scorePercentage
+      });
+      return {
+        status: "ok",
+        courseId: integration.courseId,
+        xpAwarded: result.xpAwarded,
+        masteredUnits: result.masteredUnitsApplied,
+        pctCompleteApp: result.pctCompleteApp,
+        scoreStatus: result.scoreStatus,
+        inProgress: result.inProgress
+      };
+    }
+    async recordHeartbeat({
       gameId,
-      courseId: integration.courseId,
       studentId,
-      score: scorePercentage
-    });
-    return {
-      status: "ok",
-      courseId: integration.courseId,
-      xpAwarded: result.xpAwarded,
-      masteredUnits: result.masteredUnitsApplied,
-      pctCompleteApp: result.pctCompleteApp,
-      scoreStatus: result.scoreStatus,
-      inProgress: result.inProgress
-    };
-  }
-  async getStudentXp(timebackId, user, options) {
-    const client = this.requireClient();
-    const db2 = this.deps.db;
-    let courseIds = [];
-    if (options?.gameId) {
-      await this.deps.validateDeveloperAccess(user, options.gameId);
-      const conditions2 = [eq(gameTimebackIntegrations.gameId, options.gameId)];
-      if (options.grade !== undefined && options.subject) {
-        conditions2.push(eq(gameTimebackIntegrations.grade, options.grade));
-        conditions2.push(eq(gameTimebackIntegrations.subject, options.subject));
+      runId,
+      resumeId,
+      activityData,
+      timingData,
+      windowStartedAtMs,
+      windowSequence,
+      isFinal,
+      user
+    }) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      const hasWindowStartedAtMs = windowStartedAtMs !== undefined;
+      const hasWindowSequence = windowSequence !== undefined;
+      if (hasWindowStartedAtMs === hasWindowSequence) {
+        throw new ValidationError("Provide exactly one of windowStartedAtMs or windowSequence");
+      }
+      const heartbeatWindowKey = hasWindowStartedAtMs ? `${runId}:t:${windowStartedAtMs}` : `${runId}:s:${windowSequence}`;
+      const effectiveResumeId = resumeId ?? runId;
+      if (TimebackService2.isDuplicateHeartbeatWindow(heartbeatWindowKey)) {
+        logger17.debug("Skipping duplicate heartbeat window", {
+          gameId,
+          studentId,
+          runId,
+          windowStartedAtMs,
+          windowSequence,
+          isFinal
+        });
+        return { status: "ok" };
       }
-      const integrations = await db2.query.gameTimebackIntegrations.findMany({
-        where: and(...conditions2)
-      });
-      courseIds = integrations.map((i2) => i2.courseId);
-      if (courseIds.length === 0) {
-        logger17.debug("No integrations found for game, returning 0 XP", {
-          timebackId,
-          gameId: options.gameId,
-          grade: options.grade,
-          subject: options.subject
+      await this.deps.validateDeveloperAccess(user, gameId);
+      const inFlightHeartbeat = TimebackService2.getInFlightHeartbeatWindow(heartbeatWindowKey);
+      if (inFlightHeartbeat) {
+        logger17.debug("Joining in-flight heartbeat window", {
+          gameId,
+          studentId,
+          runId,
+          windowStartedAtMs,
+          windowSequence,
+          isFinal
         });
-        return {
-          totalXp: 0,
-          ...options?.include?.today && { todayXp: 0 },
-          ...options?.include?.perCourse && { courses: [] }
-        };
+        return inFlightHeartbeat;
+      }
+      const pendingHeartbeat = (async () => {
+        const integration = await db2.query.gameTimebackIntegrations.findFirst({
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject))
+        });
+        if (!integration) {
+          throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
+        }
+        const activeTimeSeconds = timingData.activeMs / 1000;
+        const inactiveTimeSeconds = timingData.pausedMs / 1000;
+        if (activeTimeSeconds > 0 || inactiveTimeSeconds > 0) {
+          await client.recordSessionEnd(integration.courseId, studentId, {
+            gameId,
+            activeTimeSeconds,
+            ...inactiveTimeSeconds > 0 ? { inactiveTimeSeconds } : {},
+            activityId: activityData.activityId,
+            activityName: activityData.activityName,
+            subject: activityData.subject,
+            appName: activityData.appName,
+            sensorUrl: activityData.sensorUrl,
+            courseId: activityData.courseId,
+            courseName: activityData.courseName,
+            studentEmail: activityData.studentEmail,
+            extensions: TimebackService2.addResumeIdToExtensions(undefined, effectiveResumeId),
+            ...runId ? { runId } : {}
+          });
+        }
+        TimebackService2.markHeartbeatWindowProcessed(heartbeatWindowKey);
+        logger17.debug("Recorded heartbeat", {
+          gameId,
+          courseId: integration.courseId,
+          studentId,
+          runId,
+          windowStartedAtMs,
+          windowSequence,
+          activeTimeSeconds,
+          isFinal
+        });
+        return { status: "ok" };
+      })();
+      TimebackService2.markHeartbeatWindowInFlight(heartbeatWindowKey, pendingHeartbeat);
+      try {
+        return await pendingHeartbeat;
+      } finally {
+        TimebackService2.clearInFlightHeartbeatWindow(heartbeatWindowKey);
+      }
+    }
+    async getStudentXp(timebackId, user, options) {
+      const client = this.requireClient();
+      const db2 = this.deps.db;
+      let courseIds = [];
+      if (options?.gameId) {
+        await this.deps.validateDeveloperAccess(user, options.gameId);
+        const conditions2 = [eq(gameTimebackIntegrations.gameId, options.gameId)];
+        if (options.grade !== undefined && options.subject) {
+          conditions2.push(eq(gameTimebackIntegrations.grade, options.grade));
+          conditions2.push(eq(gameTimebackIntegrations.subject, options.subject));
+        }
+        const integrations = await db2.query.gameTimebackIntegrations.findMany({
+          where: and(...conditions2)
+        });
+        courseIds = integrations.map((i2) => i2.courseId);
+        if (courseIds.length === 0) {
+          logger17.debug("No integrations found for game, returning 0 XP", {
+            timebackId,
+            gameId: options.gameId,
+            grade: options.grade,
+            subject: options.subject
+          });
+          return {
+            totalXp: 0,
+            ...options?.include?.today && { todayXp: 0 },
+            ...options?.include?.perCourse && { courses: [] }
+          };
+        }
       }
+      const result = await client.getStudentXp(timebackId, {
+        courseIds: courseIds.length > 0 ? courseIds : undefined,
+        include: options?.include
+      });
+      logger17.debug("Retrieved student XP", {
+        timebackId,
+        gameId: options?.gameId,
+        grade: options?.grade,
+        subject: options?.subject,
+        totalXp: result.totalXp,
+        courseCount: result.courses?.length
+      });
+      return result;
     }
-    const result = await client.getStudentXp(timebackId, {
-      courseIds: courseIds.length > 0 ? courseIds : undefined,
-      include: options?.include
-    });
-    logger17.debug("Retrieved student XP", {
-      timebackId,
-      gameId: options?.gameId,
-      grade: options?.grade,
-      subject: options?.subject,
-      totalXp: result.totalXp,
-      courseCount: result.courses?.length
-    });
-    return result;
-  }
-}
-var logger17;
-var init_timeback_service = __esm(() => {
-  init_drizzle_orm();
-  init_src();
-  init_tables_index();
-  init_src2();
-  init_types4();
-  init_src4();
-  init_errors();
-  init_timeback_util();
-  logger17 = log.scope("TimebackService");
+  };
 });
 
 class UploadService {
@@ -55625,6 +55948,7 @@ function createPlatformServices(deps) {
     alerts,
     validateDeveloperAccessBySlug,
     validateDeveloperAccess,
+    validateGameManagementAccess,
     validateOwnership
   } = deps;
   const bucket = new BucketService({
@@ -55659,12 +55983,15 @@ function createPlatformServices(deps) {
   const timeback2 = new TimebackService({
     db: db2,
     timeback: timebackClient,
-    validateDeveloperAccess
+    validateDeveloperAccess,
+    validateGameManagementAccess
   });
   const timebackAdmin = new TimebackAdminService({
+    config: config2,
     db: db2,
     timeback: timebackClient,
-    validateDeveloperAccess
+    validateDeveloperAccess,
+    validateGameManagementAccess
   });
   return {
     bucket,
@@ -58591,6 +58918,16 @@ async function requestCaliper(options) {
     baseUrl: caliperUrl
   });
 }
+function buildEventExtensions({
+  eventExtensions,
+  gameId
+}) {
+  const mergedExtensions = {
+    ...eventExtensions,
+    ...gameId ? { gameId } : {}
+  };
+  return Object.keys(mergedExtensions).length > 0 ? mergedExtensions : undefined;
+}
 function createCaliperNamespace(client) {
   const urls = createOneRosterUrls(client.getBaseUrl());
   const caliper = {
@@ -58635,11 +58972,20 @@ function createCaliperNamespace(client) {
         if (params.actorEmail) {
           query.set("actorEmail", params.actorEmail);
         }
+        if (params.extensions) {
+          for (const [key, value] of Object.entries(params.extensions)) {
+            query.set(`extensions.${key}`, value);
+          }
+        }
         const requestPath = `${CALIPER_ENDPOINTS4.events}?${query.toString()}`;
         return client["requestCaliper"](requestPath, "GET");
       }
     },
     emitActivityEvent: async (data) => {
+      const eventExtensions = buildEventExtensions({
+        eventExtensions: data.eventExtensions,
+        gameId: data.gameId
+      });
       const event = {
         "@context": CALIPER_CONSTANTS4.context,
         id: `urn:uuid:${crypto.randomUUID()}`,
@@ -58652,6 +58998,7 @@ function createCaliperNamespace(client) {
           email: data.studentEmail
         },
         action: TIMEBACK_ACTIONS4.completed,
+        ...data.runId ? { session: `urn:uuid:${data.runId}` } : {},
         object: {
           id: data.objectId || caliper.buildActivityUrl(data),
           type: TIMEBACK_TYPES4.activityContext,
@@ -58698,11 +59045,15 @@ function createCaliperNamespace(client) {
             }
           } : {}
         },
-        ...data.eventExtensions ? { extensions: data.eventExtensions } : {}
+        ...eventExtensions ? { extensions: eventExtensions } : {}
       };
       return caliper.emit(event, data.sensorUrl);
     },
     emitTimeSpentEvent: async (data) => {
+      const eventExtensions = buildEventExtensions({
+        eventExtensions: data.eventExtensions,
+        gameId: data.gameId
+      });
       const event = {
         "@context": CALIPER_CONSTANTS4.context,
         id: `urn:uuid:${crypto.randomUUID()}`,
@@ -58715,6 +59066,7 @@ function createCaliperNamespace(client) {
           email: data.studentEmail
         },
         action: TIMEBACK_ACTIONS4.spentTime,
+        ...data.runId ? { session: `urn:uuid:${data.runId}` } : {},
         object: {
           id: caliper.buildActivityUrl(data),
           type: TIMEBACK_TYPES4.activityContext,
@@ -58742,13 +59094,14 @@ function createCaliperNamespace(client) {
             ...data.wasteTimeSeconds !== undefined ? [{ type: TIME_METRIC_TYPES4.waste, value: data.wasteTimeSeconds }] : []
           ],
           ...data.extensions ? { extensions: data.extensions } : {}
-        }
+        },
+        ...eventExtensions ? { extensions: eventExtensions } : {}
       };
       return caliper.emit(event, data.sensorUrl);
     },
     buildActivityUrl: (data) => {
       const base = data.sensorUrl.replace(/\/$/, "");
-      return `${base}/activities/${data.courseId}/${data.activityId}/${crypto.randomUUID()}`;
+      return `${base}/activities/${encodeURIComponent(data.courseId)}/${encodeURIComponent(data.activityId)}`;
     }
   };
   return caliper;
@@ -58758,6 +59111,34 @@ function createEduBridgeNamespace(client) {
     listByUser: async (userId) => {
       const response = await client["request"](`/edubridge/enrollments/user/${userId}`, "GET");
       return response.data;
+    },
+    enroll: async (userId, courseId, options) => {
+      const segments = [userId, courseId];
+      if (options?.schoolId) {
+        segments.push(options.schoolId);
+      }
+      const body2 = {};
+      if (options?.role) {
+        body2.role = options.role;
+      }
+      if (options?.sourcedId) {
+        body2.sourcedId = options.sourcedId;
+      }
+      if (options?.beginDate) {
+        body2.beginDate = options.beginDate;
+      }
+      if (options?.metadata) {
+        body2.metadata = options.metadata;
+      }
+      const response = await client["request"](`/edubridge/enrollments/enroll/${segments.join("/")}`, "POST", body2);
+      return response.data;
+    },
+    unenroll: async (userId, courseId, options) => {
+      const segments = [userId, courseId];
+      if (options?.schoolId) {
+        segments.push(options.schoolId);
+      }
+      await client["request"](`/edubridge/enrollments/unenroll/${segments.join("/")}`, "DELETE");
     }
   };
   const analytics = {
@@ -58933,6 +59314,10 @@ function createOneRosterNamespace(client) {
           logTimebackError("list course roster", error, { courseSourcedId });
           throw error;
         }
+      },
+      create: async (data) => client["request"](ONEROSTER_ENDPOINTS4.enrollments, "POST", { enrollment: data }),
+      delete: async (sourcedId) => {
+        await client["request"](`${ONEROSTER_ENDPOINTS4.enrollments}/${sourcedId}`, "DELETE");
       }
     },
     organizations: {
@@ -59203,6 +59588,7 @@ class AdminEventRecorder {
     await this.caliper.emitActivityEvent({
       studentId: ctx.student.id,
       studentEmail: ctx.student.email,
+      gameId: data.gameId,
       activityId: ctx.activityId,
       activityName: data.activityName || `Manual XP Assignment - ${ctx.courseContext.subject}`,
       courseId: data.courseId,
@@ -59229,6 +59615,7 @@ class AdminEventRecorder {
     await this.caliper.emitTimeSpentEvent({
       studentId: ctx.student.id,
       studentEmail: ctx.student.email,
+      gameId: data.gameId,
       activityId: ctx.activityId,
       activityName: data.activityName || "Playcademy Admin Time Adjustment",
       courseId: data.courseId,
@@ -59250,6 +59637,7 @@ class AdminEventRecorder {
     await this.caliper.emitActivityEvent({
       studentId: ctx.student.id,
       studentEmail: ctx.student.email,
+      gameId: data.gameId,
       activityId: ctx.activityId,
       activityName: data.activityName || "Playcademy Admin Mastery Adjustment",
       courseId: data.courseId,
@@ -59275,6 +59663,7 @@ class AdminEventRecorder {
     await this.caliper.emitActivityEvent({
       studentId: ctx.student.id,
       studentEmail: ctx.student.email,
+      gameId: data.gameId,
       activityId: ctx.activityId,
       activityName: isResume ? "Course resumed" : "Course marked complete",
       courseId: data.courseId,
@@ -59723,15 +60112,13 @@ class ProgressRecorder {
         studentId,
         attemptNumber: currentAttemptNumber,
         score,
-        totalQuestions,
-        correctQuestions,
         xp: calculatedXp,
-        masteredUnits,
         scoreStatus,
         inProgress,
         appName: progressData.appName,
-        activityName,
-        durationSeconds: progressData.durationSeconds
+        totalQuestions,
+        correctQuestions,
+        masteredUnits
       });
     } else {
       log.warn("[ProgressRecorder] Score not provided, skipping gradebook entry", {
@@ -59745,6 +60132,7 @@ class ProgressRecorder {
       await this.emitCourseCompletionHistoryEvent({
         studentId,
         studentEmail,
+        gameId: progressData.gameId,
         activityId,
         courseId: ids.course,
         courseName,
@@ -59756,6 +60144,7 @@ class ProgressRecorder {
     await this.emitCaliperEvent({
       studentId,
       studentEmail,
+      gameId: progressData.gameId,
       activityId,
       activityName,
       courseId: ids.course,
@@ -59766,7 +60155,8 @@ class ProgressRecorder {
       masteredUnits,
       attemptNumber: currentAttemptNumber,
       progressData,
-      extensions
+      extensions,
+      runId: progressData.runId
     });
     return {
       xpAwarded: calculatedXp,
@@ -59856,15 +60246,13 @@ class ProgressRecorder {
     studentId,
     attemptNumber,
     score,
-    totalQuestions,
-    correctQuestions,
     xp,
-    masteredUnits,
     scoreStatus,
     inProgress,
     appName,
-    activityName,
-    durationSeconds
+    totalQuestions,
+    correctQuestions,
+    masteredUnits
   }) {
     const timestamp3 = Date.now().toString(36);
     const resultId = `${lineItemId}:${studentId}:${timestamp3}`;
@@ -59879,21 +60267,18 @@ class ProgressRecorder {
       inProgress,
       metadata: {
         xp,
-        totalQuestions,
-        correctQuestions,
-        accuracy: totalQuestions && correctQuestions ? correctQuestions / totalQuestions * 100 : undefined,
         attemptNumber,
-        lastUpdated: new Date().toISOString(),
-        masteredUnits,
         appName,
-        activityName,
-        durationSeconds
+        ...totalQuestions !== undefined ? { totalQuestions } : {},
+        ...correctQuestions !== undefined ? { correctQuestions } : {},
+        ...masteredUnits !== undefined ? { masteredUnits } : {}
       }
     });
   }
   async emitCaliperEvent({
     studentId,
     studentEmail,
+    gameId,
     activityId,
     activityName,
     courseId,
@@ -59904,11 +60289,13 @@ class ProgressRecorder {
     masteredUnits,
     attemptNumber,
     progressData,
-    extensions
+    extensions,
+    runId
   }) {
     await this.caliperNamespace.emitActivityEvent({
       studentId,
       studentEmail,
+      gameId,
       activityId,
       activityName,
       courseId,
@@ -59921,7 +60308,8 @@ class ProgressRecorder {
       subject: progressData.subject,
       appName: progressData.appName,
       sensorUrl: progressData.sensorUrl,
-      extensions: extensions || progressData.extensions
+      extensions: extensions || progressData.extensions,
+      ...runId ? { runId } : {}
     }).catch((error) => {
       log.error("[ProgressRecorder] Failed to emit activity event", { error });
     });
@@ -59930,6 +60318,7 @@ class ProgressRecorder {
     await this.caliperNamespace.emitActivityEvent({
       studentId: data.studentId,
       studentEmail: data.studentEmail,
+      gameId: data.gameId,
       activityId: data.activityId,
       activityName: "Course completed",
       courseId: data.courseId,
@@ -59975,10 +60364,11 @@ class SessionRecorder {
     const courseName = sessionData.courseName || "Game Course";
     const student = await this.studentResolver.resolve(studentIdentifier, sessionData.studentEmail);
     const { id: studentId, email: studentEmail } = student;
-    const { activeTimeSeconds, inactiveTimeSeconds, wasteTimeSeconds, extensions } = sessionData;
+    const { activeTimeSeconds, inactiveTimeSeconds, wasteTimeSeconds, extensions, runId } = sessionData;
     await this.caliperNamespace.emitTimeSpentEvent({
       studentId,
       studentEmail,
+      gameId: sessionData.gameId,
       activityId,
       activityName,
       courseId: ids.course,
@@ -59989,6 +60379,7 @@ class SessionRecorder {
       subject: sessionData.subject,
       appName: sessionData.appName,
       sensorUrl: sessionData.sensorUrl,
+      ...runId ? { runId } : {},
       ...extensions ? { extensions } : {}
     });
   }
@@ -118566,18 +118957,23 @@ async function seedCoreGames(db2) {
 }
 async function seedCurrentProjectGame(db2, project) {
   const now2 = new Date;
+  const desiredGameId = project.gameId?.trim() || undefined;
   try {
     const existingGame = await db2.query.games.findFirst({
-      where: (row, { eq: eq3 }) => eq3(row.slug, project.slug)
+      where: (row, operators) => operators.eq(row.slug, project.slug)
     });
     if (existingGame) {
-      if (project.timebackCourses && project.timebackCourses.length > 0) {
-        await seedTimebackIntegrations(db2, existingGame.id, project.timebackCourses);
+      if (desiredGameId && existingGame.id !== desiredGameId) {
+        await db2.delete(games).where(eq(games.id, existingGame.id));
+      } else {
+        if (project.timebackCourses && project.timebackCourses.length > 0) {
+          await seedTimebackIntegrations(db2, existingGame.id, project.timebackCourses);
+        }
+        return existingGame;
       }
-      return existingGame;
     }
     const gameRecord = {
-      id: crypto.randomUUID(),
+      id: desiredGameId ?? crypto.randomUUID(),
       developerId: DEMO_USERS.developer.id,
       slug: project.slug,
       displayName: project.displayName,
@@ -118606,6 +119002,7 @@ async function seedCurrentProjectGame(db2, project) {
   }
 }
 var init_games = __esm(() => {
+  init_drizzle_orm();
   init_src();
   init_tables_index();
   init_constants();
@@ -119670,6 +120067,7 @@ var init_schemas2 = __esm(() => {
     code: exports_external.string().optional(),
     codeUploadToken: exports_external.string().optional(),
     config: exports_external.unknown().optional(),
+    compatibilityDate: exports_external.string().optional(),
     compatibilityFlags: exports_external.array(exports_external.string()).optional(),
     bindings: exports_external.object({
       database: exports_external.array(exports_external.string()).optional(),
@@ -119951,7 +120349,9 @@ var TIMEBACK_SUBJECTS5;
 var TimebackGradeSchema;
 var TimebackSubjectSchema;
 var UpdateTimebackXpRequestSchema;
+var TimebackActivityDataSchema;
 var EndActivityRequestSchema;
+var HeartbeatRequestSchema;
 var PopulateStudentRequestSchema;
 var DerivedPlatformCourseConfigSchema;
 var TimebackBaseConfigSchema;
@@ -119962,6 +120362,8 @@ var GrantTimebackXpRequestSchema;
 var AdjustTimebackTimeRequestSchema;
 var AdjustTimebackMasteryRequestSchema;
 var ToggleCourseCompletionRequestSchema;
+var EnrollStudentRequestSchema;
+var UnenrollStudentRequestSchema;
 var init_schemas11 = __esm(() => {
   init_esm();
   TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
@@ -119984,31 +120386,55 @@ var init_schemas11 = __esm(() => {
     xp: exports_external.number().min(0, "XP must be a non-negative number"),
     userTimestamp: exports_external.string().datetime().optional()
   });
+  TimebackActivityDataSchema = exports_external.object({
+    activityId: exports_external.string().min(1),
+    activityName: exports_external.string().optional(),
+    grade: TimebackGradeSchema,
+    subject: TimebackSubjectSchema,
+    appName: exports_external.string().optional(),
+    sensorUrl: exports_external.string().url().optional(),
+    courseId: exports_external.string().optional(),
+    courseName: exports_external.string().optional(),
+    studentEmail: exports_external.string().email().optional()
+  });
   EndActivityRequestSchema = exports_external.object({
     gameId: exports_external.string().uuid(),
     studentId: exports_external.string().min(1),
-    activityData: exports_external.object({
-      activityId: exports_external.string().min(1),
-      activityName: exports_external.string().optional(),
-      grade: TimebackGradeSchema,
-      subject: TimebackSubjectSchema,
-      appName: exports_external.string().optional(),
-      sensorUrl: exports_external.string().url().optional(),
-      courseId: exports_external.string().optional(),
-      courseName: exports_external.string().optional(),
-      studentEmail: exports_external.string().email().optional()
-    }),
+    runId: exports_external.string().uuid().optional(),
+    resumeId: exports_external.string().uuid().optional(),
+    activityData: TimebackActivityDataSchema,
     scoreData: exports_external.object({
       correctQuestions: exports_external.number().int().min(0),
       totalQuestions: exports_external.number().int().min(0)
     }),
     timingData: exports_external.object({
-      durationSeconds: exports_external.number().positive()
+      durationSeconds: exports_external.number().nonnegative()
     }),
+    sessionTimingData: exports_external.object({
+      activeSeconds: exports_external.number().nonnegative(),
+      inactiveSeconds: exports_external.number().nonnegative().optional()
+    }).optional(),
     xpEarned: exports_external.number().optional(),
     masteredUnits: exports_external.number().nonnegative().optional(),
     extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
   });
+  HeartbeatRequestSchema = exports_external.object({
+    gameId: exports_external.string().uuid(),
+    studentId: exports_external.string().min(1),
+    runId: exports_external.string().uuid(),
+    resumeId: exports_external.string().uuid().optional(),
+    activityData: TimebackActivityDataSchema,
+    timingData: exports_external.object({
+      activeMs: exports_external.number().nonnegative(),
+      pausedMs: exports_external.number().nonnegative()
+    }),
+    windowStartedAtMs: exports_external.number().int().nonnegative().optional(),
+    windowSequence: exports_external.number().int().nonnegative().optional(),
+    isFinal: exports_external.boolean().optional()
+  }).refine((value) => value.windowStartedAtMs !== undefined !== (value.windowSequence !== undefined), {
+    message: "Provide exactly one of windowStartedAtMs or windowSequence",
+    path: ["windowStartedAtMs"]
+  });
   PopulateStudentRequestSchema = exports_external.object({
     firstName: exports_external.string().min(1).optional(),
     lastName: exports_external.string().min(1).optional()
@@ -120088,15 +120514,18 @@ var init_schemas11 = __esm(() => {
   });
   GrantTimebackXpRequestSchema = AdminTimebackMutationBaseSchema.extend({
     xp: exports_external.number().min(-100, "Amount must be between -100 and 100").max(100, "Amount must be between -100 and 100").refine((value) => value !== 0, { message: "Amount cannot be 0" }),
-    date: AdminAttributionDateSchema.optional()
+    date: AdminAttributionDateSchema.optional(),
+    useCurrentTime: exports_external.boolean().optional()
   });
   AdjustTimebackTimeRequestSchema = AdminTimebackMutationBaseSchema.extend({
     seconds: exports_external.number().refine((value) => value !== 0, { message: "Time amount cannot be 0" }),
-    date: AdminAttributionDateSchema.optional()
+    date: AdminAttributionDateSchema.optional(),
+    useCurrentTime: exports_external.boolean().optional()
   });
   AdjustTimebackMasteryRequestSchema = AdminTimebackMutationBaseSchema.extend({
     units: exports_external.number().refine((value) => value !== 0, { message: "Units cannot be 0" }),
-    date: AdminAttributionDateSchema.optional()
+    date: AdminAttributionDateSchema.optional(),
+    useCurrentTime: exports_external.boolean().optional()
   });
   ToggleCourseCompletionRequestSchema = exports_external.object({
     gameId: exports_external.string().uuid(),
@@ -120104,6 +120533,16 @@ var init_schemas11 = __esm(() => {
     studentId: exports_external.string().min(1),
     action: exports_external.enum(["complete", "resume"])
   });
+  EnrollStudentRequestSchema = exports_external.object({
+    gameId: exports_external.string().uuid(),
+    courseId: exports_external.string().min(1),
+    studentId: exports_external.string().min(1)
+  });
+  UnenrollStudentRequestSchema = exports_external.object({
+    gameId: exports_external.string().uuid(),
+    courseId: exports_external.string().min(1),
+    studentId: exports_external.string().min(1)
+  });
 });
 var init_schemas_index = __esm(() => {
   init_schemas();
@@ -120122,6 +120561,9 @@ function isAuthenticated(ctx) {
   return ctx.user != null;
 }
 var init_types9 = () => {};
+function hasGameManagementAccess(user) {
+  return user.role === "admin" || user.role === "teacher" || user.role === "developer" && user.developerStatus === "approved";
+}
 function requireAuth(handler) {
   return async (ctx) => {
     if (!isAuthenticated(ctx)) {
@@ -120165,6 +120607,17 @@ function requireDeveloper(handler) {
     return handler(ctx);
   };
 }
+function requireGameManagementAccess(handler) {
+  return async (ctx) => {
+    if (!isAuthenticated(ctx)) {
+      throw ApiError.unauthorized("Valid session or bearer token required");
+    }
+    if (!hasGameManagementAccess(ctx.user)) {
+      throw ApiError.forbidden("Game management access required");
+    }
+    return handler(ctx);
+  };
+}
 var init_auth_util = __esm(() => {
   init_errors();
   init_types9();
@@ -122290,6 +122743,7 @@ var verifyIntegration;
 var getConfig2;
 var deleteIntegrations;
 var endActivity;
+var heartbeat;
 var getStudentXp;
 var getRoster;
 var getStudentOverview;
@@ -122298,6 +122752,9 @@ var grantXp;
 var adjustTime;
 var adjustMastery;
 var toggleCompletion;
+var searchStudents;
+var enrollStudent;
+var unenrollStudent;
 var timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
@@ -122388,7 +122845,7 @@ var init_timeback_controller = __esm(() => {
     });
     return ctx.services.timeback.setupIntegration(body2.gameId, body2, ctx.user);
   });
-  getIntegrations = requireDeveloper(async (ctx) => {
+  getIntegrations = requireGameManagementAccess(async (ctx) => {
     const gameId = ctx.params.gameId;
     if (!gameId) {
       throw ApiError.badRequest("Missing gameId");
@@ -122448,9 +122905,12 @@ var init_timeback_controller = __esm(() => {
     const {
       gameId,
       studentId,
+      runId,
+      resumeId,
       activityData,
       scoreData,
       timingData,
+      sessionTimingData,
       xpEarned,
       masteredUnits,
       extensions
@@ -122459,15 +122919,65 @@ var init_timeback_controller = __esm(() => {
     return ctx.services.timeback.endActivity({
       gameId,
       studentId,
+      runId,
+      resumeId,
       activityData,
       scoreData,
       timingData,
+      sessionTimingData,
       xpEarned,
       masteredUnits,
       extensions,
       user: ctx.user
     });
   });
+  heartbeat = requireDeveloper(async (ctx) => {
+    let body2;
+    try {
+      const json4 = await ctx.request.json();
+      body2 = HeartbeatRequestSchema.parse(json4);
+    } catch (error2) {
+      if (error2 instanceof exports_external.ZodError) {
+        const details = formatZodError(error2);
+        logger63.warn("Heartbeat validation failed", { details });
+        throw ApiError.unprocessableEntity("Validation failed", details);
+      }
+      throw ApiError.badRequest("Invalid JSON body");
+    }
+    const {
+      gameId,
+      studentId,
+      runId,
+      resumeId,
+      activityData,
+      timingData,
+      windowStartedAtMs,
+      windowSequence,
+      isFinal
+    } = body2;
+    logger63.debug("Recording heartbeat", {
+      userId: ctx.user.id,
+      gameId,
+      runId,
+      resumeId,
+      windowStartedAtMs,
+      windowSequence,
+      activeMs: timingData.activeMs,
+      isFinal
+    });
+    return ctx.services.timeback.recordHeartbeat({
+      gameId,
+      studentId,
+      runId,
+      resumeId,
+      activityData,
+      timingData,
+      windowStartedAtMs,
+      windowSequence,
+      isFinal,
+      user: ctx.user
+    });
+  });
   getStudentXp = requireDeveloper(async (ctx) => {
     const timebackId = ctx.params.timebackId;
     if (!timebackId) {
@@ -122513,7 +123023,7 @@ var init_timeback_controller = __esm(() => {
       include
     });
   });
-  getRoster = requireDeveloper(async (ctx) => {
+  getRoster = requireGameManagementAccess(async (ctx) => {
     const gameId = ctx.params.gameId;
     const courseId = ctx.params.courseId;
     if (!gameId || !courseId) {
@@ -122526,7 +123036,7 @@ var init_timeback_controller = __esm(() => {
     });
     return ctx.services.timebackAdmin.listStudentsForCourse(gameId, courseId, ctx.user);
   });
-  getStudentOverview = requireDeveloper(async (ctx) => {
+  getStudentOverview = requireGameManagementAccess(async (ctx) => {
     const timebackId = ctx.params.timebackId;
     const gameId = ctx.url.searchParams.get("gameId") || undefined;
     const courseId = ctx.url.searchParams.get("courseId") || undefined;
@@ -122541,7 +123051,7 @@ var init_timeback_controller = __esm(() => {
     });
     return ctx.services.timebackAdmin.getStudentOverview(gameId, timebackId, ctx.user, courseId);
   });
-  getStudentActivity = requireDeveloper(async (ctx) => {
+  getStudentActivity = requireGameManagementAccess(async (ctx) => {
     const timebackId = ctx.params.timebackId;
     const courseId = ctx.params.courseId;
     const gameId = ctx.url.searchParams.get("gameId") || undefined;
@@ -122604,7 +123114,7 @@ var init_timeback_controller = __esm(() => {
     });
     return ctx.services.timebackAdmin.adjustMasteredUnits(body2, ctx.user);
   });
-  toggleCompletion = requireDeveloper(async (ctx) => {
+  toggleCompletion = requireGameManagementAccess(async (ctx) => {
     const body2 = await parseRequestBody(ctx.request, ToggleCourseCompletionRequestSchema);
     logger63.debug("Toggling course completion", {
       requesterId: ctx.user.id,
@@ -122615,6 +123125,41 @@ var init_timeback_controller = __esm(() => {
     });
     return ctx.services.timebackAdmin.toggleCourseCompletion(body2, ctx.user);
   });
+  searchStudents = requireGameManagementAccess(async (ctx) => {
+    const gameId = ctx.params.gameId;
+    const courseId = ctx.params.courseId;
+    const query = ctx.url.searchParams.get("q") || "";
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
+    }
+    logger63.debug("Searching students for enrollment", {
+      requesterId: ctx.user.id,
+      gameId,
+      courseId,
+      query
+    });
+    return ctx.services.timebackAdmin.searchStudentsForEnrollment(gameId, courseId, query, ctx.user);
+  });
+  enrollStudent = requireGameManagementAccess(async (ctx) => {
+    const body2 = await parseRequestBody(ctx.request, EnrollStudentRequestSchema);
+    logger63.debug("Enrolling student", {
+      requesterId: ctx.user.id,
+      gameId: body2.gameId,
+      courseId: body2.courseId,
+      studentId: body2.studentId
+    });
+    return ctx.services.timebackAdmin.enrollStudent(body2, ctx.user);
+  });
+  unenrollStudent = requireGameManagementAccess(async (ctx) => {
+    const body2 = await parseRequestBody(ctx.request, UnenrollStudentRequestSchema);
+    logger63.debug("Unenrolling student", {
+      requesterId: ctx.user.id,
+      gameId: body2.gameId,
+      courseId: body2.courseId,
+      studentId: body2.studentId
+    });
+    return ctx.services.timebackAdmin.unenrollStudent(body2, ctx.user);
+  });
   timeback2 = {
     getTodayXp,
     getTotalXp,
@@ -122629,6 +123174,7 @@ var init_timeback_controller = __esm(() => {
     getConfig: getConfig2,
     deleteIntegrations,
     endActivity,
+    heartbeat,
     getStudentXp,
     getRoster,
     getStudentOverview,
@@ -122636,7 +123182,10 @@ var init_timeback_controller = __esm(() => {
     grantXp,
     adjustTime,
     adjustMastery,
-    toggleCompletion
+    toggleCompletion,
+    searchStudents,
+    enrollStudent,
+    unenrollStudent
   };
 });
 var logger64;
@@ -123612,6 +124161,7 @@ var init_timeback6 = __esm(() => {
   timebackRouter.get("/config/:gameId", handle2(timeback2.getConfig));
   timebackRouter.delete("/integrations/:gameId", handle2(timeback2.deleteIntegrations, { status: 204 }));
   timebackRouter.post("/end-activity", handle2(timeback2.endActivity));
+  timebackRouter.post("/heartbeat", handle2(timeback2.heartbeat));
   timebackRouter.get("/user", async (c2) => {
     const user = c2.get("user");
     const gameId = c2.get("gameId");
@@ -124007,6 +124557,203 @@ function printBanner(viteConfig, options) {
 import fs5 from "node:fs";
 import path3 from "node:path";
 import { loadPlaycademyConfig } from "playcademy/utils";
+
+// ../utils/src/uuid.ts
+var UUID_REGEX2 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+function isValidUUID2(value) {
+  if (!value || typeof value !== "string") {
+    return false;
+  }
+  return UUID_REGEX2.test(value);
+}
+// ../utils/src/ansi.ts
+var colors3 = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var styles3 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var cursor2 = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  up: (n3) => `\x1B[${n3}A`,
+  down: (n3) => `\x1B[${n3}B`,
+  forward: (n3) => `\x1B[${n3}C`,
+  back: (n3) => `\x1B[${n3}D`,
+  clearLine: "\x1B[K",
+  clearScreen: "\x1B[2J",
+  home: "\x1B[H"
+};
+var isInteractive2 = typeof process !== "undefined" && process.stdout?.isTTY && !process.env.CI && process.env.TERM !== "dumb";
+function stripAnsi2(text2) {
+  return text2.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+// ../utils/src/spinner.ts
+import { stdout as stdout2 } from "process";
+var SPINNER_FRAMES2 = [
+  10251,
+  10265,
+  10297,
+  10296,
+  10300,
+  10292,
+  10278,
+  10279,
+  10247,
+  10255
+].map((code) => String.fromCodePoint(code));
+var CHECK_MARK2 = String.fromCodePoint(10004);
+var CROSS_MARK2 = String.fromCodePoint(10006);
+var CANCEL_MARK2 = String.fromCodePoint(9675);
+var SPINNER_INTERVAL2 = 80;
+
+class Spinner3 {
+  tasks = new Map;
+  frameIndex = 0;
+  intervalId = null;
+  renderCount = 0;
+  previousLineCount = 0;
+  printedTasks = new Set;
+  indent;
+  constructor(taskIds, texts, options) {
+    this.indent = options?.indent ?? 0;
+    taskIds.forEach((id, index6) => {
+      this.tasks.set(id, {
+        text: texts[index6] || "",
+        status: "pending"
+      });
+    });
+  }
+  start() {
+    if (isInteractive2) {
+      stdout2.write(cursor2.hide);
+      this.render();
+      this.intervalId = setInterval(() => {
+        this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES2.length;
+        this.render();
+      }, SPINNER_INTERVAL2);
+    }
+  }
+  clear() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive2 && this.previousLineCount > 0) {
+      stdout2.write(cursor2.up(this.previousLineCount));
+      for (let i3 = 0;i3 < this.previousLineCount; i3++) {
+        stdout2.write(`\r${cursor2.clearLine}
+`);
+      }
+      stdout2.write(cursor2.up(this.previousLineCount));
+      stdout2.write(cursor2.show);
+    }
+    this.previousLineCount = 0;
+  }
+  updateTask(taskId, status, finalText) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      task.status = status;
+      if (finalText) {
+        task.finalText = finalText;
+      }
+      if (!isInteractive2) {
+        this.renderNonInteractive(taskId, task);
+      }
+    }
+  }
+  renderNonInteractive(taskId, task) {
+    const key = `${taskId}-${task.status}`;
+    if (this.printedTasks.has(key)) {
+      return;
+    }
+    this.printedTasks.add(key);
+    const indentStr = "  ".repeat(this.indent);
+    let line2 = "";
+    switch (task.status) {
+      case "running": {
+        line2 = `${indentStr}[RUNNING] ${stripAnsi2(task.text)}`;
+        break;
+      }
+      case "success": {
+        line2 = `${indentStr}[SUCCESS] ${stripAnsi2(task.finalText || task.text)}`;
+        break;
+      }
+      case "error": {
+        line2 = `${indentStr}[ERROR] Failed: ${stripAnsi2(task.text)}`;
+        break;
+      }
+      case "cancelled": {
+        line2 = `${indentStr}[CANCELLED] ${stripAnsi2(task.finalText || task.text)}`;
+        break;
+      }
+    }
+    console.log(line2);
+  }
+  render() {
+    if (this.previousLineCount > 0) {
+      stdout2.write(cursor2.up(this.previousLineCount));
+    }
+    const spinner = SPINNER_FRAMES2[this.frameIndex];
+    const indentStr = "  ".repeat(this.indent);
+    const visibleTasks = [...this.tasks.values()].filter((task) => task.status !== "pending");
+    for (const task of visibleTasks) {
+      stdout2.write(`\r${cursor2.clearLine}`);
+      let line2 = "";
+      switch (task.status) {
+        case "running": {
+          line2 = `${indentStr}${colors3.blue}${spinner}${styles3.reset} ${task.text}`;
+          break;
+        }
+        case "success": {
+          line2 = `${indentStr}${colors3.green}${CHECK_MARK2}${styles3.reset} ${task.finalText || task.text}`;
+          break;
+        }
+        case "error": {
+          line2 = `${indentStr}${colors3.red}${CROSS_MARK2}${styles3.reset} Failed: ${task.text}`;
+          break;
+        }
+        case "cancelled": {
+          line2 = `${indentStr}${colors3.gray}${CANCEL_MARK2}${styles3.reset} Cancelled: ${task.finalText || task.text}`;
+          break;
+        }
+      }
+      console.log(line2);
+    }
+    this.previousLineCount = visibleTasks.length;
+    this.renderCount++;
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive2) {
+      this.render();
+      stdout2.write(cursor2.show);
+    } else {
+      this.tasks.forEach((task, taskId) => {
+        if (task.status !== "pending") {
+          this.renderNonInteractive(taskId, task);
+        }
+      });
+    }
+  }
+}
+// src/lib/sandbox/project-info.ts
 function extractTimebackCourses(config2, timebackOptions) {
   const courses = config2?.integrations?.timeback?.courses;
   if (!courses || courses.length === 0) {
@@ -124040,17 +124787,20 @@ async function extractProjectInfo(viteConfig, timebackOptions) {
       packageJson = JSON.parse(packageJsonContent);
     }
   } catch {}
-  const name2 = config2?.name || packageJson.name || "";
-  let slug = name2;
-  if (slug.includes("/")) {
-    slug = slug.split("/")[1] || slug;
+  const name4 = config2?.name || packageJson.name || "";
+  let slug2 = name4;
+  if (slug2.includes("/")) {
+    slug2 = slug2.split("/")[1] || slug2;
   }
-  if (!slug) {
-    slug = directoryName;
+  if (!slug2) {
+    slug2 = directoryName;
   }
-  const displayName = slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const displayName = slug2.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const envGameId = process.env.SANDBOX_GAME_ID;
+  const gameId = envGameId && isValidUUID2(envGameId) ? envGameId : undefined;
   return {
-    slug,
+    gameId,
+    slug: slug2,
     displayName,
     version: packageJson.version || "dev",
     description: packageJson.description,
@@ -124546,7 +125296,8 @@ var TIMEBACK_COMPONENT_RESOURCE_DEFAULTS2;
 var init_timeback7 = __esm7(() => {
   TIMEBACK_ROUTES2 = {
     END_ACTIVITY: "/integrations/timeback/end-activity",
-    GET_XP: "/integrations/timeback/xp"
+    GET_XP: "/integrations/timeback/xp",
+    HEARTBEAT: "/integrations/timeback/heartbeat"
   };
   TIMEBACK_COURSE_DEFAULTS2 = {
     gradingScheme: "STANDARD",
@@ -125084,7 +125835,7 @@ var DEBOUNCE_MS = 500;
 var VITE_CONFIG_NAMES = ["vite.config.ts", "vite.config.js", "vite.config.mjs"];
 var debounceTimer = null;
 function findExistingFiles(projectRoot, fileNames) {
-  return fileNames.map((name2) => path4.join(projectRoot, name2)).filter((file) => fs7.existsSync(file));
+  return fileNames.map((name4) => path4.join(projectRoot, name4)).filter((file) => fs7.existsSync(file));
 }
 function createChangeHandler(server, viteConfig, platformModeOptions, watchedFiles) {
   return async (changedPath) => {
@@ -125152,7 +125903,7 @@ function cyclePlatformRoleHotkey(options) {
 
 // src/server/hotkeys/cycle-timeback-role.ts
 var import_picocolors9 = __toESM(require_picocolors(), 1);
-var { bold: bold4, cyan: cyan4, green: green4, red: red3, yellow: yellow3 } = import_picocolors9.default;
+var { bold: bold5, cyan: cyan4, green: green4, red: red3, yellow: yellow3 } = import_picocolors9.default;
 function cycleTimebackRole(logger) {
   const currentRole = getTimebackRoleOverride() ?? "student";
   const currentIndex = TIMEBACK_ROLES.indexOf(currentRole);
@@ -125171,14 +125922,14 @@ function cycleTimebackRole(logger) {
 function cycleTimebackRoleHotkey(options) {
   return {
     key: "t",
-    description: `${cyan4(bold4("[playcademy]"))} cycle Timeback role`,
+    description: `${cyan4(bold5("[playcademy]"))} cycle Timeback role`,
     action: () => cycleTimebackRole(options.viteConfig.logger)
   };
 }
 
 // src/server/hotkeys/recreate-database.ts
 var import_picocolors10 = __toESM(require_picocolors(), 1);
-var { bold: bold5, cyan: cyan5 } = import_picocolors10.default;
+var { bold: bold6, cyan: cyan5 } = import_picocolors10.default;
 async function recreateSandboxDatabase(options) {
   await recreateSandbox({
     viteConfig: options.viteConfig,
@@ -125188,7 +125939,7 @@ async function recreateSandboxDatabase(options) {
 function recreateDatabaseHotkey(options) {
   return {
     key: "d",
-    description: `${cyan5(bold5("[playcademy]"))} recreate sandbox database`,
+    description: `${cyan5(bold6("[playcademy]"))} recreate sandbox database`,
     action: () => recreateSandboxDatabase(options)
   };
 }
@@ -125198,7 +125949,7 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default2 = {
   name: "@playcademy/vite-plugin",
-  version: "0.2.23",
+  version: "0.2.24-beta.10",
   type: "module",
   exports: {
     ".": {