@playcademy/vite-plugin 1.3.1-beta.1 → 1.3.1-beta.2

package/dist/index.js

@@ -24317,7 +24317,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.3.1-beta.1",
+  version: "1.3.1-beta.2",
   type: "module",
   exports: {
     ".": {
@@ -25934,7 +25934,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.8.1-beta.1",
+    version: "0.8.1-beta.2",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -26324,6 +26324,9 @@ async function runWithConcurrency(items, concurrency, worker) {
   }
   return results;
 }
+function reviewBankSinkIdentifier(integrationId) {
+  return `playcademy-review-bank.${integrationId}`;
+}
 function playcademySupportedQtiInteractionType(value) {
   if (typeof value !== "string") {
     return;
@@ -34411,9 +34414,12 @@ function classifyAssessmentSubmission(attempt, submissionId) {
   }
   return isAssessmentAttemptOpen(attempt) ? "submit" : "reject";
 }
+function isSameAssessmentAward(recorded, input) {
+  return recorded.xpAwarded === input.xpAwarded && recorded.masteredUnits === input.masteredUnits && recorded.masteredUnitsAbsolute === input.masteredUnitsAbsolute;
+}
 function classifyAssessmentFinalization(attempt, input) {
   if (isAssessmentAttemptCompleted(attempt)) {
-    return attempt.submissionId === input.submissionId && attempt.xpAwarded === input.xpAwarded ? "replay" : "conflict";
+    return attempt.submissionId === input.submissionId && attempt.award !== undefined && isSameAssessmentAward(attempt.award, input) ? "replay" : "conflict";
   }
   if (!isAssessmentAttemptAwaitingAward(attempt) || attempt.submissionId !== input.submissionId) {
     return "reject";
@@ -35894,7 +35900,7 @@ async function reviewBankRevision(input) {
   })}`);
   return `review-bank-v1:${bankRevisionUuid}`;
 }
-async function reviewBankIndex(input) {
+async function buildReviewBankIndexFromReferences(input) {
   return {
     ...input,
     bankRevision: await reviewBankRevision(input)
@@ -35923,7 +35929,7 @@ async function buildReviewBankIndex(assessment, questions, options = {}) {
       standards
     };
   });
-  return reviewBankIndex({
+  return buildReviewBankIndexFromReferences({
     bankIdentifier: assessment.identifier,
     sourceContentRevision: assessment.contentRevision,
     items
@@ -36028,7 +36034,7 @@ async function reviewBankIndexFromManifest(metadata2, input) {
       }
     }
   }
-  const index = await reviewBankIndex({
+  const index = await buildReviewBankIndexFromReferences({
     bankIdentifier,
     sourceContentRevision,
     items: input.membershipItemIdentifiers.map((itemIdentifier) => ({
@@ -36383,6 +36389,18 @@ function isRoutedDiagnosticAttemptMetadata(value, itemSubmissions, responseVersi
 function isReviewAttemptMetadata(value) {
   return isRecord(value) && typeof value.requestFingerprint === "string" && typeof value.bankRevision === "string" && Array.isArray(value.standards) && value.standards.every(isAssessmentStandardRef) && Number.isInteger(value.candidateItemsPerStandard) && Array.isArray(value.selections) && value.selections.every((selection) => isRecord(selection) && isAssessmentStandardRef(selection.standard) && typeof selection.itemIdentifier === "string") && isReviewFulfillment(value.fulfillment);
 }
+function isOptionalInteger(value) {
+  return value === undefined || Number.isInteger(value);
+}
+function isMasteryWriteWarning(value) {
+  return isRecord(value) && value.code === "MASTERY_WRITE_CAPPED" && typeof value.message === "string" && Number.isFinite(value.currentMasteredUnits) && Number.isFinite(value.attemptedMasteredUnits) && Number.isFinite(value.appliedMasteredUnits) && Number.isFinite(value.storedMasteredUnits) && Number.isFinite(value.masterableUnits);
+}
+function isAssessmentAwardRecord(value) {
+  if (value === undefined) {
+    return true;
+  }
+  return isRecord(value) && typeof value.xpAwarded === "number" && Number.isFinite(value.xpAwarded) && value.xpAwarded >= 0 && (value.masteredUnits === undefined || Number.isFinite(value.masteredUnits)) && isOptionalInteger(value.masteredUnitsAbsolute) && Number.isFinite(value.masteredUnitsApplied) && isOptionalInteger(value.pctCompleteApp) && (value.warnings === undefined || Array.isArray(value.warnings) && value.warnings.every(isMasteryWriteWarning));
+}
 function isMasteryAttemptMetadata(value) {
   return isRecord(value) && typeof value.requestFingerprint === "string" && isAssessmentStandardRef(value.standard);
 }
@@ -36407,7 +36425,7 @@ function isPlaycademyAssessmentResultMetadataV1(value) {
   const review = metadata2.review;
   const diagnostic = metadata2.diagnostic;
   const routedDiagnostic = metadata2.purpose === "diagnostic" && diagnostic !== undefined && Array.isArray(metadata2.itemSubmissions) && Number.isInteger(metadata2.responseVersion) && isRoutedDiagnosticAttemptMetadata(diagnostic, metadata2.itemSubmissions, metadata2.responseVersion);
-  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && (selectedTest?.assessmentKey === undefined || isNonEmptyString(selectedTest.assessmentKey)) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && Array.isArray(metadata2.itemSubmissions) && metadata2.itemSubmissions.every(isAssessmentItemSubmission) && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.finalizedAt === undefined || typeof metadata2.finalizedAt === "string") && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.purpose === "diagnostic" ? diagnostic === undefined || routedDiagnostic : diagnostic === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && isCompletionMetadata(metadata2.completion, metadata2.purpose, routedDiagnostic);
+  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && (selectedTest?.assessmentKey === undefined || isNonEmptyString(selectedTest.assessmentKey)) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && Array.isArray(metadata2.itemSubmissions) && metadata2.itemSubmissions.every(isAssessmentItemSubmission) && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.finalizedAt === undefined || typeof metadata2.finalizedAt === "string") && isAssessmentAwardRecord(metadata2.award) && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.purpose === "diagnostic" ? diagnostic === undefined || routedDiagnostic : diagnostic === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && isCompletionMetadata(metadata2.completion, metadata2.purpose, routedDiagnostic);
 }
 function isPlaycademyReviewAssessmentItemResultMetadataV1(value) {
   if (!isRecord(value) || !isRecord(value.responses)) {
@@ -36927,7 +36945,12 @@ var init_assessment_runtime2 = __esm(() => {
   });
   FinalizeAssessmentBodySchema = exports_external.object({
     submissionId: exports_external.string().trim().min(1),
-    xpAwarded: exports_external.number().finite().nonnegative()
+    xpAwarded: exports_external.number().finite().nonnegative(),
+    masteredUnits: exports_external.number().finite().optional(),
+    masteredUnitsAbsolute: exports_external.number().finite().int().optional()
+  }).refine((body2) => body2.masteredUnits === undefined || body2.masteredUnitsAbsolute === undefined, {
+    message: "Provide either masteredUnits or masteredUnitsAbsolute, not both",
+    path: ["masteredUnits"]
   });
   StartRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentBodySchema);
   SaveRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SaveAssessmentBodySchema.shape);
@@ -36936,10 +36959,10 @@ var init_assessment_runtime2 = __esm(() => {
     appName: exports_external.string().trim().min(1),
     sensorUrl: exports_external.string().url()
   });
-  FinalizeRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(FinalizeAssessmentBodySchema.shape).extend({
+  FinalizeRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend({
     appName: exports_external.string().trim().min(1),
     sensorUrl: exports_external.string().url()
-  });
+  }).and(FinalizeAssessmentBodySchema);
 });
 var DOMAIN_CODE_BY_STATUS;
 var AssessmentRuntimeError;
@@ -71642,6 +71665,15 @@ function requireMasteryStandard(input, context2) {
     });
   }
 }
+function rejectSystemManagedReview(input, context2) {
+  if (input.purpose === "review") {
+    context2.addIssue({
+      code: "custom",
+      path: ["purpose"],
+      message: "The review bank is system-managed and cannot be managed manually"
+    });
+  }
+}
 var TimebackGradeSchema;
 var TimebackSubjectSchema;
 var CourseGoalsSchema;
@@ -71946,7 +71978,10 @@ var init_schemas4 = __esm(() => {
     title: exports_external.string().min(1, "Assessment title is required"),
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional()
-  }).superRefine(requireMasteryStandard);
+  }).superRefine((input, context2) => {
+    requireMasteryStandard(input, context2);
+    rejectSystemManagedReview(input, context2);
+  });
   UpdateAssessmentRequestSchema = exports_external.object({
     title: exports_external.string().trim().min(1, "Assessment title is required").optional(),
     purpose: AssessmentPurposeSchema.optional(),
@@ -71955,13 +71990,16 @@ var init_schemas4 = __esm(() => {
     status: AssessmentStatusSchema.optional()
   }).refine((input) => input.title !== undefined || input.purpose !== undefined || input.standard !== undefined || input.diagnostic !== undefined || input.status !== undefined, {
     message: "Title, purpose, standard, diagnostic, or status is required"
-  });
+  }).superRefine(rejectSystemManagedReview);
   CopyAssessmentRequestSchema = exports_external.object({
     assessmentKey: AssessmentKeySchema,
     testIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional()
-  }).superRefine(requireMasteryStandard);
+  }).superRefine((input, context2) => {
+    requireMasteryStandard(input, context2);
+    rejectSystemManagedReview(input, context2);
+  });
   AssessmentAssociationImportEntrySchema = exports_external.object({
     assessmentKey: AssessmentKeySchema,
     qtiTestIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
@@ -71970,6 +72008,7 @@ var init_schemas4 = __esm(() => {
     sortOrder: exports_external.number().int().nonnegative().nullable()
   }).superRefine((input, context2) => {
     requireMasteryStandard(input, context2);
+    rejectSystemManagedReview(input, context2);
     if (input.purpose !== "mastery" && input.standard !== undefined) {
       context2.addIssue({
         code: "custom",
@@ -72019,7 +72058,7 @@ var init_schemas4 = __esm(() => {
   ReorderAssessmentsRequestSchema = exports_external.object({
     purpose: AssessmentPurposeSchema,
     testIdentifiers: exports_external.array(exports_external.string().trim().min(1, "Assessment identifier is required")).min(1, "At least one assessment is required")
-  });
+  }).superRefine(rejectSystemManagedReview);
   ReorderQuestionsRequestSchema = exports_external.object({
     items: exports_external.array(exports_external.object({
       identifier: exports_external.string().min(1),
@@ -116646,6 +116685,7 @@ function buildAssessmentCompletionEvent(input) {
     totalQuestions: input.totalQuestions,
     correctQuestions: input.correctQuestions,
     xpEarned: input.xpAwarded,
+    ...input.masteredUnits ? { masteredUnits: input.masteredUnits } : {},
     attemptNumber: input.attemptNumber,
     process: false,
     subject: input.subject,
@@ -116654,7 +116694,10 @@ function buildAssessmentCompletionEvent(input) {
     eventId: input.eventId,
     eventTime: input.submittedAt,
     runId: input.attemptId,
-    generatedExtensions: metadata2,
+    generatedExtensions: {
+      ...metadata2,
+      ...input.pctCompleteApp !== undefined ? { pctCompleteApp: input.pctCompleteApp } : {}
+    },
     eventExtensions: {
       playcademy: {
         assessmentPurpose: input.purpose,
@@ -116708,6 +116751,85 @@ function deriveSourcedIds(courseId) {
     componentResource: `${courseId}-cr`
   };
 }
+function hasMasteryAwardRequest(request) {
+  return request.masteredUnits !== undefined || request.masteredUnitsAbsolute !== undefined;
+}
+
+class ActivityMasteryAward {
+  mastery;
+  events;
+  constructor(mastery, events) {
+    this.mastery = mastery;
+    this.events = events;
+  }
+  async evaluate(input) {
+    const ids = deriveSourcedIds(input.courseId);
+    const progress = await this.mastery.checkProgress({
+      studentId: input.studentId,
+      courseId: input.courseId,
+      resourceId: ids.resource,
+      masteredUnits: input.masteredUnits ?? 0,
+      masteredUnitsAbsolute: input.masteredUnitsAbsolute
+    });
+    if (!progress) {
+      return {
+        masteredUnitsApplied: input.masteredUnits ?? 0,
+        masteryAchieved: false,
+        masteryRevoked: false
+      };
+    }
+    return {
+      masteredUnitsApplied: progress.effectiveDelta,
+      pctCompleteApp: progress.pctCompleteApp,
+      masteryAchieved: progress.masteryAchieved,
+      masteryRevoked: progress.masteryRevoked,
+      ...progress.writeWarning ? { warnings: [progress.writeWarning] } : {}
+    };
+  }
+  async settle(evaluation, input) {
+    let completionEntryWritten = false;
+    if (evaluation.masteryAchieved) {
+      setAttributes({ "app.timeback.mastery_achieved": true });
+      completionEntryWritten = await this.mastery.createCompletionEntry(input.studentId, input.courseId, input.classId, input.appName);
+      await this.emitCourseCompletionHistoryEvent(input);
+    }
+    if (evaluation.masteryRevoked) {
+      await this.mastery.revokeCompletionEntry(input.studentId, input.courseId, input.classId, input.appName);
+    }
+    return { completionEntryWritten };
+  }
+  async emitCourseCompletionHistoryEvent(input) {
+    const ids = deriveSourcedIds(input.courseId);
+    await this.events.emitActivityEvent({
+      eventId: input.completionHistoryEventId,
+      studentId: input.studentId,
+      studentEmail: input.studentEmail,
+      gameId: input.gameId,
+      activityId: input.activityId,
+      activityName: "Course completed",
+      courseId: ids.course,
+      courseName: input.courseName,
+      subject: input.subject,
+      appName: input.appName,
+      sensorUrl: input.sensorUrl,
+      process: false,
+      includeAttempt: false,
+      eventExtensions: {
+        playcademy: {
+          eventKind: "course-completed",
+          source: "gameplay"
+        }
+      },
+      generatedExtensions: {
+        playcademy: {
+          eventKind: "course-completed",
+          source: "gameplay",
+          activityId: input.activityId
+        }
+      }
+    }).catch(catchEvent("timeback.caliper_completion_event_failed"));
+  }
+}
 function validateProgressData(progressData) {
   if (!progressData.subject) {
     throw new ConfigurationError("subject", "Subject is required for Caliper events. Provide it in progressData.subject");
@@ -116723,12 +116845,12 @@ function validateProgressData(progressData) {
 class ActivityRecord {
   core;
   students;
-  mastery;
+  masteryAward;
   events;
-  constructor(core3, students, mastery, events) {
+  constructor(core3, students, masteryAward, events) {
     this.core = core3;
     this.students = students;
-    this.mastery = mastery;
+    this.masteryAward = masteryAward;
     this.events = events;
   }
   async record(courseId, studentIdentifier, progressData) {
@@ -116754,52 +116876,32 @@ class ActivityRecord {
       throw error88;
     }
     const legacyLineItemId = `${ids.course}-${activityId}-assessment`;
-    const [currentAttemptNumber, masteryProgress] = await Promise.all([
+    const [currentAttemptNumber, mastery] = await Promise.all([
       this.resolveAttemptNumber(attemptNumber, studentId, caliperLineItemId, legacyLineItemId),
-      this.mastery.checkProgress({
+      this.masteryAward.evaluate({
         studentId,
         courseId,
-        resourceId: ids.resource,
-        masteredUnits: progressData.masteredUnits ?? 0,
+        masteredUnits: progressData.masteredUnits,
         masteredUnitsAbsolute: progressData.masteredUnitsAbsolute
       })
     ]);
     setAttributes({ "app.timeback.attempt_number": currentAttemptNumber });
-    let extensions = progressData.extensions;
-    const effectiveMasteredUnits = masteryProgress ? masteryProgress.effectiveDelta : progressData.masteredUnits ?? 0;
-    let pctCompleteApp;
-    let masteryAchieved = false;
-    let completionEntryWritten = false;
-    const warnings = masteryProgress?.writeWarning ? [masteryProgress.writeWarning] : undefined;
-    if (masteryProgress) {
-      masteryAchieved = masteryProgress.masteryAchieved;
-      pctCompleteApp = masteryProgress.pctCompleteApp;
-      extensions = {
-        ...extensions,
-        ...pctCompleteApp !== undefined ? { pctCompleteApp } : {}
-      };
-    }
-    if (masteryAchieved) {
-      setAttributes({ "app.timeback.mastery_achieved": true });
-    }
-    if (masteryAchieved) {
-      completionEntryWritten = await this.mastery.createCompletionEntry(studentId, courseId, progressData.classId, progressData.appName);
-      await this.emitCourseCompletionHistoryEvent({
-        studentId,
-        studentEmail,
-        gameId: progressData.gameId,
-        activityId,
-        courseId: ids.course,
-        courseName,
-        subject: progressData.subject,
-        appName: progressData.appName,
-        sensorUrl: progressData.sensorUrl,
-        eventId: progressData.completionHistoryEventId
-      });
-    }
-    if (masteryProgress?.masteryRevoked) {
-      await this.mastery.revokeCompletionEntry(studentId, courseId, progressData.classId, progressData.appName);
-    }
+    const effectiveMasteredUnits = mastery.masteredUnitsApplied;
+    const { pctCompleteApp, warnings } = mastery;
+    const extensions = pctCompleteApp !== undefined ? { ...progressData.extensions, pctCompleteApp } : progressData.extensions;
+    const { completionEntryWritten } = await this.masteryAward.settle(mastery, {
+      studentId,
+      studentEmail,
+      courseId,
+      classId: progressData.classId,
+      gameId: progressData.gameId,
+      activityId,
+      courseName,
+      subject: progressData.subject,
+      appName: progressData.appName,
+      sensorUrl: progressData.sensorUrl,
+      completionHistoryEventId: progressData.completionHistoryEventId
+    });
     try {
       await this.events.emitActivityEvent({
         studentId,
@@ -116820,7 +116922,7 @@ class ActivityRecord {
         appName: progressData.appName,
         sensorUrl: progressData.sensorUrl,
         eventId: progressData.eventId,
-        extensions: extensions || progressData.extensions,
+        extensions,
         ...progressData.runId ? { runId: progressData.runId } : {}
       }).catch((error88) => {
         setAttributes({ "app.timeback.caliper_emit_failed": true });
@@ -116841,36 +116943,6 @@ class ActivityRecord {
       ...warnings ? { warnings } : {}
     };
   }
-  async emitCourseCompletionHistoryEvent(data) {
-    await this.events.emitActivityEvent({
-      eventId: data.eventId,
-      studentId: data.studentId,
-      studentEmail: data.studentEmail,
-      gameId: data.gameId,
-      activityId: data.activityId,
-      activityName: "Course completed",
-      courseId: data.courseId,
-      courseName: data.courseName,
-      subject: data.subject,
-      appName: data.appName,
-      sensorUrl: data.sensorUrl,
-      process: false,
-      includeAttempt: false,
-      eventExtensions: {
-        playcademy: {
-          eventKind: "course-completed",
-          source: "gameplay"
-        }
-      },
-      generatedExtensions: {
-        playcademy: {
-          eventKind: "course-completed",
-          source: "gameplay",
-          activityId: data.activityId
-        }
-      }
-    }).catch(catchEvent("timeback.caliper_completion_event_failed"));
-  }
   async resolveAttemptNumber(providedAttemptNumber, studentId, caliperLineItemId, legacyLineItemId) {
     if (providedAttemptNumber) {
       setAttributes({ "app.timeback.attempt_source": "provided" });
@@ -117268,9 +117340,12 @@ class ActivityEvents {
   }
 }
 function createActivityNamespace(core3, deps) {
-  const record3 = new ActivityRecord(core3, deps.students, deps.mastery, deps.events);
+  const masteryAward = new ActivityMasteryAward(deps.mastery, deps.events);
+  const record3 = new ActivityRecord(core3, deps.students, masteryAward, deps.events);
   const session2 = new ActivitySession(deps.students, deps.events);
   return {
+    evaluateMasteryAward: (input) => masteryAward.evaluate(input),
+    settleMasteryAward: (evaluation, input) => masteryAward.settle(evaluation, input),
     record: (courseId, studentIdentifier, progressData) => record3.record(courseId, studentIdentifier, progressData),
     session: (courseId, studentIdentifier, sessionData) => session2.record(courseId, studentIdentifier, sessionData),
     listEvents: (params) => deps.events.listEvents(params),
@@ -118560,6 +118635,7 @@ var StudentNotFoundError;
 var ConfigurationError;
 var UUID_REGEX2;
 var ONEROSTER_PATHS;
+var NO_MASTERY_AWARD;
 var TIMEBACK_API_URLS;
 var QTI_API_URL = "https://qti.alpha-1edtech.ai/api";
 var TIMEBACK_AUTH_URLS;
@@ -118576,6 +118652,7 @@ var GRADE_VALUES3;
 var MASTERY_WRITE_CAPPED_WARNING_CODE = "MASTERY_WRITE_CAPPED";
 var EmailSchema;
 var init_dist5 = __esm(async () => {
+  init_spans();
   init_spans();
   init_src();
   init_spans();
@@ -118636,6 +118713,11 @@ var init_dist5 = __esm(async () => {
     courses: "/ims/oneroster/rostering/v1p2/courses",
     componentResources: "/ims/oneroster/rostering/v1p2/courses/component-resources"
   };
+  NO_MASTERY_AWARD = {
+    masteredUnitsApplied: 0,
+    masteryAchieved: false,
+    masteryRevoked: false
+  };
   TIMEBACK_API_URLS = {
     production: "https://api.alpha-1edtech.ai",
     staging: "https://api.staging.alpha-1edtech.com"
@@ -121390,6 +121472,62 @@ function stringField2(value) {
 function firstStringField2(...values) {
   return values.map(stringField2).find(Boolean) ?? "";
 }
+function normalizedWhitespace2(value) {
+  return value.normalize("NFKC").trim().replace(/\s+/g, " ");
+}
+function normalizedIdentityCase2(value) {
+  return value.toLocaleUpperCase("en-US");
+}
+function frameworkAliasKey2(value) {
+  return value.normalize("NFKC").toLocaleLowerCase("en-US").replace(/[^a-z0-9]+/g, "");
+}
+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);
+}
+function isCommonCoreElaIdentifier2(identifier) {
+  const canonical = normalizedIdentityCase2(normalizedWhitespace2(identifier));
+  return canonical.startsWith("CCSS.ELA-LITERACY.") || /^(?:RL|RI|RF|W|SL|L)\.(?:K|[1-9]|1[0-2])\./.test(canonical) || /^(?:RH|RST|WHST)\.(?:6-8|9-10|11-12)\./.test(canonical) || /^CCRA\.(?:R|W|SL|L)\./.test(canonical);
+}
+function canonicalFramework2(authoredFramework, identifier) {
+  const aliasKey = frameworkAliasKey2(authoredFramework);
+  if (COMMON_CORE_MATH_FRAMEWORK_ALIASES2.has(aliasKey) || COMMON_CORE_FRAMEWORK_ALIASES2.has(aliasKey) && isCommonCoreMathIdentifier2(identifier)) {
+    return "CCSS.Math";
+  }
+  if (COMMON_CORE_ELA_FRAMEWORK_ALIASES2.has(aliasKey) || COMMON_CORE_FRAMEWORK_ALIASES2.has(aliasKey) && isCommonCoreElaIdentifier2(identifier)) {
+    return "CCSS.ELA-Literacy";
+  }
+  if (COMMON_CORE_FRAMEWORK_ALIASES2.has(aliasKey)) {
+    return "CCSS";
+  }
+  return normalizedIdentityCase2(authoredFramework);
+}
+function canonicalIdentifier2(framework, authoredIdentifier) {
+  const identifier = normalizedIdentityCase2(normalizedWhitespace2(authoredIdentifier));
+  if (framework === "CCSS.Math") {
+    return identifier.replace(/^CCSS\.MATH\.CONTENT\./, "").replace(/^CCSS\.MATH\.PRACTICE\./, "").replace(/^CCSS\.MATH\./, "");
+  }
+  if (framework === "CCSS.ELA-Literacy") {
+    return identifier.replace(/^CCSS\.ELA-LITERACY\./, "");
+  }
+  return identifier;
+}
+function canonicalAssessmentStandardRef2(standard) {
+  const authoredFramework = normalizedWhitespace2(standard.framework);
+  const framework = canonicalFramework2(authoredFramework, standard.identifier);
+  const identifier = canonicalIdentifier2(framework, standard.identifier);
+  return {
+    framework,
+    identifier
+  };
+}
+function assessmentStandardRefKey2(standard) {
+  const canonical = canonicalAssessmentStandardRef2(standard);
+  return JSON.stringify([
+    normalizedIdentityCase2(canonical.framework),
+    normalizedIdentityCase2(canonical.identifier)
+  ]);
+}
 function dedupeStandards2(standards) {
   const deduped = new Map;
   for (const standard of standards) {
@@ -124161,6 +124299,22 @@ var init_locks = __esm(() => {
     }
   };
 });
+async function crossAssessmentAttemptLockBarrier(lock, db2, attemptId) {
+  const maxAttempts = 5;
+  for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+    try {
+      await lock(db2, [assessmentRuntimeAttemptLockKey(attemptId)], async () => {
+        return;
+      });
+      return;
+    } catch (error88) {
+      if (!(error88 instanceof ServiceUnavailableError) || attempt === maxAttempts) {
+        throw error88;
+      }
+      await sleep(25);
+    }
+  }
+}
 function normalizeKeys(keys) {
   return [...new Set(keys)].toSorted();
 }
@@ -125176,6 +125330,97 @@ var init_timeback_qti_authoring_util = __esm(() => {
     buildMatchQuestionXml
   ];
 });
+function assessmentPreparationContentionError(expectedResponseVersion, responseVersion, kind) {
+  if (expectedResponseVersion === responseVersion) {
+    return new ServiceUnavailableError(`The ${kind} response state changed repeatedly while this item was being prepared. Try again shortly.`, {
+      retryable: true,
+      reason: "PREPARATION_CONTENTION",
+      expectedResponseVersion,
+      responseVersion
+    });
+  }
+  return AssessmentRuntimeError.from(assessmentResponseVersionConflict(expectedResponseVersion, responseVersion));
+}
+function assessmentTrackableCourse(integration) {
+  if (!isTimebackGrade2(integration.grade) || !isTimebackSubject(integration.subject)) {
+    return null;
+  }
+  return { grade: integration.grade, subject: integration.subject };
+}
+function buildAssessmentActivityData(input) {
+  if (!input.course) {
+    return;
+  }
+  return {
+    activityId: input.activityId,
+    activityName: input.activityName,
+    ...input.course,
+    courseId: input.courseId
+  };
+}
+function buildDiagnosticAssessmentSnapshot(input) {
+  return {
+    attemptId: input.attemptId,
+    responseVersion: input.metadata.responseVersion,
+    status: "in_progress",
+    flow: "platform-routed-item-submit",
+    ...input.activityData ? { activityData: input.activityData } : {},
+    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
+    selection: {
+      kind: "platform-routed-diagnostic",
+      purpose: "diagnostic",
+      definitionId: input.metadata.diagnostic.definitionId,
+      diagnosticKey: input.metadata.diagnostic.diagnosticKey,
+      routingRevision: input.metadata.diagnostic.routingRevision
+    },
+    routing: projectDiagnosticRoutingSnapshot(input.metadata.diagnostic.routingRevision, input.state),
+    completion: null
+  };
+}
+function buildConventionalAssessmentSnapshot(input) {
+  const metadata2 = input.metadata;
+  let selection;
+  if (metadata2.purpose === "review") {
+    selection = {
+      kind: "standards-review",
+      purpose: metadata2.purpose,
+      standards: [...metadata2.review.standards],
+      candidateItemsPerStandard: metadata2.review.candidateItemsPerStandard,
+      selections: [...metadata2.review.selections],
+      fulfillment: metadata2.review.fulfillment
+    };
+  } else if (metadata2.purpose === "mastery") {
+    selection = {
+      kind: "standard-quiz",
+      purpose: metadata2.purpose,
+      standard: metadata2.mastery.standard
+    };
+  } else {
+    selection = { kind: "fixed-test", purpose: metadata2.purpose };
+  }
+  return {
+    attemptId: input.attemptId,
+    responseVersion: metadata2.responseVersion,
+    status: "in_progress",
+    flow: assessmentFlowForPurpose(metadata2.purpose),
+    ...input.activityData ? { activityData: input.activityData } : {},
+    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
+    responses: metadata2.responses,
+    itemSubmissions: metadata2.itemSubmissions,
+    score: null,
+    selection
+  };
+}
+function buildAssessmentAwardRecord(input, mastery) {
+  return {
+    xpAwarded: input.xpAwarded,
+    ...input.masteredUnits !== undefined ? { masteredUnits: input.masteredUnits } : {},
+    ...input.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: input.masteredUnitsAbsolute } : {},
+    masteredUnitsApplied: mastery.masteredUnitsApplied,
+    ...mastery.pctCompleteApp !== undefined ? { pctCompleteApp: mastery.pctCompleteApp } : {},
+    ...mastery.warnings ? { warnings: mastery.warnings } : {}
+  };
+}
 function stageAssessmentAttemptSupersession(attempt) {
   Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
   Object.assign(attempt.selection, ASSESSMENT_ATTEMPT_SUPERSEDED);
@@ -125386,13 +125631,35 @@ function buildAssessmentSubmitResult(input) {
   }
   return { ...base, purpose: input.metadata.purpose };
 }
+function assessmentAwardFromResult(result, metadata2) {
+  if (metadata2.award) {
+    return metadata2.award;
+  }
+  const xp = result.metadata?.xp;
+  return typeof xp === "number" && Number.isFinite(xp) && xp >= 0 ? { xpAwarded: xp, masteredUnitsApplied: 0 } : null;
+}
 function buildCompletedAssessmentSubmitResult(input) {
-  const submitted = buildAssessmentSubmitResult(input);
-  return submitted ? {
+  const attemptId = input.result.sourcedId;
+  const award = assessmentAwardFromResult(input.result, input.metadata);
+  if (award === null) {
+    throw new GoneError("This completed assessment is missing its recorded XP.", {
+      attemptId
+    });
+  }
+  const submitted = buildAssessmentSubmitResult({ attemptId, metadata: input.metadata });
+  if (!submitted) {
+    throw new GoneError("This completed assessment has incomplete persisted results.", {
+      attemptId
+    });
+  }
+  return {
     ...submitted,
     status: "completed",
-    xpAwarded: input.xpAwarded
-  } : null;
+    xpAwarded: award.xpAwarded,
+    masteredUnitsApplied: award.masteredUnitsApplied,
+    ...award.pctCompleteApp !== undefined ? { pctCompleteApp: award.pctCompleteApp } : {},
+    ...award.warnings ? { warnings: award.warnings } : {}
+  };
 }
 function assessmentAttemptId(input) {
   return deterministicUUID([
@@ -125719,6 +125986,22 @@ function assessmentFixtureScoringKeys(assessment, questions) {
     ...Object.keys(responseAreas).length > 0 ? { responseAreas } : {}
   };
 }
+function prepareDiagnosticAssessmentResponses(assessment, current, input) {
+  const update2 = { [input.itemIdentifier]: input.responses };
+  validateAssessmentResponseUpdate(assessment, update2);
+  const responses = applyAssessmentResponseUpdate(current, update2);
+  const item = assessment.items.find((candidate) => candidate.identifier === input.itemIdentifier);
+  const itemResponses = responses[input.itemIdentifier];
+  const missingResponse = item?.interactions.find((interaction) => itemResponses?.[interaction.responseIdentifier] === undefined);
+  if (!item || !itemResponses || missingResponse) {
+    throw new AssessmentRuntimeError("INVALID_RESPONSE", `Diagnostic item ${input.itemIdentifier} requires a response for every interaction.`, {
+      itemIdentifier: input.itemIdentifier,
+      ...missingResponse ? { responseIdentifier: missingResponse.responseIdentifier } : {}
+    });
+  }
+  validateAssessmentResponses(assessment, { [input.itemIdentifier]: itemResponses });
+  return responses;
+}
 function validateAssessmentResponseUpdate(assessment, update2) {
   const message = assessmentResponseUpdateValidationMessage(assessment, update2);
   if (message) {
@@ -125805,7 +126088,7 @@ function buildAssessmentResultSubmission(input) {
     }
   };
 }
-function buildAssessmentResultXpFinalization(input) {
+function buildAssessmentResultAwardFinalization(input) {
   const completion = input.metadata.completion;
   if (!completion || completion.totalQuestions === undefined) {
     throw new Error("A scored assessment must retain its completion facts before finalization");
@@ -125813,8 +126096,10 @@ function buildAssessmentResultXpFinalization(input) {
   const metadata2 = {
     ...input.metadata,
     finalizedAt: input.timestamp,
-    updatedAt: input.timestamp
+    updatedAt: input.timestamp,
+    award: input.award
   };
+  const masteryRequested = input.award.masteredUnits !== undefined || input.award.masteredUnitsAbsolute !== undefined;
   return {
     metadata: metadata2,
     resultUpdate: {
@@ -125826,7 +126111,8 @@ function buildAssessmentResultXpFinalization(input) {
       ...ASSESSMENT_ATTEMPT_COMPLETED,
       metadata: {
         ...mergeAssessmentRuntimeMetadata(input.result.metadata, metadata2),
-        xp: input.xpAwarded,
+        xp: input.award.xpAwarded,
+        ...masteryRequested ? { masteredUnits: input.award.masteredUnitsApplied } : {},
         totalQuestions: completion.totalQuestions,
         correctQuestions: completion.correctQuestions,
         appName: input.appName
@@ -125839,12 +126125,217 @@ var init_timeback_assessment_runtime_util = __esm(() => {
   init_src();
   init_assessment_runtime2();
   init_qti();
+  init_types2();
   init_utils6();
   init_timeback4();
   init_uuid();
   init_errors2();
   PLAYABLE_SHAPE_SET = new Set(PLAYABLE_ASSESSMENT_SHAPES);
 });
+function reviewBankTestItemIdentifiers(test) {
+  return qtiTestParts(test).flatMap((part) => part["qti-assessment-section"].flatMap((section) => (section["qti-assessment-item-ref"] ?? []).map((reference) => reference.identifier)));
+}
+function canonicalSyncContributors(contributors) {
+  return contributors.map((contributor) => {
+    const canonical = canonicalContributorIdentity(contributor);
+    return {
+      ...contributor,
+      ...canonical
+    };
+  }).toSorted((left, right) => compareCodeUnits(left.standardKey, right.standardKey) || compareCodeUnits(left.qtiTestIdentifier, right.qtiTestIdentifier) || compareCodeUnits(left.assessmentKey, right.assessmentKey));
+}
+function canonicalContributorIdentity(contributor) {
+  const standard = canonicalReviewStandardRef(contributor.standard);
+  if (!standard) {
+    throw new ValidationError(`Mastery assessment ${contributor.qtiTestIdentifier} has an invalid standard`);
+  }
+  return {
+    qtiTestIdentifier: contributor.qtiTestIdentifier,
+    standard,
+    standardKey: assessmentStandardRefKey2(standard)
+  };
+}
+async function reviewBankContributorFingerprint(contributors) {
+  const uniqueTuples = new Map;
+  for (const contributor of contributors) {
+    const { qtiTestIdentifier, standardKey } = canonicalContributorIdentity(contributor);
+    const tuple3 = { qtiTestIdentifier, standardKey };
+    uniqueTuples.set(canonicalJson2(tuple3), tuple3);
+  }
+  const digest = await sha256Hex(canonicalJson2([...uniqueTuples.values()].toSorted((left, right) => compareCodeUnits(left.standardKey, right.standardKey) || compareCodeUnits(left.qtiTestIdentifier, right.qtiTestIdentifier))));
+  return `review-bank-contributors-v1:${digest}`;
+}
+function conflictWarning(input) {
+  const retained = `${input.retainedStandard.framework} · ${input.retainedStandard.identifier}`;
+  const skipped = `${input.skippedStandard.framework} · ${input.skippedStandard.identifier}`;
+  return {
+    code: "QUESTION_STANDARD_CONFLICT",
+    ...input,
+    message: `Question ${input.itemIdentifier} is referenced by multiple mastery standards; retained ${retained} and skipped ${skipped} from ${input.skippedQtiTestIdentifier}.`
+  };
+}
+async function prepareReviewBankSynchronization(input) {
+  const contributors = canonicalSyncContributors(input.contributors);
+  const selectedByItem = new Map;
+  const warningKeys = new Set;
+  const warnings = [];
+  for (const contributor of contributors) {
+    const itemIdentifiers2 = [
+      ...new Set(reviewBankTestItemIdentifiers(contributor.test))
+    ].toSorted();
+    for (const itemIdentifier of itemIdentifiers2) {
+      const selected = selectedByItem.get(itemIdentifier);
+      if (!selected) {
+        selectedByItem.set(itemIdentifier, {
+          standard: contributor.standard,
+          standardKey: contributor.standardKey
+        });
+      } else if (selected.standardKey !== contributor.standardKey) {
+        const warningKey = `${itemIdentifier}\x00${contributor.standardKey}`;
+        if (!warningKeys.has(warningKey)) {
+          warningKeys.add(warningKey);
+          warnings.push(conflictWarning({
+            itemIdentifier,
+            retainedStandard: selected.standard,
+            skippedStandard: contributor.standard,
+            skippedQtiTestIdentifier: contributor.qtiTestIdentifier
+          }));
+        }
+      }
+    }
+  }
+  const itemIdentifiers = [...selectedByItem.keys()].toSorted();
+  const sourceContentRevision = input.contributorFingerprint ?? await reviewBankContributorFingerprint(contributors);
+  const bank = await buildReviewBankIndexFromReferences({
+    bankIdentifier: input.bankIdentifier,
+    sourceContentRevision,
+    items: itemIdentifiers.map((itemIdentifier) => ({
+      itemIdentifier,
+      standards: [selectedByItem.get(itemIdentifier).standard]
+    }))
+  });
+  const manifest = await buildReviewBankManifest(bank);
+  return {
+    bankIdentifier: input.bankIdentifier,
+    contributorFingerprint: sourceContentRevision,
+    itemIdentifiers,
+    manifest,
+    warnings,
+    summary: {
+      itemCount: itemIdentifiers.length,
+      standardCount: Object.keys(manifest.itemsByStandard).length,
+      contributorCount: contributors.length,
+      sourceFingerprint: manifest.sourceFingerprint
+    }
+  };
+}
+function reviewBankSinkMetadata(integrationId, plan) {
+  return {
+    ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+    integrationId,
+    [PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY]: {
+      version: PLAYCADEMY_REVIEW_BANK_SINK_VERSION,
+      integrationId,
+      contributorFingerprint: plan.contributorFingerprint,
+      warnings: plan.warnings
+    },
+    [PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY]: plan.manifest
+  };
+}
+function reviewBankSinkMarker(test) {
+  const parsed = ReviewBankSinkMarkerSchema.safeParse(test.metadata?.[PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY]);
+  return parsed.success ? parsed.data : null;
+}
+function reviewBankSinkState(test, integrationId) {
+  assertReviewBankSinkOwnership(test, integrationId);
+  const marker = reviewBankSinkMarker(test);
+  return {
+    contributorFingerprint: marker?.contributorFingerprint ?? null,
+    warnings: marker?.warnings ?? []
+  };
+}
+async function unchangedReviewBankSynchronizationResult(input) {
+  const sinkState = reviewBankSinkState(input.sink, input.integrationId);
+  if (sinkState.contributorFingerprint !== input.contributorFingerprint) {
+    return null;
+  }
+  const membershipItemIdentifiers = reviewBankTestItemIdentifiers(input.sink);
+  const bank = await reviewBankIndexFromManifest(input.sink.metadata, {
+    bankIdentifier: input.sink.identifier,
+    membershipItemIdentifiers
+  });
+  const manifest = input.sink.metadata?.[PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY];
+  if (!bank || typeof manifest?.sourceFingerprint !== "string") {
+    return null;
+  }
+  const standardCount = new Set(bank.items.flatMap((item) => item.standards.map(assessmentStandardRefKey2))).size;
+  return {
+    qtiTestIdentifier: input.sink.identifier,
+    itemCount: bank.items.length,
+    standardCount,
+    contributorCount: input.contributorCount,
+    sourceFingerprint: manifest.sourceFingerprint,
+    addedItemCount: 0,
+    removedItemCount: 0,
+    unchanged: true,
+    warnings: sinkState.warnings
+  };
+}
+function reviewBankSynchronizationDiff(input) {
+  let previousMembershipReadable = true;
+  let previousItemIdentifiers = [];
+  if (input.existingSink) {
+    try {
+      previousItemIdentifiers = reviewBankTestItemIdentifiers(input.existingSink);
+    } catch {
+      previousMembershipReadable = false;
+    }
+  }
+  const previousItems = new Set(previousItemIdentifiers);
+  const desiredItems = new Set(input.plan.itemIdentifiers);
+  const addedItemCount = input.plan.itemIdentifiers.filter((identifier) => !previousItems.has(identifier)).length;
+  const removedItemCount = [...previousItems].filter((identifier) => !desiredItems.has(identifier)).length;
+  const currentManifest = input.existingSink?.metadata?.[PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY];
+  const currentContributorFingerprint = input.existingSink ? reviewBankSinkMarker(input.existingSink)?.contributorFingerprint ?? null : null;
+  const canonicalMembership = previousItemIdentifiers.length === input.plan.itemIdentifiers.length && previousItemIdentifiers.every((identifier, index2) => identifier === input.plan.itemIdentifiers[index2]);
+  const unchanged = input.existingSink !== null && previousMembershipReadable && canonicalMembership && canonicalJson2(currentManifest) === canonicalJson2(input.plan.manifest) && currentContributorFingerprint === input.plan.contributorFingerprint;
+  return { addedItemCount, removedItemCount, unchanged };
+}
+function assertReviewBankSinkOwnership(test, integrationId) {
+  const marker = reviewBankSinkMarker(test);
+  if (marker?.integrationId !== integrationId || test.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM || test.identifier !== reviewBankSinkIdentifier(integrationId)) {
+    throw new ValidationError(`QTI assessment ${test.identifier} is not the review-bank sink for this integration`);
+  }
+}
+function buildReviewBankSinkInput(input) {
+  return {
+    ...input.includeIdentifier ? { identifier: input.identifier } : {},
+    title: input.title,
+    metadata: input.metadata,
+    "qti-test-part": [
+      {
+        identifier: `${input.identifier}-part1`,
+        navigationMode: "linear",
+        submissionMode: "individual",
+        "qti-assessment-section": [
+          {
+            identifier: `${input.identifier}-section1`,
+            title: "Questions",
+            visible: true,
+            required: true,
+            fixed: false,
+            sequence: 1,
+            "qti-assessment-item-ref": input.itemIdentifiers.map((itemIdentifier, index2) => ({
+              identifier: itemIdentifier,
+              href: input.itemHref(itemIdentifier),
+              sequence: index2 + 1
+            }))
+          }
+        ]
+      }
+    ]
+  };
+}
 function reviewMappingIssueSummary(label, identifiers) {
   if (identifiers.length === 0) {
     return null;
@@ -125893,11 +126384,50 @@ async function prepareReviewMappingUpdate(test, questions) {
     }
   };
 }
+var PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink";
+var PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1;
+var StoredSinkWarningSchema;
+var ReviewBankSinkMarkerSchema;
 var init_timeback_review_mapping_util = __esm(() => {
+  init_esm();
   init_assessment_runtime2();
+  init_qti();
+  init_timeback3();
   init_errors2();
   init_timeback_assessment_runtime_util();
   init_timeback_qti_authoring_util();
+  StoredSinkWarningSchema = exports_external.object({
+    code: exports_external.literal("QUESTION_STANDARD_CONFLICT"),
+    itemIdentifier: exports_external.string(),
+    retainedStandard: exports_external.object({ framework: exports_external.string(), identifier: exports_external.string() }),
+    skippedStandard: exports_external.object({ framework: exports_external.string(), identifier: exports_external.string() }),
+    skippedQtiTestIdentifier: exports_external.string()
+  });
+  ReviewBankSinkMarkerSchema = exports_external.object({
+    version: exports_external.literal(PLAYCADEMY_REVIEW_BANK_SINK_VERSION),
+    integrationId: exports_external.string(),
+    contributorFingerprint: exports_external.string().nullable().catch(null),
+    warnings: exports_external.array(StoredSinkWarningSchema).nullable().catch(null)
+  }).transform((marker) => {
+    if (!marker.contributorFingerprint || !marker.warnings) {
+      return { ...marker, contributorFingerprint: null, warnings: [] };
+    }
+    const warnings = [];
+    for (const warning of marker.warnings) {
+      const retained = canonicalReviewStandardRef(warning.retainedStandard);
+      const skipped = canonicalReviewStandardRef(warning.skippedStandard);
+      if (!retained || !skipped) {
+        return { ...marker, contributorFingerprint: null, warnings: [] };
+      }
+      warnings.push(conflictWarning({
+        itemIdentifier: warning.itemIdentifier,
+        retainedStandard: retained,
+        skippedStandard: skipped,
+        skippedQtiTestIdentifier: warning.skippedQtiTestIdentifier
+      }));
+    }
+    return { ...marker, warnings };
+  });
 });
 function assessmentKeyFromManagedQtiIdentifier(identifier) {
   const assessmentKey = /^playcademy-test\.(.+)\.[a-f0-9]{64}$/.exec(identifier)?.[1];
@@ -126201,11 +126731,6 @@ function assertAssessmentHasQuestions(questions) {
     throw new ValidationError("An assessment must contain at least one question to publish");
   }
 }
-function assertReviewAssessmentHasStandards(standardCounts) {
-  if (standardCounts.some((count) => count !== 1)) {
-    throw new ValidationError("Every question in a review assessment must have exactly one standards alignment");
-  }
-}
 function planAssessmentRemoval(status) {
   if (status === "draft") {
     return { kind: "delete", action: "discarded", operation: "discard_draft" };
@@ -126266,6 +126791,9 @@ function orderLiveAssessmentRows(liveRows, purpose, testIdentifiers) {
 var init_timeback_assessment_rules_util = __esm(() => {
   init_errors2();
 });
+function qtiItemHref(client2, itemIdentifier) {
+  return `${client2.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
+}
 async function hydrateQtiTestQuestions(client2, references) {
   const questions = await runWithConcurrency(references.questions, QTI_HYDRATION_CONCURRENCY, async (reference) => ({
     ...reference,
@@ -126288,6 +126816,28 @@ async function hydrateQtiTestQuestionSelection(client2, references, itemIdentifi
     questions: selectedReferences
   });
 }
+async function hydrateQtiItemSelection(client2, test, itemIdentifiers) {
+  const testPart = qtiTestParts(test)[0];
+  const section = testPart?.["qti-assessment-section"][0];
+  if (!testPart || !section) {
+    throw new Error(`QTI assessment ${test.identifier} has no section to reference items from`);
+  }
+  const questions = await runWithConcurrency(itemIdentifiers, QTI_HYDRATION_CONCURRENCY, async (itemIdentifier) => ({
+    reference: {
+      identifier: itemIdentifier,
+      href: qtiItemHref(client2, itemIdentifier),
+      testPart: testPart.identifier,
+      section: section.identifier
+    },
+    question: await client2.qtiApi.assessmentItems.get(itemIdentifier)
+  }));
+  return {
+    assessmentTest: test.identifier,
+    title: test.title,
+    totalQuestions: questions.length,
+    questions
+  };
+}
 async function loadQtiTestReferences(client2, identifier) {
   const [test, references] = await Promise.all([
     client2.qtiApi.assessmentTests.get(identifier),
@@ -126303,7 +126853,9 @@ async function loadHydratedQtiTest(client2, identifier) {
   };
 }
 var QTI_HYDRATION_CONCURRENCY = 8;
-var init_timeback_qti_hydration_util = () => {};
+var init_timeback_qti_hydration_util = __esm(() => {
+  init_timeback_qti_authoring_util();
+});
 var TimebackAssessmentRuntimeService;
 var init_timeback_assessment_runtime_service = __esm(async () => {
   init_drizzle_orm();
@@ -126331,8 +126883,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     static EXPORT_CONCURRENCY = 4;
     static ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS = 3;
     static ASSESSMENT_VERSION_CONFIRMATION_DELAY_MS = 25;
-    static PROJECTION_BARRIER_MAX_ATTEMPTS = 5;
-    static PROJECTION_BARRIER_RETRY_DELAY_MS = 25;
     static SCORING_CONCURRENCY = 4;
     static STALE_AWARD_AGE_MS = 900000;
     deps;
@@ -126875,15 +127425,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.assertInProgress(attempt.result);
           if (!preview || preview.responseVersion !== attempt.metadata.responseVersion || preview.submissionId !== input.submissionId || preview.itemIdentifier !== input.itemIdentifier) {
             if (preparationAttempts >= TimebackAssessmentRuntimeService2.ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS) {
-              if (input.expectedResponseVersion === attempt.metadata.responseVersion) {
-                throw new ServiceUnavailableError("The assessment response state changed repeatedly while this item was being prepared. Try again shortly.", {
-                  retryable: true,
-                  reason: "PREPARATION_CONTENTION",
-                  expectedResponseVersion: input.expectedResponseVersion,
-                  responseVersion: attempt.metadata.responseVersion
-                });
-              }
-              throw AssessmentRuntimeError.from(assessmentResponseVersionConflict(input.expectedResponseVersion, attempt.metadata.responseVersion));
+              throw assessmentPreparationContentionError(input.expectedResponseVersion, attempt.metadata.responseVersion, "assessment");
             }
             return { action: "prepare" };
           }
@@ -127006,15 +127548,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.assertInProgress(attempt.result);
           if (!preview || preview.responseVersion !== metadata2.responseVersion || preview.submissionId !== input.submissionId || preview.routingNodeKey !== input.routingNodeKey || preview.itemIdentifier !== input.itemIdentifier) {
             if (preparationAttempts >= TimebackAssessmentRuntimeService2.ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS) {
-              if (input.expectedResponseVersion === metadata2.responseVersion) {
-                throw new ServiceUnavailableError("The diagnostic response state changed repeatedly while this item was being prepared. Try again shortly.", {
-                  retryable: true,
-                  reason: "PREPARATION_CONTENTION",
-                  expectedResponseVersion: input.expectedResponseVersion,
-                  responseVersion: metadata2.responseVersion
-                });
-              }
-              throw AssessmentRuntimeError.from(assessmentResponseVersionConflict(input.expectedResponseVersion, metadata2.responseVersion));
+              throw assessmentPreparationContentionError(input.expectedResponseVersion, metadata2.responseVersion, "diagnostic");
             }
             return { action: "prepare" };
           }
@@ -127029,7 +127563,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               itemIdentifier: input.itemIdentifier
             }));
           }
-          const responses = this.prepareDiagnosticResponses(preview.assessment, metadata2.responses, input);
+          const responses = prepareDiagnosticAssessmentResponses(preview.assessment, metadata2.responses, input);
           const scoring = preview.scoring;
           if (!scoring || typeof scoring.isCorrect !== "boolean") {
             throw AssessmentRuntimeError.from(assessmentFlowViolation(`Diagnostic item ${input.itemIdentifier} did not produce determinate binary grading.`, { itemIdentifier: input.itemIdentifier }));
@@ -127102,22 +127636,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         answered: submission.answered
       };
     }
-    prepareDiagnosticResponses(assessment, current, input) {
-      const update2 = { [input.itemIdentifier]: input.responses };
-      validateAssessmentResponseUpdate(assessment, update2);
-      const responses = applyAssessmentResponseUpdate(current, update2);
-      const item = assessment.items.find((candidate) => candidate.identifier === input.itemIdentifier);
-      const itemResponses = responses[input.itemIdentifier];
-      const missingResponse = item?.interactions.find((interaction) => itemResponses?.[interaction.responseIdentifier] === undefined);
-      if (!item || !itemResponses || missingResponse) {
-        throw new AssessmentRuntimeError("INVALID_RESPONSE", `Diagnostic item ${input.itemIdentifier} requires a response for every interaction.`, {
-          itemIdentifier: input.itemIdentifier,
-          ...missingResponse ? { responseIdentifier: missingResponse.responseIdentifier } : {}
-        });
-      }
-      validateAssessmentResponses(assessment, { [input.itemIdentifier]: itemResponses });
-      return responses;
-    }
     async prepareDiagnosticItemSubmission(params, input) {
       try {
         return await this.scoreDiagnosticItemSubmission(params, input);
@@ -127151,7 +127669,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const expected = loaded.state.next;
       let scoring = null;
       if (loaded.state.status === "in-progress" && expected?.nodeKey === input.routingNodeKey && expected.itemIdentifier === input.itemIdentifier && attempt.metadata.responseVersion === input.expectedResponseVersion) {
-        const responses = this.prepareDiagnosticResponses(assessment, attempt.metadata.responses, input);
+        const responses = prepareDiagnosticAssessmentResponses(assessment, attempt.metadata.responses, input);
         scoring = await this.scoreItem(assessment, responses, input.itemIdentifier);
       }
       return {
@@ -127422,11 +127940,14 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           inProgress: attempt.result.inProgress ?? "",
           scoreStatus: attempt.result.scoreStatus,
           submissionId: attempt.metadata.submissionId,
-          xpAwarded: this.xpFromResult(attempt.result) ?? undefined
+          award: assessmentAwardFromResult(attempt.result, attempt.metadata) ?? undefined
         }, input);
         if (disposition === "replay") {
           return {
-            response: this.completedResult(attempt.result, attempt.metadata),
+            response: buildCompletedAssessmentSubmitResult({
+              result: attempt.result,
+              metadata: attempt.metadata
+            }),
             completion: this.replayCompletion(attempt, input.submissionId, params, game2)
           };
         }
@@ -127434,20 +127955,27 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           throw AssessmentRuntimeError.from(assessmentAwardConflict({
             attemptId: attempt.result.sourcedId,
             submissionId: input.submissionId,
-            xpAwarded: input.xpAwarded
+            xpAwarded: input.xpAwarded,
+            ...input.masteredUnits !== undefined ? { masteredUnits: input.masteredUnits } : {},
+            ...input.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: input.masteredUnitsAbsolute } : {}
           }));
         }
         if (disposition === "reject") {
           throw AssessmentRuntimeError.from(assessmentAlreadySubmitted(attempt.result.sourcedId));
         }
-        const submitted = this.submittedResult(attempt.result, attempt.metadata);
-        const finalization = buildAssessmentResultXpFinalization({
+        const mastery = await this.evaluateMasteryAward(attempt, params.studentId, input);
+        const awardRecord = buildAssessmentAwardRecord(input, mastery);
+        const finalization = buildAssessmentResultAwardFinalization({
           result: attempt.result,
           metadata: attempt.metadata,
-          xpAwarded: input.xpAwarded,
+          award: awardRecord,
           appName: game2.appName,
           timestamp: new Date().toISOString()
         });
+        const response = buildCompletedAssessmentSubmitResult({
+          result: attempt.result,
+          metadata: finalization.metadata
+        });
         const finalized = await this.requireClient().api.oneroster.assessmentResults.upsert(attempt.result.sourcedId, finalization.resultUpdate);
         const finalizedForEmission = {
           ...finalized,
@@ -127466,25 +127994,78 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           "app.assessment.submission_id": input.submissionId,
           "app.assessment.purpose": finalization.metadata.purpose,
           "app.assessment.award_age_ms": this.awardAgeMs(attempt.result.scoreDate),
-          "app.assessment.xp_awarded": input.xpAwarded
+          "app.assessment.xp_awarded": input.xpAwarded,
+          "app.assessment.mastered_units_applied": mastery.masteredUnitsApplied,
+          "app.assessment.mastery_achieved": mastery.masteryAchieved,
+          "app.assessment.mastery_revoked": mastery.masteryRevoked
         });
+        await this.settleMasteryAward(finalizedAttempt, mastery, input.submissionId, game2);
         return {
-          response: {
-            ...submitted,
-            status: "completed",
-            xpAwarded: input.xpAwarded
-          },
+          response,
           completion: this.replayCompletion(finalizedAttempt, input.submissionId, params, game2)
         };
       });
       if (award.completion) {
         await this.emitCompletionBestEffort({
           ...award.completion,
-          xpAwarded: input.xpAwarded
+          award: award.response
         });
       }
       return award.response;
     }
