@playcademy/vite-plugin 0.2.24-beta.6 → 0.2.24-beta.8

package/dist/index.js

@@ -25336,7 +25336,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.3.17-beta.9",
+    version: "0.3.17-beta.11",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -29951,6 +29951,7 @@ var init_esm = __esm(() => {
 function createMinimalConfig(overrides) {
   return apiConfigSchema.parse({
     stage: "local",
+    isLocal: false,
     ...overrides
   });
 }
@@ -29978,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(),
@@ -54196,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;
 }
@@ -54240,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) {
@@ -54264,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;
@@ -54318,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 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 mapAssessmentResultToRecentActivity(assessment, relevantCourseIds, courseIdByLineItemId) {
-  if (!assessment.scoreDate || !assessment.assessmentLineItem?.sourcedId) {
+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) {
@@ -54457,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 {
@@ -54467,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;
   }
@@ -54479,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");
@@ -54647,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 }
@@ -54655,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);
@@ -54686,101 +54763,31 @@ 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();
@@ -54877,11 +54884,11 @@ class TimebackAdminService {
     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.validateGameManagementAccess(user, gameId);
-    const [integration, sensorUrl] = await Promise.all([
+    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}`);
@@ -54889,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 };
@@ -54901,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,
@@ -54916,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,
@@ -54931,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,
@@ -55142,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(() => {
@@ -55164,6 +55160,7 @@ var init_timeback_admin_service = __esm(() => {
   init_utils6();
   init_src4();
   init_errors();
+  init_timeback_admin_util();
   init_timeback_util();
   logger16 = log.scope("TimebackAdminService");
 });
@@ -55207,6 +55204,18 @@ var init_timeback_service = __esm(() => {
     static clearInFlightHeartbeatWindow(key) {
       this.inFlightHeartbeatWindows.delete(key);
     }
+    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
+        }
+      };
+    }
     constructor(deps) {
       this.deps = deps;
     }
@@ -55671,6 +55680,7 @@ var init_timeback_service = __esm(() => {
       gameId,
       studentId,
       runId,
+      resumeId,
       activityData,
       scoreData,
       timingData,
@@ -55682,6 +55692,8 @@ var init_timeback_service = __esm(() => {
     }) {
       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))
@@ -55691,13 +55703,14 @@ var init_timeback_service = __esm(() => {
       }
       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,
+        extensions: extensionsWithResumeId,
         activityId: activityData.activityId,
         activityName: activityData.activityName,
         subject: activityData.subject,
@@ -55713,6 +55726,7 @@ var init_timeback_service = __esm(() => {
       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,
@@ -55723,6 +55737,7 @@ var init_timeback_service = __esm(() => {
           courseId: activityData.courseId,
           courseName: activityData.courseName,
           studentEmail: activityData.studentEmail,
+          extensions: extensionsWithResumeId,
           ...runId ? { runId } : {}
         });
       }
@@ -55747,20 +55762,29 @@ var init_timeback_service = __esm(() => {
       gameId,
       studentId,
       runId,
+      resumeId,
       activityData,
       timingData,
+      windowStartedAtMs,
       windowSequence,
       isFinal,
       user
     }) {
       const client = this.requireClient();
       const db2 = this.deps.db;
-      const heartbeatWindowKey = `${runId}:${windowSequence}`;
+      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
         });
@@ -55773,6 +55797,7 @@ var init_timeback_service = __esm(() => {
           gameId,
           studentId,
           runId,
+          windowStartedAtMs,
           windowSequence,
           isFinal
         });
@@ -55789,6 +55814,7 @@ var init_timeback_service = __esm(() => {
         const inactiveTimeSeconds = timingData.pausedMs / 1000;
         if (activeTimeSeconds > 0 || inactiveTimeSeconds > 0) {
           await client.recordSessionEnd(integration.courseId, studentId, {
+            gameId,
             activeTimeSeconds,
             ...inactiveTimeSeconds > 0 ? { inactiveTimeSeconds } : {},
             activityId: activityData.activityId,
@@ -55799,6 +55825,7 @@ var init_timeback_service = __esm(() => {
             courseId: activityData.courseId,
             courseName: activityData.courseName,
             studentEmail: activityData.studentEmail,
+            extensions: TimebackService2.addResumeIdToExtensions(undefined, effectiveResumeId),
             ...runId ? { runId } : {}
           });
         }
@@ -55808,6 +55835,7 @@ var init_timeback_service = __esm(() => {
           courseId: integration.courseId,
           studentId,
           runId,
+          windowStartedAtMs,
           windowSequence,
           activeTimeSeconds,
           isFinal
@@ -55959,6 +55987,7 @@ function createPlatformServices(deps) {
     validateGameManagementAccess
   });
   const timebackAdmin = new TimebackAdminService({
+    config: config2,
     db: db2,
     timeback: timebackClient,
     validateDeveloperAccess,
@@ -58889,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 = {
@@ -58933,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()}`,
@@ -58997,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()}`,
@@ -59042,7 +59094,8 @@ 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);
     },
@@ -59535,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,
@@ -59561,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,
@@ -59582,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,
@@ -59607,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,
@@ -60055,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", {
@@ -60077,6 +60132,7 @@ class ProgressRecorder {
       await this.emitCourseCompletionHistoryEvent({
         studentId,
         studentEmail,
+        gameId: progressData.gameId,
         activityId,
         courseId: ids.course,
         courseName,
@@ -60088,6 +60144,7 @@ class ProgressRecorder {
     await this.emitCaliperEvent({
       studentId,
       studentEmail,
+      gameId: progressData.gameId,
       activityId,
       activityName,
       courseId: ids.course,
@@ -60189,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}`;
@@ -60212,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,
@@ -60243,6 +60295,7 @@ class ProgressRecorder {
     await this.caliperNamespace.emitActivityEvent({
       studentId,
       studentEmail,
+      gameId,
       activityId,
       activityName,
       courseId,
@@ -60265,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,
@@ -60314,6 +60368,7 @@ class SessionRecorder {
     await this.caliperNamespace.emitTimeSpentEvent({
       studentId,
       studentEmail,
+      gameId: sessionData.gameId,
       activityId,
       activityName,
       courseId: ids.course,
@@ -118902,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,
@@ -118942,6 +119002,7 @@ async function seedCurrentProjectGame(db2, project) {
   }
 }
 var init_games = __esm(() => {
+  init_drizzle_orm();
   init_src();
   init_tables_index();
   init_constants();
@@ -120340,6 +120401,7 @@ var init_schemas11 = __esm(() => {
     gameId: exports_external.string().uuid(),
     studentId: exports_external.string().min(1),
     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),
@@ -120360,13 +120422,18 @@ var init_schemas11 = __esm(() => {
     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()
     }),
-    windowSequence: exports_external.number().int().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(),
@@ -120447,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(),
@@ -122836,6 +122906,7 @@ var init_timeback_controller = __esm(() => {
       gameId,
       studentId,
       runId,
+      resumeId,
       activityData,
       scoreData,
       timingData,
@@ -122849,6 +122920,7 @@ var init_timeback_controller = __esm(() => {
       gameId,
       studentId,
       runId,
+      resumeId,
       activityData,
       scoreData,
       timingData,
@@ -122872,11 +122944,23 @@ var init_timeback_controller = __esm(() => {
       }
       throw ApiError.badRequest("Invalid JSON body");
     }
-    const { gameId, studentId, runId, activityData, timingData, windowSequence, isFinal } = body2;
+    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
@@ -122885,8 +122969,10 @@ var init_timeback_controller = __esm(() => {
       gameId,
       studentId,
       runId,
+      resumeId,
       activityData,
       timingData,
+      windowStartedAtMs,
       windowSequence,
       isFinal,
       user: ctx.user
@@ -124471,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) {
@@ -124504,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,
@@ -125549,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) => {
@@ -125617,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);
@@ -125636,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,
@@ -125653,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)
   };
 }
@@ -125663,7 +125949,7 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default2 = {
   name: "@playcademy/vite-plugin",
-  version: "0.2.24-beta.6",
+  version: "0.2.24-beta.8",
   type: "module",
   exports: {
     ".": {

package/dist/types/internal.d.ts

@@ -77,6 +77,7 @@ export interface TimebackPluginContext {
  * Project information extracted from package.json and directory structure
  */
 export interface ProjectInfo {
+    gameId?: string;
     slug: string;
     displayName: string;
     version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.2.24-beta.6",
+    "version": "0.2.24-beta.8",
     "type": "module",
     "exports": {
         ".": {