@playcademy/sandbox 0.12.2-beta.2 → 0.12.2-beta.4

package/dist/server.js

@@ -697,7 +697,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.12.2-beta.2",
+    version: "0.12.2-beta.4",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -21068,6 +21068,9 @@ var init_helpers = __esm(() => {
 function isBaseGameTimebackIntegration() {
   return sql`${gameTimebackIntegrations.kind} = ${BASE_GAME_TIMEBACK_INTEGRATION_KIND}`;
 }
+function isBaseGameTimebackIntegrationRow(integration) {
+  return integration.kind === BASE_GAME_TIMEBACK_INTEGRATION_KIND;
+}
 function isActiveGameTimebackIntegrationStatus(statusColumn = gameTimebackIntegrations.status) {
   return sql`${statusColumn} IS DISTINCT FROM ${DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS}`;
 }
@@ -48676,6 +48679,7 @@ var init_schemas4 = __esm(() => {
     appName: stringType().optional(),
     sensorUrl: stringType().url().optional(),
     courseId: stringType().min(1).optional(),
+    enrollmentId: stringType().min(1).optional(),
     courseName: stringType().optional(),
     studentEmail: stringType().email().optional()
   });
@@ -80041,6 +80045,9 @@ function normalizedIdentityCase2(value) {
 function frameworkAliasKey2(value) {
   return value.normalize("NFKC").toLocaleLowerCase("en-US").replace(/[^a-z0-9]+/g, "");
 }
+function isUuidShaped2(value) {
+  return UUID_PATTERN2.test(value.trim());
+}
 function isCommonCoreMathIdentifier2(identifier) {
   const canonical = normalizedIdentityCase2(normalizedWhitespace2(identifier));
   return canonical.startsWith("CCSS.MATH.") || /^(?:K|[1-8])\.(?:CC|OA|NBT|NF|MD|RP|NS|EE|F|G|SP)\./.test(canonical) || /^(?:HS)?(?:N|A|F|G|S)-[A-Z]+\./.test(canonical) || /^MP\.?\d/.test(canonical);
@@ -80072,6 +80079,14 @@ function canonicalIdentifier2(framework, authoredIdentifier) {
   }
   return identifier;
 }
+function readableAlignmentIdentifier2(alignment) {
+  const identifier = alignment.identifier?.trim() ?? "";
+  if (identifier && !isUuidShaped2(identifier)) {
+    return identifier;
+  }
+  const id = alignment.id.trim();
+  return id && !isUuidShaped2(id) ? id : "";
+}
 function canonicalAssessmentStandardRef2(standard) {
   const authoredFramework = normalizedWhitespace2(standard.framework);
   const framework = canonicalFramework2(authoredFramework, standard.identifier);
@@ -80178,7 +80193,23 @@ function qtiStandardsFromMetadata(metadata2) {
   standards.push(...qtiAlignmentStandardsFromMetadata2(metadata2));
   return dedupeStandards2(standards);
 }
-var EVENT_HANDLER_ATTRIBUTE, SCRIPT_SCHEMES2, DATA_RASTER_IMAGE_PATTERN2, QTI_MATHML_ALLOWED_TAGS2, metadataSymbol2, parser2, SUPPORTED_QTI_INTERACTION_TYPES2, URL_ATTRIBUTES3, IMAGE_URL_ATTRIBUTES3, INTERACTION_TYPES2, XML_NAMED_ENTITIES, EMPHASIS_TAGS2, STRONG_TAGS2, CONTENT_SKIPPED_TAGS2, BLOCK_CONTENT_KINDS2, GAP_MATCH_TOKEN_TAGS2, STAGE_GRAPHIC_EXCLUDED_CONTAINERS2, BLANK_SENTINEL2 = "￿", MARKED_BLANK_PATTERN2, MARKED_BLANK_GLOBAL_PATTERN2, REGION_SHAPE_COORDS, QTI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0", QTI_AUTHORING_BLANK_MARKER = "___", MATCH_CORRECT_TEMPLATE2 = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE2 = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES2, RESPONSE_PROCESSING_TEMPLATES2, GLOBAL_BODY_ATTRIBUTES, BODY_ELEMENT_ATTRIBUTES, MATHML_ATTRIBUTES, VOID_BODY_ELEMENTS2, URL_ATTRIBUTES22, IMAGE_URL_ATTRIBUTES22, INTERACTION_ATTRIBUTES, CHOICE_ATTRIBUTES, CHOICE_ELEMENT_ATTRIBUTES, VOID_CHOICE_ELEMENTS2, NUMERIC_COMPARISON_ATTRIBUTES2, RESPONSE_CARDINALITIES2, RESPONSE_BASE_TYPES2, BLANK_SENTINEL22 = "￿", QTI_FLOAT_VALUE, PLAYABLE_POINT_VALUE, POINT_INTERACTION_TYPES2, INDEPENDENT_PROCESSING_TAGS2, PRIVATE_PLAYABLE_KEYS2, trimmedNonEmptyString2, finiteNumber22, positiveFiniteNumber2, IDENTIFIER_VALUE2, DIRECTED_PAIR_VALUE2, scoringMatchComparisonSchema2, scoringNumericEqualComparisonSchema2, scoringNumericEqualRoundedComparisonSchema2, scoringRuleSchema2, scoringRulesSchema2, scoringItemSchema2, assessmentScoringArtifactItemsSchema2, assessmentScoringArtifactSchema2, SUPPORTED_BASE_TYPES2, SUPPORTED_CARDINALITIES2, MATCH_CORRECT_TEMPLATES2, QtiScoringArtifactValidationError, COMMON_CORE_MATH_FRAMEWORK_ALIASES2, COMMON_CORE_ELA_FRAMEWORK_ALIASES2, COMMON_CORE_FRAMEWORK_ALIASES2;
+function qtiAssessmentStandardRefsFromMetadata2(metadata2) {
+  const refs = new Map;
+  for (const alignment of qtiAlignmentStandardsFromMetadata2(metadata2)) {
+    const identifier = readableAlignmentIdentifier2(alignment);
+    if (identifier) {
+      const canonical = canonicalAssessmentStandardRef2({
+        framework: alignment.source,
+        identifier
+      });
+      if (canonical.framework && canonical.identifier) {
+        refs.set(assessmentStandardRefKey2(canonical), canonical);
+      }
+    }
+  }
+  return [...refs.values()];
+}
+var EVENT_HANDLER_ATTRIBUTE, SCRIPT_SCHEMES2, DATA_RASTER_IMAGE_PATTERN2, QTI_MATHML_ALLOWED_TAGS2, metadataSymbol2, parser2, SUPPORTED_QTI_INTERACTION_TYPES2, URL_ATTRIBUTES3, IMAGE_URL_ATTRIBUTES3, INTERACTION_TYPES2, XML_NAMED_ENTITIES, EMPHASIS_TAGS2, STRONG_TAGS2, CONTENT_SKIPPED_TAGS2, BLOCK_CONTENT_KINDS2, GAP_MATCH_TOKEN_TAGS2, STAGE_GRAPHIC_EXCLUDED_CONTAINERS2, BLANK_SENTINEL2 = "￿", MARKED_BLANK_PATTERN2, MARKED_BLANK_GLOBAL_PATTERN2, REGION_SHAPE_COORDS, QTI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0", QTI_AUTHORING_BLANK_MARKER = "___", MATCH_CORRECT_TEMPLATE2 = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE2 = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES2, RESPONSE_PROCESSING_TEMPLATES2, GLOBAL_BODY_ATTRIBUTES, BODY_ELEMENT_ATTRIBUTES, MATHML_ATTRIBUTES, VOID_BODY_ELEMENTS2, URL_ATTRIBUTES22, IMAGE_URL_ATTRIBUTES22, INTERACTION_ATTRIBUTES, CHOICE_ATTRIBUTES, CHOICE_ELEMENT_ATTRIBUTES, VOID_CHOICE_ELEMENTS2, NUMERIC_COMPARISON_ATTRIBUTES2, RESPONSE_CARDINALITIES2, RESPONSE_BASE_TYPES2, BLANK_SENTINEL22 = "￿", QTI_FLOAT_VALUE, PLAYABLE_POINT_VALUE, POINT_INTERACTION_TYPES2, INDEPENDENT_PROCESSING_TAGS2, PRIVATE_PLAYABLE_KEYS2, trimmedNonEmptyString2, finiteNumber22, positiveFiniteNumber2, IDENTIFIER_VALUE2, DIRECTED_PAIR_VALUE2, scoringMatchComparisonSchema2, scoringNumericEqualComparisonSchema2, scoringNumericEqualRoundedComparisonSchema2, scoringRuleSchema2, scoringRulesSchema2, scoringItemSchema2, assessmentScoringArtifactItemsSchema2, assessmentScoringArtifactSchema2, SUPPORTED_BASE_TYPES2, SUPPORTED_CARDINALITIES2, MATCH_CORRECT_TEMPLATES2, QtiScoringArtifactValidationError, UUID_PATTERN2, COMMON_CORE_MATH_FRAMEWORK_ALIASES2, COMMON_CORE_ELA_FRAMEWORK_ALIASES2, COMMON_CORE_FRAMEWORK_ALIASES2;
 var init_qti = __esm(() => {
   init_timeback4();
   init_timeback4();
@@ -80540,6 +80571,7 @@ var init_qti = __esm(() => {
       this.name = "QtiScoringArtifactValidationError";
     }
   };
+  UUID_PATTERN2 = /^(?:urn:uuid:)?\{?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}?$/i;
   COMMON_CORE_MATH_FRAMEWORK_ALIASES2 = new Set([
     "ccssm",
     "ccssmath",
@@ -80749,7 +80781,7 @@ function pruneUnreadableStandards(standards) {
   return standards.filter(hasReadableStandardLabel);
 }
 function parseQuestionIndex(title) {
-  const match = title.match(/\bquestion[\s_-]*(\d+)\b/i);
+  const match = title?.match(/\bquestion[\s_-]*(\d+)\b/i);
   const index = match ? Number(match[1]) : Number.NaN;
   return Number.isFinite(index) && index > 0 ? index : null;
 }
@@ -80783,14 +80815,15 @@ function qtiQuestionsByIndex(qtiQuestions) {
   }
   return questionsByIndex;
 }
+function normalizedQuestionScore(score, scorePercentile) {
+  const rawValue = numberField(score) ?? numberField(scorePercentile);
+  return rawValue !== null && rawValue > 1 ? rawValue / 100 : rawValue;
+}
 function getQuestionCorrectness(result) {
   if (!result) {
     return "unknown";
   }
-  const score = numberField(result.score);
-  const scorePercentile = numberField(result.scorePercentile);
-  const rawValue = score ?? scorePercentile;
-  const value = rawValue !== null && rawValue > 1 ? rawValue / 100 : rawValue;
+  const value = normalizedQuestionScore(result.score, result.scorePercentile);
   if (value === null) {
     return "unknown";
   }
@@ -81054,10 +81087,71 @@ var init_timeback_mastery_completion_util = __esm(async () => {
   await init_errors8();
 });
 
+// ../api-core/src/utils/bounded-map.util.ts
+function setBounded(map, key, value, maxSize) {
+  map.delete(key);
+  if (map.size >= maxSize) {
+    const oldestKey = map.keys().next().value;
+    if (oldestKey !== undefined) {
+      map.delete(oldestKey);
+    }
+  }
+  map.set(key, value);
+}
+
+// ../api-core/src/utils/timeback-qti-test-lookup.util.ts
+async function resolveQtiTestId(client, testName, parentLineItem) {
+  const cacheKey = `${parentLineItem.sourcedId ?? ""}:${testName}`;
+  const cached = cache.get(cacheKey);
+  if (cached) {
+    setBounded(cache, cacheKey, cached, MAX_CACHE_SIZE);
+    return cached;
+  }
+  let resource = null;
+  const resourceId = sourceIdFromRef(parentLineItem.componentResource);
+  if (resourceId) {
+    resource = await client.api.oneroster.resources.get(resourceId).catch(() => null);
+  }
+  for (const candidate of qtiIdCandidates(parentLineItem, resource)) {
+    const test = await client.qtiApi.assessmentTests.get(candidate).catch(() => null);
+    if (test?.identifier) {
+      setBounded(cache, cacheKey, test.identifier, MAX_CACHE_SIZE);
+      return test.identifier;
+    }
+  }
+  const normalizedTestName = testName.trim();
+  if (!normalizedTestName) {
+    return "";
+  }
+  for (let page = 1;page <= TITLE_LOOKUP_MAX_PAGES; page++) {
+    const list = await client.qtiApi.assessmentTests.list({
+      query: normalizedTestName,
+      limit: TITLE_LOOKUP_LIMIT,
+      page,
+      sort: "title",
+      order: "asc"
+    }).catch(() => null);
+    const qtiTestId = findQtiAssessmentTestIdByTitle(list?.items ?? [], normalizedTestName);
+    if (qtiTestId) {
+      setBounded(cache, cacheKey, qtiTestId, MAX_CACHE_SIZE);
+      return qtiTestId;
+    }
+    const itemCount = list?.items?.length ?? 0;
+    if (!list || itemCount < TITLE_LOOKUP_LIMIT || typeof list.pages === "number" && page >= list.pages) {
+      break;
+    }
+  }
+  return "";
+}
+var MAX_CACHE_SIZE = 500, TITLE_LOOKUP_LIMIT = 50, TITLE_LOOKUP_MAX_PAGES = 5, cache;
+var init_timeback_qti_test_lookup_util = __esm(() => {
+  init_timeback_grade_level_results_util();
+  cache = new Map;
+});
+
 // ../api-core/src/services/timeback-admin.service.ts
 class TimebackAdminService {
   deps;
-  qtiTestIdCache = new Map;
   static XP_PRECISION_FACTOR = 10;
   static RECENT_ACTIVITY_LIMIT = 20;
   static MAX_STUDENT_ACTIVITY_LIMIT = 200;
@@ -81072,9 +81166,6 @@ class TimebackAdminService {
   static GAME_METRICS_FETCH_TIMEOUT_MS = 1e4;
   static GAME_METRICS_LIST_FETCH_TIMEOUT_MS = 3000;
   static GAME_METRICS_RUN_IDS_PER_REQUEST = 50;
-  static MAX_QTI_TEST_ID_CACHE_SIZE = 500;
-  static QTI_TEST_TITLE_LOOKUP_LIMIT = 50;
-  static QTI_TEST_TITLE_LOOKUP_MAX_PAGES = 5;
   constructor(deps) {
     this.deps = deps;
   }
@@ -81934,68 +82025,6 @@ class TimebackAdminService {
       return { activities: activitiesWithGameMetrics, hasMore };
     });
   }
-  rememberQtiTestId(cacheKey, qtiTestId) {
-    if (!qtiTestId) {
-      this.qtiTestIdCache.delete(cacheKey);
-      return;
-    }
-    if (this.qtiTestIdCache.has(cacheKey)) {
-      this.qtiTestIdCache.delete(cacheKey);
-    } else if (this.qtiTestIdCache.size >= TimebackAdminService.MAX_QTI_TEST_ID_CACHE_SIZE) {
-      const oldestKey = this.qtiTestIdCache.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.qtiTestIdCache.delete(oldestKey);
-      }
-    }
-    this.qtiTestIdCache.set(cacheKey, qtiTestId);
-  }
-  async resolveQtiTestIdForGradeLevelResult(client, testName, parentLineItem) {
-    const cacheKey = `${parentLineItem.sourcedId ?? ""}:${testName}`;
-    const cachedQtiTestId = cacheKey ? this.qtiTestIdCache.get(cacheKey) : undefined;
-    if (cachedQtiTestId) {
-      this.rememberQtiTestId(cacheKey, cachedQtiTestId);
-      return cachedQtiTestId;
-    }
-    let resource = null;
-    const resourceId = sourceIdFromRef(parentLineItem.componentResource);
-    if (resourceId) {
-      resource = await client.api.oneroster.resources.get(resourceId).catch(() => null);
-    }
-    for (const candidate of qtiIdCandidates(parentLineItem, resource)) {
-      const test = await client.qtiApi.assessmentTests.get(candidate).catch(() => null);
-      if (test?.identifier) {
-        if (cacheKey) {
-          this.rememberQtiTestId(cacheKey, test.identifier);
-        }
-        return test.identifier;
-      }
-    }
-    const normalizedTestName = testName.trim();
-    if (!normalizedTestName) {
-      return "";
-    }
-    for (let page = 1;page <= TimebackAdminService.QTI_TEST_TITLE_LOOKUP_MAX_PAGES; page++) {
-      const list = await client.qtiApi.assessmentTests.list({
-        query: normalizedTestName,
-        limit: TimebackAdminService.QTI_TEST_TITLE_LOOKUP_LIMIT,
-        page,
-        sort: "title",
-        order: "asc"
-      }).catch(() => null);
-      const qtiTestId = findQtiAssessmentTestIdByTitle(list?.items ?? [], normalizedTestName);
-      if (qtiTestId) {
-        if (cacheKey) {
-          this.rememberQtiTestId(cacheKey, qtiTestId);
-        }
-        return qtiTestId;
-      }
-      const itemCount = list?.items?.length ?? 0;
-      if (!list || itemCount < TimebackAdminService.QTI_TEST_TITLE_LOOKUP_LIMIT || typeof list.pages === "number" && page >= list.pages) {
-        break;
-      }
-    }
-    return "";
-  }
   async getGradeLevelTestResults(user, options) {
     return this.withClientTelemetry(async () => {
       const { gameId, courseId, studentId } = options;
@@ -82098,7 +82127,7 @@ class TimebackAdminService {
       }).then((page) => page.data) : [];
       const latestResultsByLineItem = latestAssessmentResultsByLineItem(questionResults);
       const testName = resolveGradeLevelTestName(parentResult, parentLineItem);
-      const qtiTestId = await this.resolveQtiTestIdForGradeLevelResult(client, testName, parentLineItem);
+      const qtiTestId = await resolveQtiTestId(client, testName, parentLineItem);
       const qtiQuestions = qtiTestId ? await client.qtiApi.assessmentTests.getQuestions(qtiTestId).then((response) => response.questions ?? []).catch(() => []) : [];
       const questions = mapGradeLevelReviewQuestions({
         questionLineItems,
@@ -82792,6 +82821,7 @@ var init_timeback_admin_service = __esm(async () => {
   init_timeback_discrepancy_queue_util();
   init_timeback_game_metrics_comparison_util();
   init_timeback_grade_level_results_util();
+  init_timeback_qti_test_lookup_util();
   init_timeback_util();
   await __promiseAll([
     init_dist5(),
@@ -90690,6 +90720,22 @@ var init_timeback_assessments_service = __esm(async () => {
   await init_errors8();
 });
 
+// ../api-core/src/utils/timeback-attribution.util.ts
+function resolveRuntimeAttribution(base, holeFilling, requestedCourseId, recordedCourseId) {
+  const recorded = [base, ...holeFilling].find((integration) => integration.courseId === recordedCourseId);
+  if (recorded) {
+    return { integration: recorded, requestedCourseIdStatus: "pinned_by_run" };
+  }
+  if (requestedCourseId === undefined) {
+    return { integration: base, requestedCourseIdStatus: "absent" };
+  }
+  if (requestedCourseId === base.courseId) {
+    return { integration: base, requestedCourseIdStatus: "accepted" };
+  }
+  const requestedHoleFilling = holeFilling.find((integration) => integration.courseId === requestedCourseId);
+  return requestedHoleFilling ? { integration: requestedHoleFilling, requestedCourseIdStatus: "accepted_hole_filling" } : { integration: base, requestedCourseIdStatus: "ignored_mismatch" };
+}
+
 // ../api-core/src/utils/timeback-create-integration.util.ts
 function buildTimebackBaseConfigFromExistingConfig(config) {
   return {
@@ -90782,6 +90828,128 @@ var init_timeback_create_integration_util = __esm(() => {
   init_timeback_util();
 });
 
+// ../api-core/src/utils/timeback-hole-filling-context.util.ts
+function buildAssignmentResultWhere(options) {
+  return {
+    status: "active",
+    "student.sourcedId": options.studentId,
+    "metadata.resultType": options.resultType,
+    "metadata.assignmentId": options.assignmentId
+  };
+}
+function assignmentIdOf(record) {
+  const value = metadataOf(record).assignmentId;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  const text = stringField3(value).trim();
+  return text || undefined;
+}
+function toTriggeringResult(result) {
+  const metadata2 = metadataOf(result);
+  const testType = normalizeTestType(metadata2.testType);
+  const assignmentId = assignmentIdOf(result);
+  const lineItemId = sourceIdFromRef(result.assessmentLineItem);
+  if (!assignmentId || !lineItemId || result.scoreStatus !== SCORE_STATUS2.fullyGraded || !isAllowedGradeLevelTestType(testType)) {
+    return null;
+  }
+  return {
+    resultId: result.sourcedId ?? "",
+    assignmentId,
+    lineItemId,
+    testName: stringField3(metadata2.testName) || lineItemId,
+    testType,
+    score: numberField(result.score),
+    scoreDate: result.scoreDate ?? null,
+    totalQuestions: numberField(metadata2.totalQuestions),
+    correctQuestions: numberField(metadata2.correctQuestions)
+  };
+}
+function isMissed(resultText, score, scorePercentile) {
+  const marking = stringField3(resultText).trim().toLowerCase();
+  if (marking) {
+    return marking !== "correct";
+  }
+  const value = normalizedQuestionScore(score, scorePercentile);
+  return value !== null && value < 1;
+}
+function missedQuestionsFromInlineResponses(result) {
+  const responses = metadataOf(result).responses;
+  const questions = isRecord6(responses) && Array.isArray(responses.questions) ? responses.questions : undefined;
+  if (!questions?.length) {
+    return;
+  }
+  return questions.flatMap((question) => {
+    if (!isRecord6(question) || !isMissed(question.result, question.score)) {
+      return [];
+    }
+    const questionNumber = numberField(question.questionNumber);
+    const qtiItemId = stringField3(question.questionQtiIdentifier).trim();
+    return questionNumber === null ? [] : [{ questionNumber, ...qtiItemId && { qtiItemId } }];
+  });
+}
+function questionNumberFromLineItemId(lineItemId) {
+  const match = lineItemId.match(/_q(\d+)$/);
+  const value = match ? Number(match[1]) : Number.NaN;
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
+function missedQuestionsFromQuestionResults(questionResults) {
+  return [...latestAssessmentResultsByLineItem(questionResults)].flatMap(([lineItemId, result]) => {
+    const questionNumber = questionNumberFromLineItemId(lineItemId);
+    const responses = metadataOf(result).responses;
+    const response = isRecord6(responses) && isRecord6(responses.response) ? responses.response : undefined;
+    if (questionNumber === null || !isMissed(response?.result, result.score, result.scorePercentile)) {
+      return [];
+    }
+    const qtiItemId = stringField3(response?.questionQtiIdentifier).trim();
+    return [{ questionNumber, ...qtiItemId && { qtiItemId } }];
+  }).toSorted((a, b) => a.questionNumber - b.questionNumber);
+}
+function qtiItemIdForQuestionNumber(qtiQuestions) {
+  const byNumber = qtiQuestionsByIndex(qtiQuestions);
+  return (questionNumber) => {
+    const question = byNumber.get(questionNumber) ?? qtiQuestions[questionNumber - 1];
+    return question ? question.question.identifier || question.reference.identifier : undefined;
+  };
+}
+function groupMissedStandards(missed, standardsByItemId, itemIdFor) {
+  const byKey = new Map;
+  const untagged = [];
+  for (const question of missed) {
+    const itemId = question.qtiItemId ?? itemIdFor(question.questionNumber);
+    const standards = itemId ? standardsByItemId.get(itemId) ?? [] : [];
+    if (!standards.length) {
+      untagged.push(question.questionNumber);
+    }
+    for (const standard of standards) {
+      const key = `${standard.framework}\x00${standard.identifier}`;
+      const entry = byKey.get(key) ?? {
+        framework: standard.framework,
+        code: standard.identifier,
+        questionNumbers: [],
+        qtiItemIds: []
+      };
+      entry.questionNumbers.push(question.questionNumber);
+      if (itemId && !entry.qtiItemIds.includes(itemId)) {
+        entry.qtiItemIds.push(itemId);
+      }
+      byKey.set(key, entry);
+    }
+  }
+  return {
+    missedStandards: [...byKey.values()].toSorted((a, b) => b.questionNumbers.length - a.questionNumbers.length || a.code.localeCompare(b.code, undefined, { numeric: true })),
+    untaggedQuestionNumbers: untagged.toSorted((a, b) => a - b)
+  };
+}
+function standardsFromQtiItem(item) {
+  return qtiAssessmentStandardRefsFromMetadata2(metadataOf(item));
+}
+var init_timeback_hole_filling_context_util = __esm(() => {
+  init_constants2();
+  init_qti();
+  init_timeback_grade_level_results_util();
+});
+
 // ../api-core/src/utils/timeback-promotion.util.ts
 async function promoteCompletedCourse({
   db,
@@ -90911,14 +91079,20 @@ var init_timeback_service = __esm(async () => {
   init_helpers_index();
   init_tables_index();
   init_spans();
+  init_constants2();
   init_types2();
   init_errors2();
   init_timeback_create_integration_util();
+  init_timeback_grade_level_results_util();
+  init_timeback_hole_filling_context_util();
   init_timeback_promotion_util();
+  init_timeback_qti_test_lookup_util();
   init_timeback_removed_integration_util();
   init_timeback_util();
   await init_dist5();
   TimebackService = class TimebackService {
+    static HOLE_FILLING_CONTEXT_TTL_MS = 10 * 60 * 1000;
+    static HOLE_FILLING_CONTEXT_CACHE_SIZE = 1000;
     static HEARTBEAT_DEDUPE_TTL_MS = 5 * 60 * 1000;
     static processedHeartbeatWindows = new Map;
     static inFlightHeartbeatWindows = new Map;
@@ -90926,6 +91100,7 @@ var init_timeback_service = __esm(async () => {
     static COMPLETION_IN_FLIGHT_SETTLE_DELAY_MS = 400;
     static COMPLETION_IN_FLIGHT_SETTLE_ATTEMPTS = 5;
     deps;
+    holeFillingContextCache = new Map;
     static cleanHeartbeatDedupeCache(now = Date.now()) {
       for (const [key, timestamp] of this.processedHeartbeatWindows) {
         if (now - timestamp > this.HEARTBEAT_DEDUPE_TTL_MS) {
@@ -90949,13 +91124,13 @@ var init_timeback_service = __esm(async () => {
     static clearInFlightHeartbeatWindow(key) {
       this.inFlightHeartbeatWindows.delete(key);
     }
-    static buildCompletionCaliperEventId(key, kind, discriminator = "completion") {
+    static buildCompletionCaliperEventId(key, kind, baseCourseId, discriminator = "completion") {
       const hash = createHash3("sha256").update([
         "playcademy",
         "timeback",
         kind,
         key.gameId,
-        key.courseId,
+        baseCourseId,
         key.studentId,
         key.runId,
         key.activityId,
@@ -91021,11 +91196,14 @@ var init_timeback_service = __esm(async () => {
         } : null
       };
     }
-    static async acquireCompletionReservation(db, key) {
-      let reserveOutcome = await this.reserveCompletion(db, key);
+    static async acquireCompletionReservation(db, key, otherCourseIds = []) {
+      function reserve() {
+        return otherCourseIds.length > 0 ? TimebackService.reserveCompletionAcrossCourses(db, key, otherCourseIds) : TimebackService.reserveCompletion(db, key);
+      }
+      let reserveOutcome = await reserve();
       for (let settleAttempt = 0;reserveOutcome.status === "in_flight" && settleAttempt < this.COMPLETION_IN_FLIGHT_SETTLE_ATTEMPTS; settleAttempt++) {
         await sleep(this.COMPLETION_IN_FLIGHT_SETTLE_DELAY_MS);
-        reserveOutcome = await this.reserveCompletion(db, key);
+        reserveOutcome = await reserve();
       }
       if (reserveOutcome.status === "duplicate") {
         setAttribute("app.timeback.end_activity_status", "blocked_by_dedupe_guard");
@@ -91044,8 +91222,24 @@ var init_timeback_service = __esm(async () => {
       }
       return { status: "reserved", token: reserveOutcome.token };
     }
-    static async runWithCompletionReservation(db, key, emit, awardFromResult) {
-      const acquired = await this.acquireCompletionReservation(db, key);
+    static async reserveCompletionAcrossCourses(db, key, otherCourseIds) {
+      return db.transaction(async (tx) => {
+        const database = tx;
+        const runKey = `timeback-completion:${key.gameId.toLowerCase()}:${key.studentId}:${key.runId.toLowerCase()}:${key.activityId}`;
+        await database.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${runKey}, 0))`);
+        const onOtherCourse = await database.query.gameTimebackActivityCompletions.findFirst({
+          columns: { id: true },
+          where: and(eq(gameTimebackActivityCompletions.gameId, key.gameId), eq(gameTimebackActivityCompletions.studentId, key.studentId), eq(gameTimebackActivityCompletions.runId, key.runId), eq(gameTimebackActivityCompletions.activityId, key.activityId), inArray(gameTimebackActivityCompletions.courseId, [...otherCourseIds]))
+        });
+        if (onOtherCourse) {
+          setAttribute("app.timeback.end_activity_status", "completion_reserved_on_other_course");
+          throw new ServiceUnavailableError("An end-activity submission for this run is already in flight — retry shortly");
+        }
+        return this.reserveCompletion(database, key);
+      });
+    }
+    static async runWithCompletionReservation(db, key, emit, awardFromResult, otherCourseIds = []) {
+      const acquired = await this.acquireCompletionReservation(db, key, otherCourseIds);
       if (acquired.status === "duplicate") {
         return acquired;
       }
@@ -91080,6 +91274,9 @@ var init_timeback_service = __esm(async () => {
       await db.delete(gameTimebackActivityCompletions).where(and(eq(gameTimebackActivityCompletions.id, token.id), eq(gameTimebackActivityCompletions.reservedAt, token.reservedAt), isNull(gameTimebackActivityCompletions.completedAt)));
     }
     static addResumeIdToExtensions(extensions, resumeId) {
+      return TimebackService.addPlaycademyExtensions(extensions, { resumeId });
+    }
+    static addPlaycademyExtensions(extensions, fields) {
       const base = extensions ?? {};
       const existingPlaycademy = base.playcademy;
       const playcademy = typeof existingPlaycademy === "object" && existingPlaycademy !== null && !Array.isArray(existingPlaycademy) ? existingPlaycademy : {};
@@ -91087,28 +91284,71 @@ var init_timeback_service = __esm(async () => {
         ...base,
         playcademy: {
           ...playcademy,
-          resumeId
+          ...fields
         }
       };
     }
-    static resolveRuntimeCourse(resolvedCourseId, requestedCourseId, courseName) {
-      let requestedCourseIdStatus = "absent";
-      if (requestedCourseId === resolvedCourseId) {
-        requestedCourseIdStatus = "accepted";
-      } else if (requestedCourseId !== undefined) {
-        requestedCourseIdStatus = "ignored_mismatch";
+    async resolveRuntimeCourse({
+      gameId,
+      studentId,
+      runId,
+      activityData,
+      extensions
+    }) {
+      const integrations = await this.deps.db.query.gameTimebackIntegrations.findMany({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveGameTimebackIntegrationStatus())
+      });
+      const base = integrations.find(isBaseGameTimebackIntegrationRow);
+      if (!base) {
+        throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
       }
+      const holeFilling = integrations.filter((integration) => !isBaseGameTimebackIntegrationRow(integration));
+      const recordedCourseId = holeFilling.length > 0 && runId ? await this.findRecordedRunCourse({
+        gameId,
+        studentId,
+        runId,
+        activityId: activityData.activityId,
+        courseIds: integrations.map((i2) => i2.courseId)
+      }) : undefined;
+      const { integration, requestedCourseIdStatus } = resolveRuntimeAttribution(base, holeFilling, activityData.courseId, recordedCourseId);
+      const hintUsed = activityData.courseId === integration.courseId;
+      const enrollmentId = hintUsed ? activityData.enrollmentId : undefined;
+      const isHoleFilling = !isBaseGameTimebackIntegrationRow(integration);
       return {
-        courseId: resolvedCourseId,
-        courseName: requestedCourseIdStatus === "ignored_mismatch" ? undefined : courseName,
+        integration,
+        courseId: integration.courseId,
+        baseCourseId: base.courseId,
+        otherCourseIds: holeFilling.length > 0 ? integrations.map((other) => other.courseId).filter((courseId) => courseId !== integration.courseId) : [],
+        courseName: activityData.courseId === undefined || hintUsed ? activityData.courseName : undefined,
+        extensions: isHoleFilling ? TimebackService.addPlaycademyExtensions(extensions, {
+          courseKind: HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND,
+          baseCourseId: base.courseId,
+          ...enrollmentId && { enrollmentId }
+        }) : extensions,
         attributes: {
-          "app.timeback.course_id": resolvedCourseId,
-          "app.timeback.resolved_course_id": resolvedCourseId,
-          "app.timeback.requested_course_id": requestedCourseId,
-          "app.timeback.requested_course_id_status": requestedCourseIdStatus
+          "app.timeback.course_id": integration.courseId,
+          "app.timeback.resolved_course_id": integration.courseId,
+          "app.timeback.requested_course_id": activityData.courseId,
+          "app.timeback.requested_course_id_status": requestedCourseIdStatus,
+          "app.timeback.course_kind": integration.kind,
+          "app.timeback.enrollment_id": enrollmentId
         }
       };
     }
+    async findRecordedRunCourse({
+      gameId,
+      studentId,
+      runId,
+      activityId,
+      courseIds
+    }) {
+      const recorded = await this.deps.db.query.gameTimebackActivityCompletions.findFirst({
+        columns: { courseId: true },
+        where: and(eq(gameTimebackActivityCompletions.gameId, gameId), eq(gameTimebackActivityCompletions.studentId, studentId), eq(gameTimebackActivityCompletions.runId, runId), eq(gameTimebackActivityCompletions.activityId, activityId), inArray(gameTimebackActivityCompletions.courseId, courseIds)),
+        orderBy: (table, { asc }) => [asc(table.createdAt)]
+      });
+      return recorded?.courseId;
+    }
     static recordRuntimeContext({
       operation,
       studentId,
@@ -91234,19 +91474,163 @@ var init_timeback_service = __esm(async () => {
     }
     async getUserEnrollments(userId, gameId) {
       return this.withClientTelemetry(async () => {
-        const userData = await this.deps.db.query.users.findFirst({
-          where: eq(users.id, userId),
-          columns: { id: true, timebackId: true }
-        });
-        if (!userData) {
-          throw new NotFoundError("User", userId);
+        const enrollments = await this.fetchEnrollments(await this.requireTimebackId(userId));
+        return gameId ? filterEnrollmentsByGame(enrollments, gameId) : enrollments;
+      });
+    }
+    async requireTimebackId(userId) {
+      const userData = await this.deps.db.query.users.findFirst({
+        where: eq(users.id, userId),
+        columns: { id: true, timebackId: true }
+      });
+      if (!userData) {
+        throw new NotFoundError("User", userId);
+      }
+      if (!userData.timebackId) {
+        throw new NotFoundError("Timeback account not found for user");
+      }
+      return userData.timebackId;
+    }
+    async getHoleFillingContext(userId, gameId) {
+      return this.withClientTelemetry(async () => {
+        setAttribute("app.timeback.operation", "get_hole_filling_context");
+        const studentId = await this.requireTimebackId(userId);
+        const enrollments = filterEnrollmentsByGame(await this.fetchEnrollments(studentId), gameId);
+        const holeFilling = enrollments.filter((enrollment) => enrollment.kind === HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND);
+        setAttribute("app.timeback.hole_filling_enrollment_count", holeFilling.length);
+        if (holeFilling.length === 0) {
+          return { contexts: [] };
         }
-        if (!userData.timebackId) {
-          throw new NotFoundError("Timeback account not found for user");
+        const contexts = await Promise.all(holeFilling.map((enrollment) => this.buildHoleFillingContext(studentId, enrollment)));
+        return { contexts };
+      });
+    }
+    async buildHoleFillingContext(studentId, enrollment) {
+      const client = this.requireClient();
+      const grade = enrollment.grade;
+      const subject = enrollment.subject;
+      const enrollmentContext = {
+        courseId: enrollment.courseId,
+        baseCourseId: enrollment.baseCourseId ?? "",
+        ...enrollment.id && { enrollmentId: enrollment.id },
+        grade,
+        subject,
+        beginDate: enrollment.beginDate ?? null
+      };
+      const stampedAssignmentId = assignmentIdOf({ metadata: enrollment.enrollmentMetadata });
+      let parent = null;
+      if (stampedAssignmentId) {
+        const where = {
+          ...buildAssignmentResultWhere({
+            studentId,
+            assignmentId: stampedAssignmentId,
+            resultType: "assessment"
+          }),
+          scoreStatus: SCORE_STATUS2.fullyGraded
+        };
+        const page = await client.api.oneroster.assessmentResults.list({
+          limit: 1,
+          where,
+          sort: "scoreDate",
+          orderBy: "desc"
+        });
+        parent = page.data[0] ?? null;
+      }
+      const summary = parent ? toTriggeringResult(parent) : null;
+      let trigger = "not_stamped";
+      if (stampedAssignmentId) {
+        trigger = summary ? "found" : "not_found";
+      }
+      setAttributes({
+        "app.timeback.hole_filling_trigger": trigger,
+        "app.timeback.hole_filling_assignment_id": stampedAssignmentId
+      });
+      if (!parent || !summary) {
+        return {
+          enrollment: enrollmentContext,
+          triggeringResult: null,
+          missedStandards: [],
+          untaggedMissedQuestionNumbers: []
+        };
+      }
+      const cacheKey = `${enrollment.courseId}:${studentId}:${summary.resultId}`;
+      const cached = this.holeFillingContextCache.get(cacheKey);
+      if (cached && Date.now() - cached.at < TimebackService.HOLE_FILLING_CONTEXT_TTL_MS) {
+        return { ...cached.context, enrollment: enrollmentContext };
+      }
+      const { context, complete } = await this.resolveMissedStandards(studentId, parent, summary, enrollmentContext);
+      setAttribute("app.timeback.hole_filling_standards_complete", complete);
+      if (complete) {
+        setBounded(this.holeFillingContextCache, cacheKey, { at: Date.now(), context }, TimebackService.HOLE_FILLING_CONTEXT_CACHE_SIZE);
+      }
+      return context;
+    }
+    async resolveMissedStandards(studentId, parent, summary, enrollmentContext) {
+      const client = this.requireClient();
+      let complete = true;
+      let missed = missedQuestionsFromInlineResponses(parent);
+      if (!missed) {
+        const where = buildAssignmentResultWhere({
+          studentId,
+          assignmentId: summary.assignmentId,
+          resultType: "question"
+        });
+        const questionResults = await client.api.oneroster.assessmentResults.listAll({
+          limit: 200,
+          where,
+          sort: "scoreDate",
+          orderBy: "desc"
+        });
+        missed = missedQuestionsFromQuestionResults(questionResults);
+      }
+      let qtiTestId = "";
+      let qtiQuestions = [];
+      const standardsByItemId = new Map;
+      if (missed.length > 0 && !client.hasQti) {
+        complete = false;
+        missed = missed.map(({ questionNumber }) => ({ questionNumber }));
+      } else if (missed.some((question) => !question.qtiItemId)) {
+        const lineItem = await client.api.oneroster.assessmentLineItems.get(summary.lineItemId).catch(() => null);
+        qtiTestId = lineItem ? await resolveQtiTestId(client, resolveGradeLevelTestName(parent, lineItem), lineItem) : "";
+        complete &&= Boolean(qtiTestId);
+        if (qtiTestId) {
+          qtiQuestions = await client.qtiApi.assessmentTests.getQuestions(qtiTestId).then((response) => response.questions ?? []).catch(() => {
+            complete = false;
+            return [];
+          });
+          for (const question of qtiQuestions) {
+            const id = question.question.identifier || question.reference.identifier;
+            if (id) {
+              standardsByItemId.set(id, standardsFromQtiItem(question.question));
+            }
+          }
         }
-        const enrollments = await this.fetchEnrollments(userData.timebackId);
-        return gameId ? filterEnrollmentsByGame(enrollments, gameId) : enrollments;
+      }
+      const itemIdsToFetch = [
+        ...new Set(missed.flatMap((question) => question.qtiItemId && !standardsByItemId.has(question.qtiItemId) ? [question.qtiItemId] : []))
+      ];
+      const items = await Promise.all(itemIdsToFetch.map((id) => client.qtiApi.assessmentItems.get(id).then((item) => [id, standardsFromQtiItem(item)]).catch(() => {
+        complete = false;
+        return [id, []];
+      })));
+      for (const [id, standards] of items) {
+        standardsByItemId.set(id, standards);
+      }
+      const { missedStandards, untaggedQuestionNumbers } = groupMissedStandards(missed, standardsByItemId, qtiItemIdForQuestionNumber(qtiQuestions));
+      setAttributes({
+        "app.timeback.hole_filling_missed_question_count": missed.length,
+        "app.timeback.hole_filling_missed_standard_count": missedStandards.length,
+        "app.timeback.hole_filling_untagged_question_count": untaggedQuestionNumbers.length
       });
+      return {
+        context: {
+          enrollment: enrollmentContext,
+          triggeringResult: { ...summary, ...qtiTestId && { qtiTestId } },
+          missedStandards,
+          untaggedMissedQuestionNumbers: untaggedQuestionNumbers
+        },
+        complete
+      };
     }
     async getUserDataByTimebackId(timebackId) {
       return this.withClientTelemetry(async () => {
@@ -92090,17 +92474,21 @@ var init_timeback_service = __esm(async () => {
           activityData
         });
         await this.deps.validateDeveloperAccess(user, gameId);
-        const integration = await db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveBaseGameTimebackIntegration())
-        });
-        if (!integration) {
-          throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
-        }
         const {
+          integration,
           courseId: runtimeCourseId,
+          baseCourseId,
+          otherCourseIds,
           courseName: runtimeCourseName,
+          extensions: runtimeExtensions,
           attributes: courseAttributes
-        } = TimebackService.resolveRuntimeCourse(integration.courseId, activityData.courseId, activityData.courseName);
+        } = await this.resolveRuntimeCourse({
+          gameId,
+          studentId,
+          runId,
+          activityData,
+          extensions: extensionsWithResumeId
+        });
         const scorePercentage = scoreData.totalQuestions > 0 ? scoreData.correctQuestions / scoreData.totalQuestions * 100 : 0;
         const dedupeKey = runId !== undefined ? {
           gameId,
@@ -92129,12 +92517,12 @@ var init_timeback_service = __esm(async () => {
           courseId: runtimeCourseId,
           courseName: runtimeCourseName,
           studentEmail: activityData.studentEmail,
-          extensions: extensionsWithResumeId,
+          extensions: runtimeExtensions,
           ...runId ? { runId } : {}
         };
-        const completionEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "completion") : undefined;
-        const sessionEndEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "session-end", effectiveResumeId) : undefined;
-        const completionHistoryEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "course-completed") : undefined;
+        const completionEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "completion", baseCourseId) : undefined;
+        const sessionEndEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "session-end", baseCourseId, effectiveResumeId) : undefined;
+        const completionHistoryEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "course-completed", baseCourseId) : undefined;
         function emitRecord() {
           return client.activity.record(runtimeCourseId, studentId, {
             ...activityEventContext,
@@ -92158,7 +92546,7 @@ var init_timeback_service = __esm(async () => {
             xpAwarded: emitted.xpAwarded,
             masteredUnitsApplied: emitted.masteredUnitsApplied,
             pctCompleteApp: emitted.pctCompleteApp ?? null
-          }));
+          }), otherCourseIds);
           if (outcome.status === "duplicate") {
             blockedByDedupeGuard = true;
             duplicateAward = outcome.award;
@@ -92206,6 +92594,7 @@ var init_timeback_service = __esm(async () => {
           return {
             status: "ok",
             courseId: runtimeCourseId,
+            courseKind: integration.kind,
             xpAwarded: duplicateAward?.xpAwarded ?? 0,
             masteredUnits: duplicateAward?.masteredUnitsApplied ?? 0,
             ...duplicateAward?.pctCompleteApp != null ? { pctCompleteApp: duplicateAward.pctCompleteApp } : {},
@@ -92218,6 +92607,7 @@ var init_timeback_service = __esm(async () => {
         return {
           status: "ok",
           courseId: runtimeCourseId,
+          courseKind: integration.kind,
           xpAwarded: result.xpAwarded,
           masteredUnits: result.masteredUnitsApplied,
           pctCompleteApp: result.pctCompleteApp,
@@ -92394,7 +92784,6 @@ var init_timeback_service = __esm(async () => {
     }) {
       return this.withClientTelemetry(async () => {
         const client = this.requireClient();
-        const db = this.deps.db;
         const hasWindowStartedAtMs = windowStartedAtMs !== undefined;
         const hasWindowSequence = windowSequence !== undefined;
         if (hasWindowStartedAtMs === hasWindowSequence) {
@@ -92422,17 +92811,17 @@ var init_timeback_service = __esm(async () => {
           return inFlightHeartbeat;
         }
         const pendingHeartbeat = (async () => {
-          const integration = await db.query.gameTimebackIntegrations.findFirst({
-            where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveBaseGameTimebackIntegration())
-          });
-          if (!integration) {
-            throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
-          }
           const {
             courseId: runtimeCourseId,
             courseName: runtimeCourseName,
+            extensions: runtimeExtensions,
             attributes: courseAttributes
-          } = TimebackService.resolveRuntimeCourse(integration.courseId, activityData.courseId, activityData.courseName);
+          } = await this.resolveRuntimeCourse({
+            gameId,
+            studentId,
+            activityData,
+            extensions: TimebackService.addResumeIdToExtensions(undefined, effectiveResumeId)
+          });
           const activeTimeSeconds = timingData.activeMs / 1000;
           const inactiveTimeSeconds = timingData.pausedMs / 1000;
           if (activeTimeSeconds > 0 || inactiveTimeSeconds > 0) {
@@ -92448,7 +92837,7 @@ var init_timeback_service = __esm(async () => {
               courseId: runtimeCourseId,
               courseName: runtimeCourseName,
               studentEmail: activityData.studentEmail,
-              extensions: TimebackService.addResumeIdToExtensions(undefined, effectiveResumeId),
+              extensions: runtimeExtensions,
               ...runId ? { runId } : {}
             });
           }
@@ -94801,33 +95190,33 @@ var init_auth_provider = __esm(async () => {
 function createSandboxCacheProvider() {
   return {
     async get(key) {
-      const entry = cache.get(key);
+      const entry = cache2.get(key);
       if (!entry) {
         return null;
       }
       if (entry.expiresAt < Date.now()) {
-        cache.delete(key);
+        cache2.delete(key);
         return null;
       }
       return entry.value;
     },
     async set(key, value, ttlSeconds = 300) {
-      cache.set(key, {
+      cache2.set(key, {
         value,
         expiresAt: Date.now() + ttlSeconds * 1000
       });
     },
     async delete(key) {
-      cache.delete(key);
+      cache2.delete(key);
     }
   };
 }
 function clearSandboxCache() {
-  cache.clear();
+  cache2.clear();
 }
-var cache;
+var cache2;
 var init_cache_provider = __esm(() => {
-  cache = new Map;
+  cache2 = new Map;
 });
 
 // ../utils/src/keys.ts
@@ -151055,7 +151444,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, getHoleFillingCourses, createHoleFillingCourse, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, reviseAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserHoleFillingContext, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, getHoleFillingCourses, createHoleFillingCourse, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, reviseAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -151081,6 +151470,12 @@ var init_timeback_controller = __esm(() => {
   });
   getUser = requireNonAnonymous(async (ctx) => ctx.services.timeback.getUserData(ctx.user.id, ctx.gameId));
   getUserEnrollments = requireNonAnonymous(async (ctx) => ctx.services.timeback.getUserEnrollments(ctx.user.id, ctx.gameId));
+  getUserHoleFillingContext = requireNonAnonymous(async (ctx) => {
+    if (!ctx.gameId) {
+      throw ApiError.forbidden("Hole-filling context requires a game token");
+    }
+    return ctx.services.timeback.getHoleFillingContext(ctx.user.id, ctx.gameId);
+  });
   getUserById = requireNonAnonymous(async (ctx) => {
     const timebackId = ctx.params.timebackId;
     if (!timebackId) {
@@ -151934,6 +152329,7 @@ var init_timeback_controller = __esm(() => {
     populateStudent,
     getUser,
     getUserEnrollments,
+    getUserHoleFillingContext,
     getUserById,
     setupIntegration,
     getIntegrations,
@@ -152996,6 +153392,12 @@ var init_timeback8 = __esm(async () => {
     }
     return handle2(timeback2.getUserEnrollments)(c);
   });
+  timebackRouter.get("/user/hole-filling-context", async (c) => {
+    if (shouldMockTimeback()) {
+      return c.json({ contexts: [] });
+    }
+    return handle2(timeback2.getUserHoleFillingContext)(c);
+  });
   timebackRouter.get("/user/:timebackId", async (c) => {
     const user = c.get("user");
     if (!user) {