@playcademy/vite-plugin 0.1.35 → 0.1.37

package/dist/index.js

@@ -41199,7 +41199,7 @@ var import_picocolors7 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "0.1.34",
+  version: "0.1.36",
   type: "module",
   exports: {
     ".": {
@@ -189515,7 +189515,9 @@ var init_constants = __esm3(() => {
     studentTTL: 600000,
     studentMaxSize: 500,
     assessmentTTL: 1800000,
-    assessmentMaxSize: 200
+    assessmentMaxSize: 200,
+    enrollmentTTL: 5000,
+    enrollmentMaxSize: 100
   };
   CONFIG_DEFAULTS = {
     fileNames: ["timeback.config.js", "timeback.config.json"]
@@ -189733,6 +189735,25 @@ class ResourceNotFoundError extends TimebackError {
     Object.setPrototypeOf(this, ResourceNotFoundError.prototype);
   }
 }
+init_constants();
+var isObject2 = (value) => typeof value === "object" && value !== null;
+var SUBJECT_VALUES = TIMEBACK_SUBJECTS;
+var GRADE_VALUES = TIMEBACK_GRADE_LEVELS;
+function isPlaycademyResourceMetadata(value) {
+  if (!isObject2(value)) {
+    return false;
+  }
+  if (!("mastery" in value) || value.mastery === undefined) {
+    return true;
+  }
+  return isObject2(value.mastery);
+}
+function isTimebackSubject(value) {
+  return typeof value === "string" && SUBJECT_VALUES.includes(value);
+}
+function isTimebackGrade(value) {
+  return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES.includes(value);
+}
 var isBrowser2 = () => {
   const g52 = globalThis;
   return typeof g52.window !== "undefined" && typeof g52.document !== "undefined";
@@ -190550,14 +190571,30 @@ function createOneRosterNamespace(client2) {
       update: async (sourcedId, data) => {
         return client2["request"](`${ONEROSTER_ENDPOINTS.assessmentResults}/${sourcedId}`, "PUT", data);
       },
-      getLatestForStudent: async (studentId, lineItemId) => {
+      getAttemptStats: async (studentId, lineItemId) => {
         try {
           const filter2 = `student.sourcedId='${studentId}' AND assessmentLineItem.sourcedId='${lineItemId}'`;
-          const url = `${ONEROSTER_ENDPOINTS.assessmentResults}?filter=${encodeURIComponent(filter2)}&sort=scoreDate&orderBy=desc&limit=1`;
+          const url = `${ONEROSTER_ENDPOINTS.assessmentResults}?filter=${encodeURIComponent(filter2)}`;
           const response = await client2["request"](url, "GET");
-          return response.assessmentResults[0] || null;
+          const results = response.assessmentResults || [];
+          if (results.length === 0)
+            return null;
+          let maxAttemptResult = results[0];
+          let maxAttemptNumber = maxAttemptResult.metadata?.attemptNumber || 0;
+          let activeAttemptCount = 0;
+          for (const result of results) {
+            const attemptNumber = result.metadata?.attemptNumber || 0;
+            if (attemptNumber > maxAttemptNumber) {
+              maxAttemptNumber = attemptNumber;
+              maxAttemptResult = result;
+            }
+            if (result.status === "active") {
+              activeAttemptCount++;
+            }
+          }
+          return { maxAttemptNumber, activeAttemptCount, maxAttemptResult };
         } catch (error2) {
-          logTimebackError("query latest assessment result", error2, {
+          logTimebackError("query attempt stats", error2, {
             studentId,
             lineItemId
           });
@@ -190841,6 +190878,7 @@ class TimebackCacheManager {
   studentCache;
   assessmentLineItemCache;
   resourceMasteryCache;
+  enrollmentCache;
   constructor() {
     this.studentCache = new TimebackCache({
       defaultTTL: CACHE_DEFAULTS.studentTTL,
@@ -190857,6 +190895,11 @@ class TimebackCacheManager {
       maxSize: CACHE_DEFAULTS.assessmentMaxSize,
       name: "ResourceMasteryCache"
     });
+    this.enrollmentCache = new TimebackCache({
+      defaultTTL: CACHE_DEFAULTS.enrollmentTTL,
+      maxSize: CACHE_DEFAULTS.enrollmentMaxSize,
+      name: "EnrollmentCache"
+    });
   }
   getStudent(key) {
     return this.studentCache.get(key);
@@ -190876,40 +190919,182 @@ class TimebackCacheManager {
   setResourceMasterableUnits(key, value) {
     this.resourceMasteryCache.set(key, value);
   }
+  getEnrollments(studentId) {
+    return this.enrollmentCache.get(studentId);
+  }
+  setEnrollments(studentId, enrollments) {
+    this.enrollmentCache.set(studentId, enrollments);
+  }
   clearAll() {
     this.studentCache.clear();
     this.assessmentLineItemCache.clear();
+    this.resourceMasteryCache.clear();
+    this.enrollmentCache.clear();
     log32.info("[TimebackCacheManager] All caches cleared");
   }
   getStats() {
     return {
       studentCache: this.studentCache.stats(),
       assessmentLineItemCache: this.assessmentLineItemCache.stats(),
-      resourceMasteryCache: this.resourceMasteryCache.stats()
+      resourceMasteryCache: this.resourceMasteryCache.stats(),
+      enrollmentCache: this.enrollmentCache.stats()
     };
   }
   cleanup() {
     this.studentCache.cleanup();
     this.assessmentLineItemCache.cleanup();
     this.resourceMasteryCache.cleanup();
+    this.enrollmentCache.cleanup();
     log32.debug("[TimebackCacheManager] Cache cleanup completed");
   }
 }
-function kebabToTitleCase(kebabStr) {
-  return kebabStr.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-init_constants();
 init_constants();
-var isObject2 = (value) => typeof value === "object" && value !== null;
-function isPlaycademyResourceMetadata(value) {
-  if (!isObject2(value)) {
-    return false;
+
+class MasteryTracker {
+  cacheManager;
+  onerosterNamespace;
+  edubridgeNamespace;
+  constructor(cacheManager, onerosterNamespace, edubridgeNamespace) {
+    this.cacheManager = cacheManager;
+    this.onerosterNamespace = onerosterNamespace;
+    this.edubridgeNamespace = edubridgeNamespace;
   }
-  if (!("mastery" in value) || value.mastery === undefined) {
-    return true;
+  async checkProgress(input) {
+    const { studentId, courseId, resourceId, masteredUnits } = input;
+    if (typeof masteredUnits !== "number" || masteredUnits <= 0) {
+      return;
+    }
+    const masterableUnits = await this.resolveMasterableUnits(resourceId);
+    if (!masterableUnits || masterableUnits <= 0) {
+      log32.warn("[MasteryTracker] No masterableUnits configured for course", {
+        courseId,
+        resourceId
+      });
+      return;
+    }
+    const facts = await this.fetchEnrollmentAnalyticsFacts(studentId, courseId);
+    if (!facts) {
+      log32.warn("[MasteryTracker] Unable to retrieve analytics for mastery-based completion", {
+        studentId,
+        courseId
+      });
+      return;
+    }
+    const historicalMasteredUnits = this.sumAnalyticsMetric(facts, "masteredUnits");
+    const totalMastered = historicalMasteredUnits + masteredUnits;
+    const rawPct = totalMastered / masterableUnits * 100;
+    const pctCompleteApp = Math.min(100, Math.max(0, Math.round(rawPct)));
+    const masteryAchieved = totalMastered >= masterableUnits;
+    return { pctCompleteApp, masteryAchieved };
+  }
+  async createCompletionEntry(studentId, courseId, classId, appName) {
+    const ids = deriveSourcedIds(courseId);
+    const lineItemId = `${ids.course}-mastery-completion-assessment`;
+    const resultId = `${lineItemId}:${studentId}:completion`;
+    try {
+      await this.onerosterNamespace.assessmentLineItems.findOrCreate(lineItemId, {
+        sourcedId: lineItemId,
+        title: "Mastery Completion",
+        status: ONEROSTER_STATUS.active,
+        ...classId ? { class: { sourcedId: classId } } : { course: { sourcedId: ids.course } },
+        ...ids.componentResource ? { componentResource: { sourcedId: ids.componentResource } } : {}
+      });
+      await this.onerosterNamespace.assessmentResults.upsert(resultId, {
+        sourcedId: resultId,
+        status: ONEROSTER_STATUS.active,
+        assessmentLineItem: { sourcedId: lineItemId },
+        student: { sourcedId: studentId },
+        score: 100,
+        scoreDate: new Date().toISOString(),
+        scoreStatus: SCORE_STATUS.fullyGraded,
+        inProgress: "false",
+        metadata: {
+          isMasteryCompletion: true,
+          completedAt: new Date().toISOString(),
+          appName
+        }
+      });
+      log32.info("[MasteryTracker] Created mastery completion entry", {
+        studentId,
+        lineItemId,
+        resultId
+      });
+    } catch (error2) {
+      log32.error("[MasteryTracker] Failed to create mastery completion entry", {
+        studentId,
+        lineItemId,
+        error: error2
+      });
+    }
+  }
+  async resolveMasterableUnits(resourceId) {
+    if (!resourceId) {
+      return;
+    }
+    const cached = this.cacheManager.getResourceMasterableUnits(resourceId);
+    if (cached !== undefined) {
+      return cached === null ? undefined : cached;
+    }
+    try {
+      const resource = await this.onerosterNamespace.resources.get(resourceId);
+      const playcademyMetadata = resource.metadata?.playcademy;
+      if (!playcademyMetadata) {
+        return;
+      }
+      const masterableUnits = isPlaycademyResourceMetadata(playcademyMetadata) ? playcademyMetadata.mastery?.masterableUnits : undefined;
+      this.cacheManager.setResourceMasterableUnits(resourceId, masterableUnits ?? null);
+      return masterableUnits;
+    } catch (error2) {
+      log32.error("[MasteryTracker] Failed to fetch resource metadata for mastery config", {
+        resourceId,
+        error: error2
+      });
+      this.cacheManager.setResourceMasterableUnits(resourceId, null);
+      return;
+    }
+  }
+  async fetchEnrollmentAnalyticsFacts(studentId, courseId) {
+    try {
+      const enrollments = await this.edubridgeNamespace.enrollments.listByUser(studentId);
+      const enrollment = enrollments.find((e2) => e2.course.id === courseId);
+      if (!enrollment) {
+        log32.warn("[MasteryTracker] Enrollment not found for student/course", {
+          studentId,
+          courseId
+        });
+        return;
+      }
+      const analytics = await this.edubridgeNamespace.analytics.getEnrollmentFacts(enrollment.id);
+      return analytics.facts;
+    } catch (error2) {
+      log32.error("[MasteryTracker] Failed to load enrollment analytics facts", {
+        studentId,
+        courseId,
+        error: error2
+      });
+      return;
+    }
+  }
+  sumAnalyticsMetric(facts, metric) {
+    if (!facts) {
+      return 0;
+    }
+    let total = 0;
+    Object.values(facts).forEach((dateFacts) => {
+      Object.values(dateFacts).forEach((subjectFacts) => {
+        const metrics = subjectFacts.activityMetrics;
+        if (metrics && typeof metrics[metric] === "number") {
+          total += metrics[metric];
+        }
+      });
+    });
+    return total;
   }
-  return isObject2(value.mastery);
 }
+function kebabToTitleCase(kebabStr) {
+  return kebabStr.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+init_constants();
 function validateProgressData(progressData) {
   if (!progressData.subject) {
     throw new ConfigurationError("subject", "Subject is required for Caliper events. Provide it in progressData.subject");
@@ -190963,13 +191148,13 @@ class ProgressRecorder {
   cacheManager;
   onerosterNamespace;
   caliperNamespace;
-  edubridgeNamespace;
-  constructor(studentResolver, cacheManager, onerosterNamespace, caliperNamespace, edubridgeNamespace) {
+  masteryTracker;
+  constructor(studentResolver, cacheManager, onerosterNamespace, caliperNamespace, masteryTracker) {
     this.studentResolver = studentResolver;
     this.cacheManager = cacheManager;
     this.onerosterNamespace = onerosterNamespace;
     this.caliperNamespace = caliperNamespace;
-    this.edubridgeNamespace = edubridgeNamespace;
+    this.masteryTracker = masteryTracker;
   }
   async record(courseId, studentIdentifier, progressData) {
     validateProgressData(progressData);
@@ -190978,22 +191163,22 @@ class ProgressRecorder {
     const { score, totalQuestions, correctQuestions, xpEarned, masteredUnits, attemptNumber } = progressData;
     const actualLineItemId = await this.resolveAssessmentLineItem(activityId, activityName, progressData.classId, ids);
     const currentAttemptNumber = await this.resolveAttemptNumber(attemptNumber, score, studentId, actualLineItemId);
-    const isFirstAttempt = currentAttemptNumber === 1;
-    const calculatedXp = this.calculateXpForProgress(progressData, totalQuestions, correctQuestions, xpEarned, isFirstAttempt);
+    const isFirstActiveAttempt = currentAttemptNumber === 1;
+    const calculatedXp = this.calculateXpForProgress(progressData, totalQuestions, correctQuestions, xpEarned, isFirstActiveAttempt);
     let extensions = progressData.extensions;
-    const completionProgress = await this.buildCompletionProgress({
+    const masteryProgress = await this.masteryTracker.checkProgress({
       studentId,
       courseId,
-      progressData,
-      resourceId: ids.resource
+      resourceId: ids.resource,
+      masteredUnits: progressData.masteredUnits ?? 0
     });
     let pctCompleteApp;
     let masteryAchieved = false;
-    let scoreStatus = SCORE_STATUS.partiallyGraded;
+    let scoreStatus = SCORE_STATUS.fullyGraded;
     const inProgress = "false";
-    if (completionProgress) {
-      masteryAchieved = completionProgress.masteryAchieved;
-      pctCompleteApp = completionProgress.pctCompleteApp;
+    if (masteryProgress) {
+      masteryAchieved = masteryProgress.masteryAchieved;
+      pctCompleteApp = masteryProgress.pctCompleteApp;
       extensions = {
         ...extensions || {},
         ...pctCompleteApp !== undefined ? { pctCompleteApp } : {}
@@ -191011,6 +191196,9 @@ class ProgressRecorder {
         attemptNumber: currentAttemptNumber
       });
     }
+    if (masteryAchieved) {
+      await this.masteryTracker.createCompletionEntry(studentId, courseId, progressData.classId, progressData.appName);
+    }
     await this.emitCaliperEvent(studentId, studentEmail, activityId, activityName, ids.course, courseName, totalQuestions, correctQuestions, calculatedXp, masteredUnits, currentAttemptNumber, progressData, extensions);
     return {
       xpAwarded: calculatedXp,
@@ -191039,8 +191227,9 @@ class ProgressRecorder {
     return actualLineItemId;
   }
   async resolveAttemptNumber(providedAttemptNumber, score, studentId, lineItemId) {
-    if (providedAttemptNumber)
+    if (providedAttemptNumber) {
       return providedAttemptNumber;
+    }
     if (score !== undefined) {
       return this.determineAttemptNumber(studentId, lineItemId);
     }
@@ -191064,106 +191253,13 @@ class ProgressRecorder {
     }
     return 0;
   }
-  async buildCompletionProgress({
-    studentId,
-    courseId,
-    progressData,
-    resourceId
-  }) {
-    if (typeof progressData.masteredUnits !== "number" || progressData.masteredUnits <= 0) {
-      return;
-    }
-    const masterableUnits = await this.resolveMasterableUnits(resourceId);
-    if (!masterableUnits || masterableUnits <= 0) {
-      log32.warn("[ProgressRecorder] No masterableUnits configured for course", {
-        courseId,
-        resourceId
-      });
-      return;
-    }
-    const facts = await this.fetchEnrollmentAnalyticsFacts(studentId, courseId);
-    if (!facts) {
-      log32.warn("[ProgressRecorder] Unable to retrieve analytics for mastery-based completion", { studentId, courseId });
-      return;
-    }
-    const historicalMasteredUnits = this.sumAnalyticsMetric(facts, "masteredUnits");
-    const totalMastered = historicalMasteredUnits + progressData.masteredUnits;
-    const rawPct = totalMastered / masterableUnits * 100;
-    const pctCompleteApp = Math.min(100, Math.max(0, Math.round(rawPct)));
-    const masteryAchieved = totalMastered >= masterableUnits;
-    return { pctCompleteApp, masteryAchieved };
-  }
-  async fetchEnrollmentAnalyticsFacts(studentId, courseId) {
-    try {
-      const enrollments = await this.edubridgeNamespace.enrollments.listByUser(studentId);
-      const enrollment = enrollments.find((e2) => e2.course.id === courseId);
-      if (!enrollment) {
-        log32.warn("[ProgressRecorder] Enrollment not found for student/course", {
-          studentId,
-          courseId
-        });
-        return;
-      }
-      const analytics = await this.edubridgeNamespace.analytics.getEnrollmentFacts(enrollment.id);
-      return analytics.facts;
-    } catch (error2) {
-      log32.error("[ProgressRecorder] Failed to load enrollment analytics facts", {
-        studentId,
-        courseId,
-        error: error2
-      });
-      return;
-    }
-  }
-  sumAnalyticsMetric(facts, metric) {
-    if (!facts) {
-      return 0;
-    }
-    let total = 0;
-    Object.values(facts).forEach((dateFacts) => {
-      Object.values(dateFacts).forEach((subjectFacts) => {
-        const metrics = subjectFacts.activityMetrics;
-        if (metrics && typeof metrics[metric] === "number") {
-          total += metrics[metric];
-        }
-      });
-    });
-    return total;
-  }
-  async resolveMasterableUnits(resourceId) {
-    if (!resourceId) {
-      return;
-    }
-    const cached = this.cacheManager.getResourceMasterableUnits(resourceId);
-    if (cached !== undefined) {
-      return cached === null ? undefined : cached;
-    }
-    try {
-      const resource = await this.onerosterNamespace.resources.get(resourceId);
-      const playcademyMetadata = resource.metadata?.playcademy;
-      if (!playcademyMetadata) {
-        return;
-      }
-      const masterableUnits = isPlaycademyResourceMetadata(playcademyMetadata) ? playcademyMetadata.mastery?.masterableUnits : undefined;
-      this.cacheManager.setResourceMasterableUnits(resourceId, masterableUnits ?? null);
-      return masterableUnits;
-    } catch (error2) {
-      log32.error("[ProgressRecorder] Failed to fetch resource metadata for mastery config", {
-        resourceId,
-        error: error2
-      });
-      this.cacheManager.setResourceMasterableUnits(resourceId, null);
-      return;
-    }
-  }
   async getOrCreateLineItem(lineItemId, activityName, classId, ids) {
     try {
       const lineItem = await this.onerosterNamespace.assessmentLineItems.findOrCreate(lineItemId, {
         sourcedId: lineItemId,
         title: activityName,
         status: ONEROSTER_STATUS.active,
-        ...classId ? { class: { sourcedId: classId } } : { course: { sourcedId: ids.course } },
-        ...ids.componentResource ? { componentResource: { sourcedId: ids.componentResource } } : ids.component ? { component: { sourcedId: ids.component } } : {}
+        ...classId ? { class: { sourcedId: classId } } : { course: { sourcedId: ids.course } }
       });
       if (!lineItem.sourcedId) {
         throw new TimebackError(`Assessment line item created but has no sourcedId. This should not happen and indicates an upstream API issue.`);
@@ -191181,21 +191277,15 @@ class ProgressRecorder {
     }
   }
   async determineAttemptNumber(studentId, lineItemId) {
-    const latestAttempt = await this.onerosterNamespace.assessmentResults.getLatestForStudent(studentId, lineItemId);
-    if (latestAttempt) {
-      const previousAttemptNumber = latestAttempt.metadata?.attemptNumber || 0;
-      const newAttemptNumber = previousAttemptNumber + 1;
-      log32.debug("[ProgressRecorder] Found previous attempt, incrementing", {
-        previousAttemptNumber,
-        newAttemptNumber,
-        previousScore: latestAttempt.score
-      });
-      return newAttemptNumber;
+    const stats = await this.onerosterNamespace.assessmentResults.getAttemptStats(studentId, lineItemId);
+    if (stats) {
+      return stats.activeAttemptCount + 1;
     }
     return 1;
   }
   async createGradebookEntry(lineItemId, studentId, attemptNumber, score, totalQuestions, correctQuestions, xp, masteredUnits, scoreStatus, inProgress, appName) {
-    const resultId = `${lineItemId}:${studentId}:attempt-${attemptNumber}`;
+    const timestamp4 = Date.now().toString(36);
+    const resultId = `${lineItemId}:${studentId}:${timestamp4}`;
     await this.onerosterNamespace.assessmentResults.upsert(resultId, {
       sourcedId: resultId,
       status: ONEROSTER_STATUS.active,
@@ -193966,9 +194056,9 @@ class ZodUnion2 extends ZodType2 {
     return this._def.options;
   }
 }
-ZodUnion2.create = (types4, params) => {
+ZodUnion2.create = (types22, params) => {
   return new ZodUnion2({
-    options: types4,
+    options: types22,
     typeName: ZodFirstPartyTypeKind2.ZodUnion,
     ...processCreateParams2(params)
   });
@@ -195351,7 +195441,8 @@ class TimebackClient {
     this.edubridge = createEduBridgeNamespace(this);
     this.cacheManager = new TimebackCacheManager;
     this.studentResolver = new StudentResolver(this.cacheManager, this.oneroster);
-    this.progressRecorder = new ProgressRecorder(this.studentResolver, this.cacheManager, this.oneroster, this.caliper, this.edubridge);
+    const masteryTracker = new MasteryTracker(this.cacheManager, this.oneroster, this.edubridge);
+    this.progressRecorder = new ProgressRecorder(this.studentResolver, this.cacheManager, this.oneroster, this.caliper, masteryTracker);
     this.sessionRecorder = new SessionRecorder(this.studentResolver, this.caliper);
     if (this.credentials) {
       this._ensureAuthenticated().catch((error2) => {
@@ -195471,18 +195562,27 @@ class TimebackClient {
     await this._ensureAuthenticated();
     return this.sessionRecorder.record(courseId, studentIdentifier, sessionData);
   }
-  async getEnrollments(studentId, options) {
+  async getEnrollments(studentId) {
+    const cached = this.cacheManager.getEnrollments(studentId);
+    if (cached) {
+      return cached;
+    }
     await this._ensureAuthenticated();
-    const classes = await this.oneroster.classes.listByStudent(studentId, options);
-    return classes.filter((cls) => cls.sourcedId && cls.status && cls.course?.sourcedId).map((cls) => ({
-      sourcedId: cls.sourcedId,
-      title: cls.title,
-      classCode: cls.classCode ?? null,
-      courseId: cls.course.sourcedId,
-      status: cls.status,
-      grades: cls.grades ?? null,
-      subjects: cls.subjects ?? null
-    }));
+    const edubridgeEnrollments = await this.edubridge.enrollments.listByUser(studentId);
+    const enrollments = edubridgeEnrollments.map((enrollment) => {
+      const grades = enrollment.course.grades ? enrollment.course.grades.map((g52) => parseInt(g52, 10)).filter(isTimebackGrade) : null;
+      const subjects = enrollment.course.subjects ? enrollment.course.subjects.filter(isTimebackSubject) : null;
+      return {
+        sourcedId: enrollment.id,
+        title: enrollment.course.title,
+        courseId: enrollment.course.id,
+        status: "active",
+        grades,
+        subjects
+      };
+    });
+    this.cacheManager.setEnrollments(studentId, enrollments);
+    return enrollments;
   }
   clearCaches() {
     this.cacheManager.clearAll();
@@ -195721,7 +195821,9 @@ var init_constants2 = __esm4(() => {
     studentTTL: 600000,
     studentMaxSize: 500,
     assessmentTTL: 1800000,
-    assessmentMaxSize: 200
+    assessmentMaxSize: 200,
+    enrollmentTTL: 5000,
+    enrollmentMaxSize: 100
   };
   CONFIG_DEFAULTS2 = {
     fileNames: ["timeback.config.js", "timeback.config.json"]
@@ -195789,8 +195891,8 @@ var init_constants2 = __esm4(() => {
 });
 init_constants2();
 var isObject3 = (value) => typeof value === "object" && value !== null;
-var SUBJECT_VALUES = TIMEBACK_SUBJECTS2;
-var GRADE_VALUES = TIMEBACK_GRADE_LEVELS2;
+var SUBJECT_VALUES2 = TIMEBACK_SUBJECTS2;
+var GRADE_VALUES2 = TIMEBACK_GRADE_LEVELS2;
 function isCourseMetadata(value) {
   return isObject3(value);
 }
@@ -195806,11 +195908,11 @@ function isPlaycademyResourceMetadata2(value) {
   }
   return isObject3(value.mastery);
 }
-function isTimebackSubject(value) {
-  return typeof value === "string" && SUBJECT_VALUES.includes(value);
+function isTimebackSubject2(value) {
+  return typeof value === "string" && SUBJECT_VALUES2.includes(value);
 }
-function isTimebackGrade(value) {
-  return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES.includes(value);
+function isTimebackGrade2(value) {
+  return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES2.includes(value);
 }
 var UUID_REGEX = /^[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 isValidUUID(value) {
@@ -209934,11 +210036,11 @@ async function setupTimebackIntegration(ctx) {
       totalXp: derivedTotalXp,
       masterableUnits: derivedMasterableUnits
     } = courseConfig;
-    if (!isTimebackSubject(subject)) {
+    if (!isTimebackSubject2(subject)) {
       log2.error("[API] Invalid subject in TimeBack request", { subject });
       throw ApiError.badRequest(`Invalid subject "${subject}" provided for course "${title}".`);
     }
-    if (!isTimebackGrade(grade)) {
+    if (!isTimebackGrade2(grade)) {
       log2.error("[API] Invalid grade in TimeBack request", { grade });
       throw ApiError.badRequest(`Invalid grade "${grade}" provided for course "${title}".`);
     }
@@ -210334,14 +210436,34 @@ async function getStudentEnrollments(ctx) {
   if (!timebackId) {
     throw ApiError.badRequest("Missing timebackId parameter");
   }
+  const db = getDatabase();
+  const isLocal = process.env.PUBLIC_IS_LOCAL === "true";
+  if (isLocal) {
+    log2.debug("[API] Local mode: returning all integrations as mock enrollments", {
+      userId: user.id,
+      timebackId
+    });
+    const allIntegrations = await db.query.gameTimebackIntegrations.findMany();
+    const enrollments2 = allIntegrations.map((integration) => ({
+      gameId: integration.gameId,
+      grade: integration.grade,
+      subject: integration.subject,
+      courseId: integration.courseId
+    }));
+    log2.info("[API] Retrieved mock enrollments (local mode)", {
+      userId: user.id,
+      timebackId,
+      enrollmentCount: enrollments2.length
+    });
+    return { enrollments: enrollments2 };
+  }
   log2.debug("[API] Getting student enrollments", { userId: user.id, timebackId });
   const client2 = await getTimebackClient();
-  const classes = await client2.getEnrollments(timebackId, { limit: 100 });
+  const classes = await client2.getEnrollments(timebackId);
   const courseIds = classes.map((cls) => cls.courseId).filter((id) => Boolean(id));
   if (courseIds.length === 0) {
     return { enrollments: [] };
   }
-  const db = getDatabase();
   const integrations = await db.query.gameTimebackIntegrations.findMany({
     where: inArray(gameTimebackIntegrations.courseId, courseIds)
   });
@@ -210549,11 +210671,11 @@ timebackRouter.post("/end-activity", async (c3) => {
     return c3.json(createUnknownErrorResponse(error2), 500);
   }
 });
-timebackRouter.get("/enrollments/:studentId", async (c3) => {
-  const studentId = c3.req.param("studentId");
+timebackRouter.get("/enrollments/:timebackId", async (c3) => {
+  const timebackId = c3.req.param("timebackId");
   const ctx = {
     user: c3.get("user"),
-    params: { studentId },
+    params: { timebackId },
     url: new URL(c3.req.url),
     request: c3.req.raw
   };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.1.35",
+    "version": "0.1.37",
     "type": "module",
     "exports": {
         ".": {
@@ -21,7 +21,7 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.14.22"
+        "playcademy": "0.14.24"
     },
     "devDependencies": {
         "@inquirer/prompts": "^7.8.6",