+    async evaluateMasteryAward(attempt, studentIdentifier, input) {
+      if (!hasMasteryAwardRequest(input)) {
+        return NO_MASTERY_AWARD;
+      }
+      const student = await this.requireClient().roster.resolveStudent(studentIdentifier);
+      return this.requireClient().activity.evaluateMasteryAward({
+        studentId: student.id,
+        courseId: attempt.integration.courseId,
+        ...input.masteredUnits !== undefined ? { masteredUnits: input.masteredUnits } : {},
+        ...input.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: input.masteredUnitsAbsolute } : {}
+      });
+    }
+    async settleMasteryAward(attempt, mastery, submissionId, game2) {
+      if (!mastery.masteryAchieved && !mastery.masteryRevoked) {
+        return;
+      }
+      const integration = attempt.integration;
+      const course = this.trackableCourse(integration, "assessment.mastery_settlement_invalid_course_metadata", { "app.assessment.attempt_id": attempt.result.sourcedId });
+      if (!course) {
+        setAttributes({ "app.assessment.mastery_completion_entry_missing": true });
+        return;
+      }
+      try {
+        const student = await this.requireClient().roster.resolveStudent(attempt.result.student.sourcedId);
+        const completionHistoryEventId = `urn:uuid:${await deterministicUUID([
+          "playcademy-assessment-course-completed-event-v1",
+          attempt.result.sourcedId,
+          submissionId
+        ].join("\x00"))}`;
+        const settlement = await this.requireClient().activity.settleMasteryAward(mastery, {
+          studentId: student.id,
+          studentEmail: student.email,
+          courseId: integration.courseId,
+          gameId: integration.gameId,
+          activityId: attempt.metadata.activityId,
+          courseName: attempt.metadata.completion?.courseName ?? "Game Course",
+          subject: course.subject,
+          appName: game2.appName,
+          sensorUrl: game2.sensorUrl,
+          completionHistoryEventId
+        });
+        if (mastery.masteryAchieved && !settlement.completionEntryWritten) {
+          setAttributes({ "app.assessment.mastery_completion_entry_missing": true });
+        }
+      } catch (error88) {
+        setAttributes({ "app.assessment.mastery_completion_entry_missing": true });
+        addEvent("assessment.mastery_settlement_failed", {
+          "app.assessment.attempt_id": attempt.result.sourcedId,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage2(error88)
+        });
+      }
+    }
     async finalizeDiagnosticSubmission(input) {
       const { attempt } = input;
       const routing = await this.loadAttemptDiagnosticManifest(attempt.metadata, input.db);
@@ -127931,9 +128512,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       if (this.isSettled(resumed.result)) {
         return this.snapshotForResult(resumed.result, resumed.metadata, context2.integration);
       }
-      const catalog = await this.loadReviewBankCatalog(resumed.metadata.selectedTest.identifier, resumed.metadata.selectedTest.contentRevision);
-      const currentSource = await this.hydrateReviewBankSelection(catalog, resumed.metadata.review.selections.map((selection) => selection.itemIdentifier));
-      const source = this.pinnedReviewBankSource(currentSource, resumed.metadata);
+      const source = await this.loadPinnedReviewBankSource(resumed.metadata);
       const assessment = projectReviewAssessment(source.assessment, source.bank, resumed.metadata.review.selections);
       await this.ensureReviewChildResults({
         result: resumed.result,
@@ -127977,7 +128556,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           membershipItemIdentifiers: loaded.references.questions.map((question) => question.reference.identifier)
         });
       } catch (error88) {
-        throw new ServiceUnavailableError(`Review bank ${identifier} has stale or invalid routing metadata. Use Update Mapping in assessment authoring.`, { reason: errorMessage2(error88) });
+        throw new ServiceUnavailableError(`Review bank ${identifier} has stale or invalid routing metadata. Use Sync Review Bank in assessment authoring.`, { reason: errorMessage2(error88) });
       }
       if (!bank) {
         throw new ServiceUnavailableError(`Review bank ${identifier} needs its authoring mapping updated before it can serve review questions.`);
@@ -127993,28 +128572,60 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       this.reviewBankCache.set(`${identifier}\x00${bank.sourceContentRevision}`, catalog);
       return catalog;
     }
