@playcademy/sandbox 0.8.1-beta.1 → 0.8.1-beta.2

package/dist/server.js

@@ -1127,7 +1127,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     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: {
@@ -1497,6 +1497,9 @@ async function runWithConcurrency(items, concurrency, worker) {
 }
 
 // ../utils/src/timeback.ts
+function reviewBankSinkIdentifier(integrationId) {
+  return `playcademy-review-bank.${integrationId}`;
+}
 function playcademySupportedQtiInteractionType(value) {
   if (typeof value !== "string") {
     return;
@@ -9480,9 +9483,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";
@@ -10963,7 +10969,7 @@ async function reviewBankRevision(input) {
   })}`);
   return `review-bank-v1:${bankRevisionUuid}`;
 }
-async function reviewBankIndex(input) {
+async function buildReviewBankIndexFromReferences(input) {
   return {
     ...input,
     bankRevision: await reviewBankRevision(input)
@@ -10992,7 +10998,7 @@ async function buildReviewBankIndex(assessment, questions, options = {}) {
       standards
     };
   });
-  return reviewBankIndex({
+  return buildReviewBankIndexFromReferences({
     bankIdentifier: assessment.identifier,
     sourceContentRevision: assessment.contentRevision,
     items
@@ -11097,7 +11103,7 @@ async function reviewBankIndexFromManifest(metadata2, input) {
       }
     }
   }
-  const index = await reviewBankIndex({
+  const index = await buildReviewBankIndexFromReferences({
     bankIdentifier,
     sourceContentRevision,
     items: input.membershipItemIdentifiers.map((itemIdentifier) => ({
@@ -11452,6 +11458,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);
 }
@@ -11476,7 +11494,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)) {
@@ -11914,7 +11932,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);
@@ -11923,10 +11946,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);
 });
 
 // ../api-core/src/errors/assessment-runtime.error.ts
@@ -47109,6 +47132,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, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, AssessmentKeySchema, DiagnosticKeySchema, DiagnosticRoutingManifestSchema, DiagnosticAssessmentDefinitionInputSchema, AssessmentStandardRefSchema2, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, AssessmentAssociationImportEntrySchema, AttachExistingAssessmentsRequestSchema, ReorderAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
   init_esm();
@@ -47370,7 +47402,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(),
@@ -47379,13 +47414,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"),
@@ -47394,6 +47432,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",
@@ -47443,7 +47482,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),
@@ -90872,6 +90911,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,
@@ -90880,7 +90920,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,
@@ -90934,6 +90977,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");
@@ -90949,12 +91071,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) {
@@ -90980,52 +91102,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,
@@ -91046,7 +91148,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 });
@@ -91067,36 +91169,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" });
@@ -91494,9 +91566,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),
@@ -92780,8 +92855,9 @@ class TimebackClient2 {
     this.core.caches.clearAll();
   }
 }
-var TimebackError, TimebackAuthenticationError, StudentNotFoundError, ConfigurationError, UUID_REGEX2, ONEROSTER_PATHS, TIMEBACK_API_URLS, QTI_API_URL = "https://qti.alpha-1edtech.ai/api", TIMEBACK_AUTH_URLS, CALIPER_API_URLS, ENV_VARS, ONEROSTER_STATUS, SCORE_STATUS, CACHE_DEFAULTS, PLAYCADEMY_DEFAULTS, RESOURCE_DEFAULTS, DEFAULT_TIMEOUT = 30000, SUBJECT_VALUES2, GRADE_VALUES3, MASTERY_WRITE_CAPPED_WARNING_CODE = "MASTERY_WRITE_CAPPED", EmailSchema;
+var TimebackError, TimebackAuthenticationError, StudentNotFoundError, ConfigurationError, UUID_REGEX2, ONEROSTER_PATHS, NO_MASTERY_AWARD, TIMEBACK_API_URLS, QTI_API_URL = "https://qti.alpha-1edtech.ai/api", TIMEBACK_AUTH_URLS, CALIPER_API_URLS, ENV_VARS, ONEROSTER_STATUS, SCORE_STATUS, CACHE_DEFAULTS, PLAYCADEMY_DEFAULTS, RESOURCE_DEFAULTS, DEFAULT_TIMEOUT = 30000, SUBJECT_VALUES2, GRADE_VALUES3, MASTERY_WRITE_CAPPED_WARNING_CODE = "MASTERY_WRITE_CAPPED", EmailSchema;
 var init_dist5 = __esm(async () => {
+  init_spans();
   init_spans();
   init_src();
   init_spans();
@@ -92842,6 +92918,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"
@@ -95607,6 +95688,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) {
@@ -98340,6 +98477,22 @@ var init_locks = __esm(() => {
 });
 
 // ../api-core/src/utils/assessment-runtime-lock.util.ts
+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();
 }
@@ -99353,6 +99506,97 @@ var init_timeback_qti_authoring_util = __esm(() => {
 });
 
 // ../api-core/src/utils/timeback-assessment-runtime.util.ts
+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);
@@ -99563,13 +99807,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([
@@ -99896,6 +100162,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) {
@@ -99982,7 +100264,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");
@@ -99990,8 +100272,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: {
@@ -100003,7 +100287,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
@@ -100016,6 +100301,7 @@ var init_timeback_assessment_runtime_util = __esm(() => {
   init_src();
   init_assessment_runtime2();
   init_qti();
+  init_types2();
   init_utils6();
   init_timeback4();
   init_uuid();
@@ -100024,6 +100310,210 @@ var init_timeback_assessment_runtime_util = __esm(() => {
 });
 
 // ../api-core/src/utils/timeback-review-mapping.util.ts
+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;
@@ -100072,11 +100562,47 @@ async function prepareReviewMappingUpdate(test, questions) {
     }
   };
 }
+var PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink", PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1, StoredSinkWarningSchema, 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 };
+  });
 });
 
 // ../api-core/src/utils/timeback-assessment-publication.util.ts
@@ -100380,11 +100906,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" };
@@ -100447,6 +100968,9 @@ var init_timeback_assessment_rules_util = __esm(() => {
 });
 
 // ../api-core/src/utils/timeback-qti-hydration.util.ts
+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,
@@ -100469,6 +100993,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),
@@ -100484,7 +101030,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();
+});
 
 // ../api-core/src/services/timeback-assessment-runtime.service.ts
 var TimebackAssessmentRuntimeService;
@@ -100514,8 +101062,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 = 15 * 60 * 1000;
     deps;
@@ -101058,15 +101604,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 >= TimebackAssessmentRuntimeService.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" };
           }
@@ -101189,15 +101727,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 >= TimebackAssessmentRuntimeService.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" };
           }
@@ -101212,7 +101742,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 }));
@@ -101285,22 +101815,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);
@@ -101334,7 +101848,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 {
@@ -101605,11 +102119,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)
           };
         }
@@ -101617,20 +102134,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,
@@ -101649,25 +102173,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": errorMessage(error88)
+        });
+      }
+    }
     async finalizeDiagnosticSubmission(input) {
       const { attempt } = input;
       const routing = await this.loadAttemptDiagnosticManifest(attempt.metadata, input.db);
@@ -102114,9 +102691,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,
@@ -102160,7 +102735,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: errorMessage(error88) });
+        throw new ServiceUnavailableError(`Review bank ${identifier} has stale or invalid routing metadata. Use Sync Review Bank in assessment authoring.`, { reason: errorMessage(error88) });
       }
       if (!bank) {
         throw new ServiceUnavailableError(`Review bank ${identifier} needs its authoring mapping updated before it can serve review questions.`);
@@ -102176,28 +102751,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,
@@ -102221,9 +102828,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) {
@@ -102709,7 +103314,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]));
@@ -102723,21 +103328,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async crossAttemptLockBarrier(attemptId) {
-      for (let attempt = 1;attempt <= TimebackAssessmentRuntimeService.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 === TimebackAssessmentRuntimeService.PROJECTION_BARRIER_MAX_ATTEMPTS) {
-            throw error88;
-          }
-          await sleep(TimebackAssessmentRuntimeService.PROJECTION_BARRIER_RETRY_DELAY_MS);
-        }
-      }
-    }
     async restoreCompletedReviewChildResponses(result, metadata2, changedItemIdentifiers) {
       const outcomes = metadata2.completion?.itemOutcomes;
       const submissionId = metadata2.submissionId;
@@ -102883,7 +103473,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);
@@ -102900,58 +103490,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,
@@ -102960,27 +103529,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({
@@ -102994,29 +103543,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;
@@ -103143,7 +103669,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 } : {}
@@ -103268,6 +103796,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((entry) => entry.purpose === "mastery");
+}
 function associationMetadataMatches(row, entry) {
   return row.purpose === entry.purpose && (row.standardFramework ?? undefined) === entry.standard?.framework && (row.standardIdentifier ?? undefined) === entry.standard?.identifier;
 }
@@ -103317,18 +103848,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();
@@ -103400,7 +103919,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 {
@@ -103408,7 +103929,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", {
@@ -103428,8 +103949,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);
@@ -103505,24 +104029,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((entry) => entry.assessmentKey === sinkIdentifier || entry.qtiTestIdentifier === sinkIdentifier || entry.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 }) => entry), existingRows);
-    this.recordLiveReviewImportFailures(pendingInserts, liveReviewFailures, gameSlug, results);
-    const attachablePending = pendingInserts.filter(({ entry }) => !liveReviewFailures.has(entry.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);
@@ -103535,11 +104076,6 @@ class TimebackAssessmentsService {
         assertManagedAssessmentIdentity(loaded.test, entry.assessmentKey);
         assertAssessmentHasQuestions(loaded.questions.questions);
         assertPlayableAssessmentImportQuestions(targetStatus, loaded.questions.questions.map(({ question }) => question));
-        if (entry.purpose === "review") {
-          assertReviewAssessmentHasStandards(loaded.questions.questions.map(({ question }) => reviewRoutingStandardRefsFromMetadata(question.metadata, {
-            customOnly: true
-          }).length));
-        }
         return { entry, test: loaded.test };
       } catch (error88) {
         return { entry, error: error88 };
@@ -103585,25 +104121,13 @@ class TimebackAssessmentsService {
     }
     return pendingInserts;
   }
-  recordLiveReviewImportFailures(pending, failures, gameSlug, results) {
-    for (const { entry, test } of pending) {
-      const message = failures.get(entry.qtiTestIdentifier);
-      if (message) {
-        results[entry.index] = {
-          ...this.associationImportResultBase(entry, test, gameSlug),
-          status: "failed",
-          message
-        };
-      }
-    }
-  }
-  async concurrentAssessmentImportDecision(integrationId, entry) {
+  async concurrentAssessmentImportDecision(db2, integrationId, entry) {
     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, entry.assessmentKey))
         }),
-        this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+        db2.query.gameTimebackAssessmentTests.findFirst({
           where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, entry.qtiTestIdentifier))
         })
       ]);
@@ -103615,39 +104139,53 @@ class TimebackAssessmentsService {
       return null;
     }
   }
-  async insertImportedAssessments(integrationId, pending, targetStatus, gameSlug, results) {
-    for (const { entry, test } of pending) {
-      const base = this.associationImportResultBase(entry, test, gameSlug);
+  async insertImportedAssessments(input) {
+    for (const { entry, test } of input.pending) {
+      const base = this.associationImportResultBase(entry, 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: entry.assessmentKey,
           qtiTestIdentifier: entry.qtiTestIdentifier,
           purpose: entry.purpose,
-          status: targetStatus,
+          status: input.targetStatus,
           sortOrder: entry.sortOrder,
           standardFramework: entry.standard?.framework,
           standardIdentifier: entry.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, entry);
+          if (concurrent?.decision.kind === "skip" || concurrent?.decision.kind === "fail") {
+            input.results[entry.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[entry.index] = {
+            ...base,
+            status: "created",
+            association: this.associationImportSummary(row),
+            message: attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false)
+          };
         }
-        results[entry.index] = {
-          ...base,
-          status: "created",
-          association: this.associationImportSummary(row),
-          message: attachedAssessmentImportMessage(targetStatus, base.editable ?? false)
-        };
       } catch (error88) {
-        results[entry.index] = {
+        if (input.abortOnError) {
+          throw error88;
+        }
+        input.results[entry.index] = {
           ...base,
           status: "failed",
           message: `Association attach failed: ${errorMessage(error88)}`
         };
         if (isUniqueViolation(error88)) {
-          const concurrent = await this.concurrentAssessmentImportDecision(integrationId, entry);
+          const concurrent = await this.concurrentAssessmentImportDecision(input.db, input.integrationId, entry);
           if (concurrent?.decision.kind === "skip" || concurrent?.decision.kind === "fail") {
-            results[entry.index] = {
+            input.results[entry.index] = {
               ...base,
               status: concurrent.decision.status,
               ...concurrent.byKey ? { association: this.associationImportSummary(concurrent.byKey) } : {},
@@ -103661,6 +104199,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;
@@ -103679,19 +104223,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);
@@ -103701,7 +104236,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.");
           }
@@ -103711,8 +104246,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);
@@ -103735,15 +104269,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));
@@ -103757,6 +104291,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;
@@ -103814,19 +104351,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": errorMessage(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();
@@ -103846,15 +104460,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 {
@@ -103979,7 +104596,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;
@@ -104089,7 +104706,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
         }))
       });
@@ -104103,6 +104720,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");
@@ -104187,8 +104919,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 {
@@ -104229,7 +104969,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;
@@ -104311,15 +105051,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) {
@@ -104348,22 +105084,8 @@ 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", REVIEW_BANK_SYNC_ATTEMPTS = 2;
 var init_timeback_assessments_service = __esm(async () => {
   init_drizzle_orm();
   init_helpers_index();
@@ -164385,7 +165107,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, updateReviewMapping, reorderAssessments, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, synchronizeReviewBank, reorderAssessments, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -164747,7 +165469,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,
@@ -165081,13 +165805,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;
@@ -165238,7 +165962,7 @@ var init_timeback_controller = __esm(() => {
     createAssessment,
     attachExistingAssessments,
     updateAssessment,
-    updateReviewMapping,
+    synchronizeReviewBank,
     reorderAssessments,
     removeAssessment,
     reorderQuestions,