-    async hydrateReviewBankSelection(catalog, itemIdentifiers) {
-      const cacheKey2 = [
-        catalog.test.identifier,
-        catalog.bank.sourceContentRevision,
-        ...itemIdentifiers
-      ].join("\x00");
+    async cachedReviewSelection(input) {
+      const cacheKey2 = [input.identifier, input.contentRevision, ...input.itemIdentifiers].join("\x00");
       const cached3 = this.reviewSelectionCache.get(cacheKey2);
       if (cached3) {
-        return { assessment: cached3, bank: catalog.bank };
+        return cached3;
       }
-      const questions = await hydrateQtiTestQuestionSelection(this.requireClient(), catalog.references, itemIdentifiers);
-      const assessment = await buildPlayableAssessment(catalog.test, questions);
-      assessment.contentRevision = catalog.bank.sourceContentRevision;
+      const { test, questions } = await input.hydrate();
+      const assessment = await buildPlayableAssessment(test, questions);
+      assessment.contentRevision = input.contentRevision;
       this.reviewSelectionCache.set(cacheKey2, assessment);
+      return assessment;
+    }
+    async hydrateReviewBankSelection(catalog, itemIdentifiers) {
+      const assessment = await this.cachedReviewSelection({
+        identifier: catalog.test.identifier,
+        contentRevision: catalog.bank.sourceContentRevision,
+        itemIdentifiers,
+        hydrate: async () => ({
+          test: catalog.test,
+          questions: await hydrateQtiTestQuestionSelection(this.requireClient(), catalog.references, itemIdentifiers)
+        })
+      });
       return { assessment, bank: catalog.bank };
     }
-    pinnedReviewBankSource(source, metadata2) {
+    async loadPinnedReviewBankSource(metadata2) {
+      const itemIdentifiers = metadata2.review.selections.map((selection) => selection.itemIdentifier);
+      let assessment;
+      try {
+        assessment = await this.cachedReviewSelection({
+          identifier: metadata2.selectedTest.identifier,
+          contentRevision: metadata2.selectedTest.contentRevision,
+          itemIdentifiers,
+          hydrate: async () => {
+            const test = await this.requireClient().qtiApi.assessmentTests.get(metadata2.selectedTest.identifier);
+            return {
+              test,
+              questions: await hydrateQtiItemSelection(this.requireClient(), test, itemIdentifiers)
+            };
+          }
+        });
+      } catch (error88) {
+        if (isApiError(error88) && error88.statusCode === 404) {
+          throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `A selected review item for ${metadata2.selectedTest.identifier} is no longer available.`, {
+            identifier: metadata2.selectedTest.identifier,
+            expectedRevision: metadata2.selectedTest.contentRevision
+          });
+        }
+        throw error88;
+      }
       return {
-        assessment: source.assessment,
+        assessment,
         bank: {
-          bankIdentifier: source.assessment.identifier,
-          sourceContentRevision: source.assessment.contentRevision,
+          bankIdentifier: assessment.identifier,
+          sourceContentRevision: metadata2.selectedTest.contentRevision,
           bankRevision: metadata2.review.bankRevision,
           items: metadata2.review.selections.map((selection) => ({
             itemIdentifier: selection.itemIdentifier,
@@ -128038,9 +128649,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       if (metadata2.purpose !== "review") {
         return this.loadAssessment(metadata2.selectedTest.identifier, metadata2.selectedTest.contentRevision);
       }
-      const catalog = await this.loadReviewBankCatalog(metadata2.selectedTest.identifier, metadata2.selectedTest.contentRevision);
-      const currentSource = await this.hydrateReviewBankSelection(catalog, metadata2.review.selections.map((selection) => selection.itemIdentifier));
-      const source = this.pinnedReviewBankSource(currentSource, metadata2);
+      const source = await this.loadPinnedReviewBankSource(metadata2);
       return projectReviewAssessment(source.assessment, source.bank, metadata2.review.selections);
     }
     isPlatformRoutedDiagnosticMetadata(metadata2) {
@@ -128526,7 +129135,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     async projectReviewItemResponse(params, projection) {
       await this.putReviewChildResponse(projection.result, projection.metadata, projection.itemIdentifier);
       try {
-        await this.crossAttemptLockBarrier(params.attemptId);
+        await crossAssessmentAttemptLockBarrier(this.deps.assessmentRuntimeLock, this.deps.db, params.attemptId);
         const latest = await this.peekAttempt(params);
         if (this.isSettled(latest.result) && latest.metadata.purpose === "review") {
           await this.restoreCompletedReviewChildResponses(latest.result, latest.metadata, new Set([projection.itemIdentifier]));
@@ -128540,21 +129149,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async crossAttemptLockBarrier(attemptId) {
-      for (let attempt = 1;attempt <= TimebackAssessmentRuntimeService2.PROJECTION_BARRIER_MAX_ATTEMPTS; attempt += 1) {
-        try {
-          await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(attemptId)], async () => {
-            return;
-          });
-          return;
-        } catch (error88) {
-          if (!(error88 instanceof ServiceUnavailableError) || attempt === TimebackAssessmentRuntimeService2.PROJECTION_BARRIER_MAX_ATTEMPTS) {
-            throw error88;
-          }
-          await sleep(TimebackAssessmentRuntimeService2.PROJECTION_BARRIER_RETRY_DELAY_MS);
-        }
-      }
-    }
     async restoreCompletedReviewChildResponses(result, metadata2, changedItemIdentifiers) {
       const outcomes = metadata2.completion?.itemOutcomes;
       const submissionId = metadata2.submissionId;
@@ -128700,7 +129294,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           attemptId: result.sourcedId,
           responseVersion: metadata2.responseVersion,
           status: "completed",
-          result: this.completedResult(result, metadata2)
+          result: buildCompletedAssessmentSubmitResult({ result, metadata: metadata2 })
         };
       }
       const assessment = await this.loadAttemptAssessment(metadata2);
@@ -128717,58 +129311,37 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       return this.snapshot(result, metadata2, assessment, integration);
     }
     diagnosticSnapshot(result, metadata2, assessment, integration, state) {
-      const activityData = this.activityData(metadata2, assessment, integration);
-      return {
+      return buildDiagnosticAssessmentSnapshot({
         attemptId: result.sourcedId,
-        responseVersion: metadata2.responseVersion,
-        status: "in_progress",
-        flow: "platform-routed-item-submit",
-        ...activityData ? { activityData } : {},
-        assessment: assessmentPresentationForAttempt(assessment, result.sourcedId),
-        selection: {
-          kind: "platform-routed-diagnostic",
-          purpose: "diagnostic",
-          definitionId: metadata2.diagnostic.definitionId,
-          diagnosticKey: metadata2.diagnostic.diagnosticKey,
-          routingRevision: metadata2.diagnostic.routingRevision
-        },
-        routing: this.diagnosticRoutingSnapshot(metadata2, state),
-        completion: null
-      };
+        metadata: metadata2,
+        assessment,
+        state,
+        activityData: this.activityData(metadata2, assessment, integration)
+      });
     }
     diagnosticRoutingSnapshot(metadata2, state) {
       return projectDiagnosticRoutingSnapshot(metadata2.diagnostic.routingRevision, state);
     }
     snapshot(result, metadata2, assessment, integration) {
-      const selection = this.selectionContext(metadata2);
-      const activityData = this.activityData(metadata2, assessment, integration);
-      return {
+      return buildConventionalAssessmentSnapshot({
         attemptId: result.sourcedId,
-        responseVersion: metadata2.responseVersion,
-        status: "in_progress",
-        flow: assessmentFlowForPurpose(metadata2.purpose),
-        ...activityData ? { activityData } : {},
-        assessment: assessmentPresentationForAttempt(assessment, result.sourcedId),
-        responses: metadata2.responses,
-        itemSubmissions: metadata2.itemSubmissions,
-        score: null,
-        selection
-      };
+        metadata: metadata2,
+        assessment,
+        activityData: this.activityData(metadata2, assessment, integration)
+      });
     }
     activityData(metadata2, assessment, integration) {
       const course = this.trackableCourse(integration, "assessment.activity_tracking_invalid_course_metadata");
-      if (!course) {
-        return;
-      }
-      return {
+      return buildAssessmentActivityData({
         activityId: metadata2.activityId,
         activityName: assessment.title,
-        ...course,
-        courseId: integration.courseId
-      };
+        courseId: integration.courseId,
+        course
+      });
     }
     trackableCourse(integration, event, attributes2 = {}) {
-      if (!isTimebackGrade2(integration.grade) || !isTimebackSubject(integration.subject)) {
+      const course = assessmentTrackableCourse(integration);
+      if (!course) {
         addEvent(event, {
           ...attributes2,
           "app.timeback.integration_id": integration.id,
@@ -128777,27 +129350,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
         return null;
       }
-      return { grade: integration.grade, subject: integration.subject };
-    }
-    selectionContext(metadata2) {
-      if (metadata2.purpose === "review") {
-        return {
-          kind: "standards-review",
-          purpose: metadata2.purpose,
-          standards: [...metadata2.review.standards],
-          candidateItemsPerStandard: metadata2.review.candidateItemsPerStandard,
-          selections: [...metadata2.review.selections],
-          fulfillment: metadata2.review.fulfillment
-        };
-      }
-      if (metadata2.purpose === "mastery") {
-        return {
-          kind: "standard-quiz",
-          purpose: metadata2.purpose,
-          standard: metadata2.mastery.standard
-        };
-      }
-      return { kind: "fixed-test", purpose: metadata2.purpose };
+      return course;
     }
     submittedResult(result, metadata2) {
       const response = buildAssessmentSubmitResult({
@@ -128811,29 +129364,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return response;
     }
-    completedResult(result, metadata2) {
-      const xpAwarded = this.xpFromResult(result);
-      if (xpAwarded === null) {
-        throw new GoneError("This completed assessment is missing its recorded XP.", {
-          attemptId: result.sourcedId
-        });
-      }
-      const response = buildCompletedAssessmentSubmitResult({
-        attemptId: result.sourcedId,
-        metadata: metadata2,
-        xpAwarded
-      });
-      if (!response) {
-        throw new GoneError("This completed assessment has incomplete persisted results.", {
-          attemptId: result.sourcedId
-        });
-      }
-      return response;
-    }
-    xpFromResult(result) {
-      const xp = result.metadata?.xp;
-      return typeof xp === "number" && Number.isFinite(xp) && xp >= 0 ? xp : null;
-    }
     awardAgeMs(scoreDate) {
       const submittedAt = Date.parse(scoreDate);
       return Number.isFinite(submittedAt) ? Math.max(0, Date.now() - submittedAt) : -1;
@@ -128960,7 +129490,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           attemptNumber: attempt.metadata.attemptNumber,
           totalQuestions: input.totalQuestions,
           correctQuestions: input.correctQuestions,
-          xpAwarded: input.xpAwarded,
+          xpAwarded: input.award.xpAwarded,
+          ...input.award.masteredUnitsApplied !== 0 ? { masteredUnits: input.award.masteredUnitsApplied } : {},
+          ...input.award.pctCompleteApp !== undefined ? { pctCompleteApp: input.award.pctCompleteApp } : {},
           submittedAt: attempt.result.scoreDate,
           eventId,
           ...session2 ? { resumeId: session2.resumeId } : {}
@@ -129081,6 +129613,9 @@ function assertAssessmentImportCourseMatches(manifest, integration) {
     throw new ValidationError(`This manifest is for ${manifest.subject} grade ${manifest.grade}, not ${integration.subject} grade ${integration.grade}.`);
   }
 }
+function assessmentImportsAffectReviewBank(targetStatus, entries) {
+  return targetStatus === "live" && entries.some((entry2) => entry2.purpose === "mastery");
+}
 function associationMetadataMatches(row, entry2) {
   return row.purpose === entry2.purpose && (row.standardFramework ?? undefined) === entry2.standard?.framework && (row.standardIdentifier ?? undefined) === entry2.standard?.identifier;
 }
@@ -129130,18 +129665,6 @@ function attachedAssessmentImportMessage(targetStatus, editable) {
   }
   return editable ? "Attached as a draft." : "Attached as a read-only draft owned by another app.";
 }
-function liveReviewAssessmentImportFailures(targetStatus, candidates, existingRows) {
-  if (targetStatus === "draft") {
-    return new Map;
-  }
-  const reviews = candidates.filter((candidate) => candidate.purpose === "review");
-  const hasExistingLiveReview = existingRows.some((row) => row.purpose === "review" && row.status === "live");
-  if (reviews.length <= 1 && !hasExistingLiveReview) {
-    return new Map;
-  }
-  const message = hasExistingLiveReview ? "Another review assessment is already live for this course." : "Only one review assessment can be imported live at a time.";
-  return new Map(reviews.map((review) => [review.qtiTestIdentifier, message]));
-}
 var init_timeback_assessment_import_util = __esm(() => {
   init_errors2();
   init_timeback_qti_authoring_util();
@@ -129210,7 +129733,9 @@ class TimebackAssessmentsService {
     const rows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
       where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
     });
-    const assessments2 = await runWithConcurrency(rows, QTI_HYDRATION_CONCURRENCY, async (row) => {
+    const sinkIdentifier = reviewBankSinkIdentifier(integrationId);
+    const visibleRows = rows.filter((row) => row.purpose !== "review" || row.qtiTestIdentifier === sinkIdentifier);
+    const assessments2 = await runWithConcurrency(visibleRows, QTI_HYDRATION_CONCURRENCY, async (row) => {
       try {
         const test = await client2.qtiApi.assessmentTests.get(row.qtiTestIdentifier);
         return {
@@ -129218,7 +129743,7 @@ class TimebackAssessmentsService {
           title: test.title,
           questionCount: countQtiTestItems(test),
           available: true,
-          editable: isQtiTestOwnedByGame(test, ownership.gameSlug)
+          editable: row.purpose !== "review" && isQtiTestOwnedByGame(test, ownership.gameSlug)
         };
       } catch (error88) {
         addEvent("assessment.qti_fetch_failed", {
@@ -129238,8 +129763,11 @@ class TimebackAssessmentsService {
     return assessments2.toSorted((a, b) => a.title.localeCompare(b.title));
   }
   async createAssessment(integrationId, input) {
-    if (input.purpose === "diagnostic") {
-      throw new ValidationError("Adaptive diagnostics must be created by importing assessment JSON with a routing sidecar.");
+    if (input.purpose === "diagnostic" || input.purpose === "review") {
+      throw new ValidationError(input.purpose === "review" ? "The review bank is system-managed. Use Sync Review Bank instead." : "Adaptive diagnostics must be created by importing assessment JSON with a routing sidecar.");
+    }
+    if (input.assessmentKey === reviewBankSinkIdentifier(integrationId)) {
+      throw new ValidationError("This assessment key is reserved for the review bank.");
     }
     const client2 = this.requireClient();
     const ownership = await this.requireQtiTestOwnershipContext(integrationId);
@@ -129315,24 +129843,41 @@ class TimebackAssessmentsService {
       index: index2,
       standard: this.requirePurposeStandard(assessment.purpose, assessment.standard)
     }));
-    const existingRows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
-      where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
-    });
-    const existingByKey = new Map(existingRows.flatMap((row) => row.assessmentKey ? [[row.assessmentKey, row]] : []));
-    const existingByIdentifier = new Map(existingRows.map((row) => [row.qtiTestIdentifier, row]));
+    const sinkIdentifier = reviewBankSinkIdentifier(integrationId);
+    if (entries.some((entry2) => entry2.assessmentKey === sinkIdentifier || entry2.qtiTestIdentifier === sinkIdentifier || entry2.purpose === "review")) {
+      throw new ValidationError("The review bank is system-managed and cannot be attached manually.");
+    }
     const validated = await this.validateAssessmentImportEntries(client2, entries, manifest.targetStatus);
     const results = [];
-    const pendingInserts = this.planAssessmentImports({
-      validated,
-      existingByKey,
-      existingByIdentifier,
-      gameSlug,
-      results
-    });
-    const liveReviewFailures = liveReviewAssessmentImportFailures(manifest.targetStatus, pendingInserts.map(({ entry: entry2 }) => entry2), existingRows);
-    this.recordLiveReviewImportFailures(pendingInserts, liveReviewFailures, gameSlug, results);
-    const attachablePending = pendingInserts.filter(({ entry: entry2 }) => !liveReviewFailures.has(entry2.qtiTestIdentifier));
-    await this.insertImportedAssessments(integrationId, attachablePending, manifest.targetStatus, gameSlug, results);
+    const affectsReviewBank = assessmentImportsAffectReviewBank(manifest.targetStatus, entries);
+    const planAndInsert = async (db2, existingRows) => {
+      const existingByKey = new Map(existingRows.flatMap((row) => row.assessmentKey ? [[row.assessmentKey, row]] : []));
+      const existingByIdentifier = new Map(existingRows.map((row) => [row.qtiTestIdentifier, row]));
+      const pendingInserts = this.planAssessmentImports({
+        validated,
+        existingByKey,
+        existingByIdentifier,
+        gameSlug,
+        results
+      });
+      await this.insertImportedAssessments({
+        db: db2,
+        integrationId,
+        pending: pendingInserts,
+        targetStatus: manifest.targetStatus,
+        gameSlug,
+        results,
+        abortOnError: affectsReviewBank
+      });
+    };
+    if (affectsReviewBank) {
+      await this.withLockedIntegrationAssessmentRows(integrationId, async (tx, lockedAssociations) => planAndInsert(tx, lockedAssociations));
+    } else {
+      const existingRows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
+        where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
+      });
+      await planAndInsert(this.deps.db, existingRows);
+    }
     setAttribute("app.assessment.operation", "bulk_attach_existing");
     setAttribute("app.assessment.bulk_attach.target_status", manifest.targetStatus);
     setAttribute("app.assessment.bulk_attach.created", results.filter((result) => result.status === "created").length);
@@ -129345,11 +129890,6 @@ class TimebackAssessmentsService {
         assertManagedAssessmentIdentity(loaded.test, entry2.assessmentKey);
         assertAssessmentHasQuestions(loaded.questions.questions);
         assertPlayableAssessmentImportQuestions(targetStatus, loaded.questions.questions.map(({ question }) => question));
-        if (entry2.purpose === "review") {
-          assertReviewAssessmentHasStandards(loaded.questions.questions.map(({ question }) => reviewRoutingStandardRefsFromMetadata(question.metadata, {
-            customOnly: true
-          }).length));
-        }
         return { entry: entry2, test: loaded.test };
       } catch (error88) {
         return { entry: entry2, error: error88 };
@@ -129395,25 +129935,13 @@ class TimebackAssessmentsService {
     }
     return pendingInserts;
   }
-  recordLiveReviewImportFailures(pending, failures, gameSlug, results) {
-    for (const { entry: entry2, test } of pending) {
-      const message = failures.get(entry2.qtiTestIdentifier);
-      if (message) {
-        results[entry2.index] = {
-          ...this.associationImportResultBase(entry2, test, gameSlug),
-          status: "failed",
-          message
-        };
-      }
-    }
-  }
-  async concurrentAssessmentImportDecision(integrationId, entry2) {
+  async concurrentAssessmentImportDecision(db2, integrationId, entry2) {
     try {
       const [byKey, byIdentifier] = await Promise.all([
-        this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+        db2.query.gameTimebackAssessmentTests.findFirst({
           where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.assessmentKey, entry2.assessmentKey))
         }),
-        this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+        db2.query.gameTimebackAssessmentTests.findFirst({
           where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, entry2.qtiTestIdentifier))
         })
       ]);
@@ -129425,39 +129953,53 @@ class TimebackAssessmentsService {
       return null;
     }
   }
-  async insertImportedAssessments(integrationId, pending, targetStatus, gameSlug, results) {
-    for (const { entry: entry2, test } of pending) {
-      const base = this.associationImportResultBase(entry2, test, gameSlug);
+  async insertImportedAssessments(input) {
+    for (const { entry: entry2, test } of input.pending) {
+      const base = this.associationImportResultBase(entry2, test, input.gameSlug);
       try {
-        const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
-          integrationId,
+        const [row] = await input.db.insert(gameTimebackAssessmentTests).values({
+          integrationId: input.integrationId,
           assessmentKey: entry2.assessmentKey,
           qtiTestIdentifier: entry2.qtiTestIdentifier,
           purpose: entry2.purpose,
-          status: targetStatus,
+          status: input.targetStatus,
           sortOrder: entry2.sortOrder,
           standardFramework: entry2.standard?.framework,
           standardIdentifier: entry2.standard?.identifier
-        }).returning();
+        }).onConflictDoNothing().returning();
         if (!row) {
-          throw new Error("Assessment association create returned no row");
+          const concurrent = await this.concurrentAssessmentImportDecision(input.db, input.integrationId, entry2);
+          if (concurrent?.decision.kind === "skip" || concurrent?.decision.kind === "fail") {
+            input.results[entry2.index] = {
+              ...base,
+              status: concurrent.decision.status,
+              ...concurrent.byKey ? { association: this.associationImportSummary(concurrent.byKey) } : {},
+              message: concurrent.decision.message
+            };
+          } else {
+            throw new Error("Assessment association insert conflicted");
+          }
+        } else {
+          input.results[entry2.index] = {
+            ...base,
+            status: "created",
+            association: this.associationImportSummary(row),
+            message: attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false)
+          };
         }
-        results[entry2.index] = {
-          ...base,
-          status: "created",
-          association: this.associationImportSummary(row),
-          message: attachedAssessmentImportMessage(targetStatus, base.editable ?? false)
-        };
       } catch (error88) {
-        results[entry2.index] = {
+        if (input.abortOnError) {
+          throw error88;
+        }
+        input.results[entry2.index] = {
           ...base,
           status: "failed",
           message: `Association attach failed: ${errorMessage2(error88)}`
         };
         if (isUniqueViolation(error88)) {
-          const concurrent = await this.concurrentAssessmentImportDecision(integrationId, entry2);
+          const concurrent = await this.concurrentAssessmentImportDecision(input.db, input.integrationId, entry2);
           if (concurrent?.decision.kind === "skip" || concurrent?.decision.kind === "fail") {
-            results[entry2.index] = {
+            input.results[entry2.index] = {
               ...base,
               status: concurrent.decision.status,
               ...concurrent.byKey ? { association: this.associationImportSummary(concurrent.byKey) } : {},
@@ -129471,6 +130013,12 @@ class TimebackAssessmentsService {
   async updateAssessment(integrationId, qtiTestIdentifier, input) {
     try {
       return await this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+        if (row.purpose === "review" || qtiTestIdentifier === reviewBankSinkIdentifier(integrationId)) {
+          throw new ValidationError("The review bank is system-managed and cannot be edited.");
+        }
+        if (input.purpose === "review") {
+          throw new ValidationError("Assessment purpose cannot be changed to the system-managed review bank.");
+        }
         const nextPurpose = input.purpose ?? row.purpose;
         assertPurposeChangeDraft(row, nextPurpose);
         const requestedStandard = input.standard ? this.canonicalAssessmentStandard(input.standard) : undefined;
@@ -129489,19 +130037,10 @@ class TimebackAssessmentsService {
           ...associationUpdates,
           ...diagnosticChanges.updates
         };
-        const nextStatus = input.status ?? row.status;
         const publishing = input.status !== undefined && isAssessmentPublicationTransition(row.status, input.status);
-        const activatingReview = nextPurpose === "review" && nextStatus === "live" && (row.purpose !== "review" || row.status !== "live");
         if (input.status !== undefined) {
           validateAssessmentStatusTransition(row.status, input.status);
         }
-        if (!publishing && !activatingReview && nextPurpose === "review" && row.purpose !== "review") {
-          const ownership = await this.requireQtiTestOwnershipContext(integrationId, tx);
-          await this.rebuildReviewMapping(this.requireClient(), qtiTestIdentifier, {
-            kind: "owned",
-            gameSlug: ownership.gameSlug
-          });
-        }
         if (input.title !== undefined) {
           assertDraftAssessment(row);
           assertAllAssessmentAssociationsDraft(associations);
@@ -129511,7 +130050,7 @@ class TimebackAssessmentsService {
           assertQtiTestOwnedByGame(test, ownership.gameSlug);
           await client2.qtiApi.assessmentTests.update(qtiTestIdentifier, buildQtiTestUpdateInput(test, input.title));
         }
-        if (publishing || activatingReview) {
+        if (publishing) {
           if (nextPurpose === "diagnostic" && !nextDiagnostic) {
             throw new ValidationError("Platform-routed diagnostics require a diagnostic key and routing manifest before publication.");
           }
@@ -129521,8 +130060,7 @@ class TimebackAssessmentsService {
             updates.diagnosticKey = nextDiagnostic.diagnosticKey;
             updates.diagnosticRoutingManifest = nextDiagnostic.routingManifest;
           } else {
-            const reviewOwnership = nextPurpose === "review" && nextStatus === "live" ? await this.requireQtiTestOwnershipContext(integrationId, tx) : undefined;
-            await this.validateAssessmentHasQuestions(loaded, reviewOwnership?.gameSlug);
+            await this.validateAssessmentHasQuestions(loaded);
           }
           if (publishing) {
             const publication = await this.publishManagedAssessment(row, nextPurpose, nextDiagnostic?.routingManifest ?? null, loaded);
@@ -129545,15 +130083,15 @@ class TimebackAssessmentsService {
         if (databaseConstraintName(error88) === "game_timeback_assessment_tests_one_live_diagnostic_key_idx") {
           throw new ValidationError("Only one live revision of a diagnostic key is allowed. Archive the current revision before publishing another.");
         }
-        if (databaseConstraintName(error88) === "game_timeback_assessment_tests_one_live_review_idx") {
-          throw new ValidationError("Only one live review assessment is allowed. Archive the current review bank before publishing another.");
-        }
       }
       throw error88;
     }
   }
   async removeAssessment(integrationId, qtiTestIdentifier) {
     return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx) => {
+      if (qtiTestIdentifier === reviewBankSinkIdentifier(integrationId)) {
+        throw new ValidationError("The review bank is permanent and cannot be removed or archived.");
+      }
       const plan = planAssessmentRemoval(row.status);
       if (plan.kind === "delete") {
         await tx.delete(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.id, row.id));
@@ -129567,6 +130105,9 @@ class TimebackAssessmentsService {
     });
   }
   async reorderAssessments(integrationId, purpose, testIdentifiers) {
+    if (purpose === "review") {
+      throw new ValidationError("The review bank is system-managed and cannot be reordered.");
+    }
     await this.requireIntegration(integrationId);
     validateUniqueAssessmentIdentifiers(testIdentifiers);
     const updatedAt = new Date;
@@ -129624,19 +130165,96 @@ class TimebackAssessmentsService {
     });
     return { ...result, questions };
   }
-  async updateReviewMapping(integrationId, qtiTestIdentifier) {
-    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (_row, _tx, associations) => {
-      if (!associations.some((association) => association.purpose === "review")) {
-        throw new ValidationError("Review mapping is available only for standards-review assessments.");
+  async synchronizeReviewBank(integrationId) {
+    const client2 = this.requireClient();
+    await this.requireIntegration(integrationId);
+    const sinkIdentifier = reviewBankSinkIdentifier(integrationId);
+    for (let attempt = 0;attempt < REVIEW_BANK_SYNC_ATTEMPTS; attempt++) {
+      const associations = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
+        where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
+      });
+      const masterySources = this.reviewBankMasterySources(associations);
+      const contributorFingerprint = await reviewBankContributorFingerprint(masterySources);
+      const existingSink = await this.findReviewBankSink(client2, integrationId);
+      if (existingSink) {
+        assertReviewBankSinkOwnership(existingSink, integrationId);
+      }
+      let unchangedResult = null;
+      if (existingSink) {
+        try {
+          unchangedResult = await unchangedReviewBankSynchronizationResult({
+            sink: existingSink,
+            integrationId,
+            contributorFingerprint,
+            contributorCount: masterySources.length
+          });
+        } catch (error88) {
+          addEvent("assessment.review_mapping_noop_validation_failed", {
+            "app.assessment.qti_test_identifier": existingSink.identifier,
+            "exception.type": errorType(error88),
+            "app.error.message": errorMessage2(error88)
+          });
+        }
       }
-      const client2 = this.requireClient();
-      const result = await this.rebuildReviewMapping(client2, qtiTestIdentifier, {
-        kind: "live-review-repair"
+      let plan = null;
+      let addedItemCount = 0;
+      let removedItemCount = 0;
+      let catalogUnchanged = unchangedResult !== null;
+      if (!unchangedResult) {
+        const contributors = await runWithConcurrency(masterySources, QTI_HYDRATION_CONCURRENCY, async (source) => {
+          const test = await client2.qtiApi.assessmentTests.get(source.qtiTestIdentifier);
+          assertManagedAssessmentIdentity(test, source.assessmentKey);
+          return { ...source, test };
+        });
+        plan = await prepareReviewBankSynchronization({
+          bankIdentifier: sinkIdentifier,
+          contributors,
+          contributorFingerprint
+        });
+        const diff = reviewBankSynchronizationDiff({ existingSink, plan });
+        addedItemCount = diff.addedItemCount;
+        removedItemCount = diff.removedItemCount;
+        catalogUnchanged = diff.unchanged;
+      }
+      const committed = await this.withLockedIntegrationAssessmentRows(integrationId, async (tx, lockedAssociations) => {
+        const lockedSources = this.reviewBankMasterySources(lockedAssociations);
+        const lockedFingerprint = await reviewBankContributorFingerprint(lockedSources);
+        if (lockedFingerprint !== contributorFingerprint) {
+          return null;
+        }
+        const associationChanged = await this.installReviewBankAssociation({
+          tx,
+          integrationId,
+          associations: lockedAssociations,
+          sinkIdentifier,
+          beforeInstall: async () => {
+            if (!catalogUnchanged) {
+              await this.writeReviewBankSink({
+                client: client2,
+                integrationId,
+                existingSink,
+                plan,
+                metadata: reviewBankSinkMetadata(integrationId, plan)
+              });
+            }
+          }
+        });
+        const unchanged = catalogUnchanged && !associationChanged;
+        const result = unchangedResult ? { ...unchangedResult, unchanged } : {
+          qtiTestIdentifier: sinkIdentifier,
+          ...plan.summary,
+          addedItemCount,
+          removedItemCount,
+          unchanged,
+          warnings: plan.warnings
+        };
+        return this.reviewMappingResult(result);
       });
-      setAttribute("app.assessment.operation", "update_review_mapping");
-      setAttribute("app.assessment.review_mapping_item_count", result.itemCount);
-      return result;
-    });
+      if (committed) {
+        return committed;
+      }
+    }
+    throw new ValidationError("Mastery assessments changed while the review bank was synchronizing. Try again.");
   }
   async listQuestionLibrary(integrationId, params) {
     const client2 = this.requireClient();
@@ -129656,15 +130274,18 @@ class TimebackAssessmentsService {
       purpose,
       standard: standardInput
     } = input;
-    if (purpose === "diagnostic") {
-      throw new ValidationError("Adaptive diagnostics must be created by importing assessment JSON with a routing sidecar.");
+    if (purpose === "diagnostic" || purpose === "review") {
+      throw new ValidationError(purpose === "review" ? "The review bank is system-managed. Use Sync Review Bank instead." : "Adaptive diagnostics must be created by importing assessment JSON with a routing sidecar.");
+    }
+    if (assessmentKey === reviewBankSinkIdentifier(integrationId) || targetTestIdentifier === reviewBankSinkIdentifier(integrationId)) {
+      throw new ValidationError("This assessment identity is reserved for the review bank.");
     }
     const client2 = this.requireClient();
     const ownership = await this.requireQtiTestOwnershipContext(integrationId);
     const { integration } = ownership;
     const standard = this.requirePurposeStandard(purpose, standardInput);
     const source = await client2.qtiApi.assessmentTests.get(sourceTestIdentifier);
-    const itemPlan = buildQtiAssessmentItemCopyPlan(source, targetTestIdentifier, (identifier) => this.qtiItemHref(client2, identifier));
+    const itemPlan = buildQtiAssessmentItemCopyPlan(source, targetTestIdentifier, (identifier) => qtiItemHref(client2, identifier));
     const itemCopies = await runWithConcurrency(itemPlan, QTI_HYDRATION_CONCURRENCY, async (plan) => {
       const sourceItem = await client2.qtiApi.assessmentItems.get(plan.sourceIdentifier);
       return {
@@ -129789,7 +130410,7 @@ class TimebackAssessmentsService {
         };
       }
       const section = await this.qtiSectionItems(client2, qtiTestIdentifier, undefined, undefined, ownership.test);
-      const href = this.qtiItemHref(client2, itemIdentifier);
+      const href = qtiItemHref(client2, itemIdentifier);
       let item;
       let itemCreationAttempted = false;
       let referenceCreationAttempted = false;
@@ -129899,7 +130520,7 @@ class TimebackAssessmentsService {
       const result = await section.items.reorder({
         items: items.map((item) => ({
           identifier: item.identifier,
-          href: item.href ?? this.qtiItemHref(client2, item.identifier),
+          href: item.href ?? qtiItemHref(client2, item.identifier),
           sequence: item.sequence
         }))
       });
@@ -129913,6 +130534,121 @@ class TimebackAssessmentsService {
     }
     return this.deps.timeback;
   }
+  reviewBankMasterySources(associations) {
+    return associations.filter((association) => association.purpose === "mastery" && association.status === "live").map((association) => {
+      const standard = assessmentStandardForRow(association);
+      if (!association.assessmentKey || !standard) {
+        throw new ValidationError(`Live mastery assessment ${association.qtiTestIdentifier} requires a managed identity and standard`);
+      }
+      if (assessmentKeyFromManagedQtiIdentifier(association.qtiTestIdentifier) !== association.assessmentKey) {
+        throw new ValidationError(`Live mastery assessment ${association.qtiTestIdentifier} is not a managed publication for ${association.assessmentKey}`);
+      }
+      return {
+        assessmentKey: association.assessmentKey,
+        qtiTestIdentifier: association.qtiTestIdentifier,
+        standard
+      };
+    });
+  }
+  async writeReviewBankSink(input) {
+    function sinkInput(title, includeIdentifier = false) {
+      return buildReviewBankSinkInput({
+        identifier: input.plan.bankIdentifier,
+        title,
+        metadata: input.metadata,
+        itemIdentifiers: input.plan.itemIdentifiers,
+        itemHref: (identifier) => qtiItemHref(input.client, identifier),
+        includeIdentifier
+      });
+    }
+    if (input.existingSink) {
+      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(input.existingSink.title));
+      return;
+    }
+    try {
+      const createInput = sinkInput(REVIEW_BANK_TITLE, true);
+      await input.client.qtiApi.assessmentTests.create(createInput);
+    } catch (error88) {
+      if (!isApiError(error88) || error88.statusCode !== 409) {
+        throw error88;
+      }
+      const concurrentlyCreated = await input.client.qtiApi.assessmentTests.get(input.plan.bankIdentifier);
+      assertReviewBankSinkOwnership(concurrentlyCreated, input.integrationId);
+      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(concurrentlyCreated.title));
+    }
+  }
+  async installReviewBankAssociation(input) {
+    const singleton = input.associations.find((association) => association.qtiTestIdentifier === input.sinkIdentifier);
+    if (singleton && singleton.purpose !== "review") {
+      throw new ValidationError("The reserved review-bank identifier is associated with another assessment purpose.");
+    }
+    const legacyReviews = input.associations.filter((association) => association.purpose === "review" && association.qtiTestIdentifier !== input.sinkIdentifier);
+    const reservedKeyOwner = input.associations.find((association) => association.assessmentKey === input.sinkIdentifier && association.qtiTestIdentifier !== input.sinkIdentifier);
+    if (reservedKeyOwner && reservedKeyOwner.purpose !== "review") {
+      throw new ValidationError("The reserved review-bank assessment key is already in use.");
+    }
+    const singletonCurrent = Boolean(singleton && singleton.assessmentKey === input.sinkIdentifier && singleton.status === "live" && singleton.sortOrder === null && singleton.standardFramework === null && singleton.standardIdentifier === null && singleton.diagnosticKey === null && singleton.diagnosticRoutingManifest === null);
+    const legacyCurrent = legacyReviews.every((association) => association.status === "archived" && association.sortOrder === null && association.assessmentKey !== input.sinkIdentifier);
+    const changed = !singletonCurrent || !legacyCurrent;
+    await input.beforeInstall();
+    for (const legacy of legacyReviews) {
+      if (legacy.status !== "archived" || legacy.sortOrder !== null || legacy.assessmentKey === input.sinkIdentifier) {
+        await input.tx.update(gameTimebackAssessmentTests).set({
+          status: "archived",
+          sortOrder: null,
+          ...legacy.assessmentKey === input.sinkIdentifier ? { assessmentKey: null } : {},
+          updatedAt: new Date
+        }).where(eq(gameTimebackAssessmentTests.id, legacy.id));
+      }
+    }
+    if (singletonCurrent) {
+      return changed;
+    }
+    if (singleton) {
+      await input.tx.update(gameTimebackAssessmentTests).set({
+        assessmentKey: input.sinkIdentifier,
+        purpose: "review",
+        status: "live",
+        sortOrder: null,
+        standardFramework: null,
+        standardIdentifier: null,
+        diagnosticKey: null,
+        diagnosticRoutingManifest: null,
+        updatedAt: new Date
+      }).where(eq(gameTimebackAssessmentTests.id, singleton.id));
+      return changed;
+    }
+    await input.tx.insert(gameTimebackAssessmentTests).values({
+      integrationId: input.integrationId,
+      assessmentKey: input.sinkIdentifier,
+      qtiTestIdentifier: input.sinkIdentifier,
+      purpose: "review",
+      status: "live",
+      sortOrder: null,
+      standardFramework: null,
+      standardIdentifier: null,
+      diagnosticKey: null,
+      diagnosticRoutingManifest: null
+    });
+    return changed;
+  }
+  reviewMappingResult(result) {
+    setAttribute("app.assessment.operation", "update_review_mapping");
+    setAttribute("app.assessment.review_mapping_item_count", result.itemCount);
+    setAttribute("app.assessment.review_mapping_added_item_count", result.addedItemCount);
+    setAttribute("app.assessment.review_mapping_removed_item_count", result.removedItemCount);
+    return result;
+  }
+  async withLockedIntegrationAssessmentRows(integrationId, action) {
+    return this.deps.db.transaction(async (tx) => {
+      const [integration] = await tx.select({ id: gameTimebackIntegrations.id }).from(gameTimebackIntegrations).where(and(eq(gameTimebackIntegrations.id, integrationId), isActiveGameTimebackIntegrationStatus())).for("update");
+      if (!integration) {
+        throw new NotFoundError(`Integration not found: ${integrationId}`);
+      }
+      const rows = await tx.select().from(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.integrationId, integrationId)).orderBy(gameTimebackAssessmentTests.id).for("update");
+      return action(tx, rows);
+    });
+  }
   async withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, action) {
     return this.deps.db.transaction(async (tx) => {
       const rows = await tx.select().from(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.qtiTestIdentifier, qtiTestIdentifier)).orderBy(gameTimebackAssessmentTests.id).for("update");
@@ -129997,8 +130733,16 @@ class TimebackAssessmentsService {
       items: client2.qtiApi.assessmentTests.testParts(qtiTestIdentifier).sections(section.partIdentifier).items(section.sectionIdentifier)
     };
   }
-  qtiItemHref(client2, itemIdentifier) {
-    return `${client2.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
+  async findReviewBankSink(client2, integrationId) {
+    const identifier = reviewBankSinkIdentifier(integrationId);
+    try {
+      return await client2.qtiApi.assessmentTests.get(identifier);
+    } catch (error88) {
+      if (isApiError(error88) && error88.statusCode === 404) {
+        return null;
+      }
+      throw error88;
+    }
   }
   async ensureImmutableQtiResource(get, create) {
     try {
@@ -130039,7 +130783,7 @@ class TimebackAssessmentsService {
       test: loaded.test,
       questions: loaded.questions,
       diagnosticRoutingManifest,
-      itemHref: (identifier) => this.qtiItemHref(client2, identifier)
+      itemHref: (identifier) => qtiItemHref(client2, identifier)
     });
     await this.ensureManagedQtiPublication(client2, plan);
     return plan;
@@ -130121,15 +130865,11 @@ class TimebackAssessmentsService {
     const plan = buildQtiLibraryListPlan(params);
     return list(plan.params);
   }
-  async validateAssessmentHasQuestions(loaded, reviewGameSlug) {
+  async validateAssessmentHasQuestions(loaded) {
     assertAssessmentHasQuestions(loaded.questions.questions);
     for (const { question } of loaded.questions.questions) {
       assertPlayableQtiQuestion(question);
     }
-    if (reviewGameSlug) {
-      assertQtiTestOwnedByGame(loaded.test, reviewGameSlug);
-      await this.writeReviewMapping(this.requireClient(), loaded.test, loaded.questions);
-    }
   }
   async prepareDiagnosticAssociationChanges(row, nextPurpose, requested) {
     if (row.purpose !== "diagnostic" && nextPurpose === "diagnostic" && !requested) {
@@ -130158,22 +130898,9 @@ class TimebackAssessmentsService {
       }
     };
   }
-  async rebuildReviewMapping(client2, qtiTestIdentifier, scope) {
-    const [test, references] = await Promise.all([
-      client2.qtiApi.assessmentTests.get(qtiTestIdentifier),
-      client2.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier)
-    ]);
-    if (scope.kind === "owned") {
-      assertQtiTestOwnedByGame(test, scope.gameSlug);
-    }
-    return this.writeReviewMapping(client2, test, await hydrateQtiTestQuestions(client2, references));
-  }
-  async writeReviewMapping(client2, test, questions) {
-    const prepared = await prepareReviewMappingUpdate(test, questions);
-    await client2.qtiApi.assessmentTests.update(test.identifier, prepared.update);
-    return prepared.summary;
-  }
 }
+var REVIEW_BANK_TITLE = "Review Bank";
+var REVIEW_BANK_SYNC_ATTEMPTS = 2;
 var init_timeback_assessments_service = __esm(async () => {
   init_drizzle_orm();
   init_helpers_index();
@@ -192833,7 +193560,7 @@ var listAssessments;
 var createAssessment;
 var attachExistingAssessments;
 var updateAssessment;
-var updateReviewMapping;
+var synchronizeReviewBank;
 var reorderAssessments;
 var reorderQuestions;
 var removeAssessment;
@@ -193206,7 +193933,9 @@ var init_timeback_controller = __esm(() => {
       attemptId,
       input: {
         submissionId: body2.submissionId,
-        xpAwarded: body2.xpAwarded
+        xpAwarded: body2.xpAwarded,
+        ...body2.masteredUnits !== undefined ? { masteredUnits: body2.masteredUnits } : {},
+        ...body2.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: body2.masteredUnitsAbsolute } : {}
       },
       game: {
         appName: body2.appName,
@@ -193540,13 +194269,13 @@ var init_timeback_controller = __esm(() => {
     const body2 = await parseRequestBody(ctx.request, UpdateAssessmentRequestSchema);
     return ctx.services.timebackAssessments.updateAssessment(integrationId, testIdentifier, body2);
   });
-  updateReviewMapping = requireDeveloper(async (ctx) => {
-    const { gameId, courseId, testIdentifier } = ctx.params;
-    if (!gameId || !courseId || !testIdentifier) {
-      throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
+  synchronizeReviewBank = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
     }
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    return ctx.services.timebackAssessments.updateReviewMapping(integrationId, testIdentifier);
+    return ctx.services.timebackAssessments.synchronizeReviewBank(integrationId);
   });
   reorderAssessments = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
@@ -193697,7 +194426,7 @@ var init_timeback_controller = __esm(() => {
     createAssessment,
     attachExistingAssessments,
     updateAssessment,
-    updateReviewMapping,
+    synchronizeReviewBank,
     reorderAssessments,
     removeAssessment,
     reorderQuestions,