@playcademy/sandbox 0.8.1-beta.5 → 0.8.1-beta.7

package/dist/server.js

@@ -284,7 +284,7 @@ var init_platform = __esm(() => {
 var PLATFORM_TIMEZONE = "America/New_York";
 
 // ../constants/src/timeback.ts
-var TIMEBACK_GRADES, TIMEBACK_SUBJECTS, ASSESSMENT_PURPOSES, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION = 1, PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION = 1, PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION = 1, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY = "playcademyAssessment", PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY = "playcademyAssessmentItem", TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS, TIMEBACK_ORG_SOURCED_ID = "PLAYCADEMY", TIMEBACK_ORG_NAME = "Playcademy Studios", TIMEBACK_ORG_TYPE = "department", TIMEBACK_COURSE_DEFAULTS, TIMEBACK_RESOURCE_DEFAULTS, TIMEBACK_COMPONENT_DEFAULTS, TIMEBACK_COMPONENT_RESOURCE_DEFAULTS, TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH = 2048, TIMEBACK_GAME_METRIC_DECIMAL_PLACES, TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE;
+var TIMEBACK_GRADES, TIMEBACK_SUBJECTS, ASSESSMENT_PURPOSES, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION = 1, PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION = 1, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY = "playcademyAssessment", PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY = "playcademyAssessmentItem", TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS, TIMEBACK_ORG_SOURCED_ID = "PLAYCADEMY", TIMEBACK_ORG_NAME = "Playcademy Studios", TIMEBACK_ORG_TYPE = "department", TIMEBACK_COURSE_DEFAULTS, TIMEBACK_RESOURCE_DEFAULTS, TIMEBACK_COMPONENT_DEFAULTS, TIMEBACK_COMPONENT_RESOURCE_DEFAULTS, TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH = 2048, TIMEBACK_GAME_METRIC_DECIMAL_PLACES, TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE;
 var init_timeback2 = __esm(() => {
   TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
   TIMEBACK_SUBJECTS = [
@@ -1127,7 +1127,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.8.1-beta.5",
+    version: "0.8.1-beta.7",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -9239,26 +9239,6 @@ var init_v3 = __esm(() => {
 var init_esm = __esm(() => {
   init_v3();
 });
-// ../types/src/timeback/assessment-runtime.ts
-var PLAYABLE_ASSESSMENT_SHAPES;
-var init_assessment_runtime = __esm(() => {
-  PLAYABLE_ASSESSMENT_SHAPES = ["circle", "ellipse", "rect", "poly", "default"];
-});
-// ../types/src/timeback/diagnostic-routing.ts
-var DIAGNOSTIC_ROUTING_MANIFEST_VERSION = 1, DIAGNOSTIC_ROUTING_STATE_VERSION = 1, DIAGNOSTIC_TRACK_OUTCOMES;
-var init_diagnostic_routing = __esm(() => {
-  DIAGNOSTIC_TRACK_OUTCOMES = [
-    "provisional",
-    "unresolved",
-    "route-to-instruction",
-    "not-assessed"
-  ];
-});
-// ../types/src/timeback/index.ts
-var init_timeback4 = __esm(() => {
-  init_assessment_runtime();
-  init_diagnostic_routing();
-});
 
 // ../utils/src/uuid.ts
 function isValidUUID(value) {
@@ -9282,6 +9262,26 @@ var UUID_REGEX;
 var init_uuid = __esm(() => {
   UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 });
+// ../types/src/timeback/assessment-runtime.ts
+var PLAYABLE_ASSESSMENT_SHAPES;
+var init_assessment_runtime = __esm(() => {
+  PLAYABLE_ASSESSMENT_SHAPES = ["circle", "ellipse", "rect", "poly", "default"];
+});
+// ../types/src/timeback/diagnostic-routing.ts
+var DIAGNOSTIC_ROUTING_MANIFEST_VERSION = 1, DIAGNOSTIC_ROUTING_STATE_VERSION = 1, DIAGNOSTIC_TRACK_OUTCOMES;
+var init_diagnostic_routing = __esm(() => {
+  DIAGNOSTIC_TRACK_OUTCOMES = [
+    "provisional",
+    "unresolved",
+    "route-to-instruction",
+    "not-assessed"
+  ];
+});
+// ../types/src/timeback/index.ts
+var init_timeback4 = __esm(() => {
+  init_assessment_runtime();
+  init_diagnostic_routing();
+});
 
 // ../timeback/dist/engines/assessment-runtime/index.js
 function qtiDirectedPairValidationIssue(values, contract) {
@@ -9561,6 +9561,25 @@ function assessmentReviewBankShortage(fulfillment) {
 function assessmentFlowForPurpose(purpose) {
   return purpose === "review" ? "item-submit" : "attempt-submit";
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTimebackGrade(value) {
+  return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES.includes(value);
+}
+function isAssessmentSessionTiming(value) {
+  return isObject(value) && typeof value.runId === "string" && isValidUUID(value.runId) && typeof value.resumeId === "string" && isValidUUID(value.resumeId) && isNonNegativeDuration(value.activeSeconds) && (value.inactiveSeconds === undefined || isNonNegativeDuration(value.inactiveSeconds));
+}
+function isNonNegativeDuration(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isAssessmentPurpose(value) {
+  return ASSESSMENT_PURPOSES.includes(value);
+}
+function isAssessmentResponseValue(value) {
+  const entries = Array.isArray(value) ? value : [value];
+  return entries.length > 0 && entries.every((entry) => typeof entry === "string" && entry.length > 0 && entry.length <= TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH);
+}
 function compareCodeUnits(left, right) {
   if (left < right) {
     return -1;
@@ -10414,48 +10433,6 @@ function projectDiagnosticRoutingSnapshot(revision, state) {
     }))
   };
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isTimebackGrade(value) {
-  return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES.includes(value);
-}
-function isAssessmentSessionTiming(value) {
-  return isObject(value) && typeof value.runId === "string" && isValidUUID(value.runId) && typeof value.resumeId === "string" && isValidUUID(value.resumeId) && isNonNegativeDuration(value.activeSeconds) && (value.inactiveSeconds === undefined || isNonNegativeDuration(value.inactiveSeconds));
-}
-function isNonNegativeDuration(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function isAssessmentPurpose(value) {
-  return ASSESSMENT_PURPOSES.includes(value);
-}
-function isAssessmentResponseValue(value) {
-  const entries = Array.isArray(value) ? value : [value];
-  return entries.length > 0 && entries.every((entry) => typeof entry === "string" && entry.length > 0 && entry.length <= TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH);
-}
-function applyAssessmentItemResponseUpdate(current, update) {
-  const next = { ...current };
-  for (const [responseId, value] of Object.entries(update)) {
-    if (value === null) {
-      delete next[responseId];
-    } else {
-      next[responseId] = value;
-    }
-  }
-  return Object.keys(next).length === 0 ? undefined : next;
-}
-function applyAssessmentResponseUpdate(current, update) {
-  const next = structuredClone(current);
-  for (const [questionId, questionUpdate] of Object.entries(update)) {
-    const questionResponses = applyAssessmentItemResponseUpdate(next[questionId], questionUpdate);
-    if (questionResponses === undefined) {
-      delete next[questionId];
-    } else {
-      next[questionId] = questionResponses;
-    }
-  }
-  return next;
-}
 function assessmentResponseUpdateValidationMessage(assessment, update) {
   const items = new Map(assessment.items.map((item) => [item.identifier, item]));
   for (const [itemIdentifier, itemUpdate] of Object.entries(update)) {
@@ -10617,158 +10594,163 @@ function interactionResponseValidationMessage(itemIdentifier, interaction, respo
   }
   return null;
 }
-function invalidResponse(message) {
-  return { code: "INVALID_RESPONSE", message };
-}
-function administeredItemIdentifiers(itemSubmissions) {
-  return new Set(itemSubmissions.map((submission) => submission.itemIdentifier));
-}
-function itemAdministration(itemSubmissions, itemIdentifier) {
-  return itemSubmissions.find((submission) => submission.itemIdentifier === itemIdentifier);
-}
-function responseValuesEqual(left, right) {
-  if (left === undefined || right === undefined) {
-    return left === right;
-  }
-  if (Array.isArray(left) || Array.isArray(right)) {
-    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => value === right[index]);
-  }
-  return left === right;
-}
-function itemResponsesEqual(left, right) {
-  const leftEntries = Object.entries(left ?? {});
-  const rightEntries = Object.entries(right ?? {});
-  return leftEntries.length === rightEntries.length && leftEntries.every(([identifier, value]) => responseValuesEqual(value, right?.[identifier]));
+function emptyAssessmentTranscript(attemptId, contentRevision) {
+  return { version: 1, attemptId, contentRevision, administrations: [] };
 }
-function itemResponseUpdateMatches(current, update) {
-  return itemResponsesEqual(current, applyAssessmentItemResponseUpdate(current, update));
-}
-function resolveAssessmentItemReplay(state, input) {
-  const flow = assessmentFlowForPurpose(state.purpose);
-  if (flow !== "item-submit") {
+function assessmentProgressAdministration(purpose, input) {
+  if (purpose !== "mastery") {
     return {
-      action: "conflict",
-      failure: assessmentFlowViolation("Items cannot be submitted individually in this flow.", { flow })
+      ok: false,
+      failure: assessmentFlowViolation("Background progress is only available for mastery.")
     };
   }
-  const priorSubmission = state.itemSubmissions.find((submission) => submission.submissionId === input.submissionId);
-  if (priorSubmission) {
-    const sameRequest = priorSubmission.itemIdentifier === input.itemIdentifier && itemResponseUpdateMatches(state.responses[input.itemIdentifier], input.responses);
-    if (!sameRequest) {
-      return {
-        action: "conflict",
-        failure: assessmentFlowViolation("This item submission ID was already used for a different request.", {
-          submissionId: input.submissionId,
-          itemIdentifier: input.itemIdentifier,
-          committedItemIdentifier: priorSubmission.itemIdentifier,
-          flow
-        })
-      };
-    }
+  const { administrations } = input.transcript;
+  if (input.expectedResponseVersion !== administrations.length) {
     return {
-      action: "replay",
-      responseVersion: state.responseVersion,
-      responses: state.responses,
-      submission: priorSubmission
+      ok: false,
+      failure: assessmentResponseVersionConflict(input.expectedResponseVersion, administrations.length)
     };
   }
-  return { action: "missing" };
+  const administration = administrations.find((entry) => entry.itemIdentifier === input.itemIdentifier);
+  return administration ? { ok: true, submissionId: administration.submissionId } : {
+    ok: false,
+    failure: assessmentFlowViolation("The progress item must be present in the transcript.")
+  };
 }
-function prepareAssessmentItemSubmission(state, input) {
-  const replay = resolveAssessmentItemReplay(state, input);
-  if (replay.action === "conflict") {
-    return { action: "reject", failure: replay.failure };
-  }
-  if (replay.action === "replay") {
-    return replay;
-  }
-  if (state.responseVersion !== input.expectedResponseVersion) {
+function appendAssessmentAdministration(transcript, input) {
+  const entry = {
+    submissionId: input.submissionId,
+    itemIdentifier: input.itemIdentifier,
+    ...input.routingNodeKey === undefined ? {} : { routingNodeKey: input.routingNodeKey },
+    responses: Object.fromEntries(Object.entries(input.responses).filter((pair) => pair[1] !== null))
+  };
+  const priorIndex = transcript.administrations.findIndex((item) => item.submissionId === input.submissionId);
+  const index = priorIndex === -1 ? transcript.administrations.length : priorIndex;
+  if (input.expectedResponseVersion !== index) {
     return {
-      action: "reject",
-      failure: assessmentResponseVersionConflict(input.expectedResponseVersion, state.responseVersion)
+      ok: false,
+      failure: assessmentResponseVersionConflict(input.expectedResponseVersion, index)
     };
   }
-  const itemIndex = state.assessment.items.findIndex((item) => item.identifier === input.itemIdentifier);
-  const previousItemIdentifier = state.itemSubmissions.at(-1)?.itemIdentifier;
-  const previousItemIndex = state.assessment.items.findIndex((item) => item.identifier === previousItemIdentifier);
-  if (itemIndex === -1 || itemIndex <= previousItemIndex) {
+  if (priorIndex !== -1 && canonicalJson(transcript.administrations[priorIndex]) !== canonicalJson(entry)) {
     return {
-      action: "reject",
-      failure: assessmentFlowViolation("Items must be submitted once and in candidate order.", {
-        itemIdentifier: input.itemIdentifier,
-        previousItemIdentifier: previousItemIdentifier ?? null,
-        flow: assessmentFlowForPurpose(state.purpose)
-      })
+      ok: false,
+      failure: assessmentFlowViolation("This administration identity was reused with different answers.")
     };
   }
-  const update = { [input.itemIdentifier]: input.responses };
-  const updateMessage = assessmentResponseUpdateValidationMessage(state.assessment, update);
-  if (updateMessage) {
-    return { action: "reject", failure: invalidResponse(updateMessage) };
-  }
-  const responses = applyAssessmentResponseUpdate(state.responses, update);
-  const validationMessage = assessmentResponseValidationMessage(state.assessment, responses);
-  if (validationMessage) {
-    return { action: "reject", failure: invalidResponse(validationMessage) };
-  }
   return {
-    action: "commit",
-    itemIndex,
-    responseVersion: state.responseVersion + 1,
-    responses,
-    answered: Object.keys(responses[input.itemIdentifier] ?? {}).length > 0
+    ok: true,
+    index,
+    transcript: priorIndex === -1 ? { ...transcript, administrations: [...transcript.administrations, entry] } : transcript
   };
 }
-function completeAssessmentItemSubmission(state, input, prepared, scoring, submittedAt) {
-  const submission = {
-    submissionId: input.submissionId,
-    itemIdentifier: input.itemIdentifier,
-    submittedAt,
-    responseVersion: prepared.responseVersion,
-    answered: prepared.answered,
-    score: scoring.score,
-    isCorrect: scoring.isCorrect,
-    ...scoring.grading ? { grading: scoring.grading } : {}
-  };
-  return {
-    responseVersion: prepared.responseVersion,
-    responses: prepared.responses,
-    itemSubmissions: [...state.itemSubmissions, submission],
-    submission
-  };
+function prepareAssessmentTranscript(input) {
+  const parsed = AssessmentTranscriptSchema.safeParse(input.transcript);
+  if (!parsed.success) {
+    throw new AssessmentTranscriptError("Invalid assessment transcript", 0, "INVALID_RESPONSE");
+  }
+  const transcript = parsed.data;
+  if (transcript.attemptId !== input.attemptId || transcript.contentRevision !== input.contentRevision) {
+    throw new AssessmentTranscriptError("Transcript does not belong to this attempt and revision");
+  }
+  const responses = {};
+  const submissions = new Set;
+  const items = new Set;
+  let previousItemIndex = -1;
+  for (const [index, entry] of transcript.administrations.entries()) {
+    const itemIndex = input.assessment.items.findIndex((item) => item.identifier === entry.itemIdentifier);
+    if (submissions.has(entry.submissionId) || items.has(entry.itemIdentifier)) {
+      throw new AssessmentTranscriptError("Transcript contains a repeated administration or item", index);
+    }
+    if (itemIndex === -1) {
+      throw new AssessmentTranscriptError("Transcript references an unknown assessment item", index, "INVALID_RESPONSE");
+    }
+    if (!input.routed && itemIndex <= previousItemIndex) {
+      throw new AssessmentTranscriptError("Transcript items must follow the selected candidate order", index);
+    }
+    if (input.routed !== (entry.routingNodeKey !== undefined)) {
+      throw new AssessmentTranscriptError("Transcript routing identity does not match the assessment flow", index);
+    }
+    const itemResponses = { [entry.itemIdentifier]: entry.responses };
+    const validate2 = input.routed || input.allowIncomplete ? assessmentDraftResponseValidationMessage : assessmentResponseValidationMessage;
+    const invalid = Object.keys(entry.responses).length === 0 ? null : validate2(input.assessment, itemResponses);
+    if (invalid) {
+      throw new AssessmentTranscriptError(invalid, index, "INVALID_RESPONSE");
+    }
+    submissions.add(entry.submissionId);
+    items.add(entry.itemIdentifier);
+    previousItemIndex = itemIndex;
+    Object.assign(responses, itemResponses);
+  }
+  return { transcript, responses };
+}
+function completeAssessmentTranscript(input) {
+  const itemSubmissions = [];
+  let state;
+  const ledger = [];
+  if (input.manifest) {
+    const initial = initializeDiagnosticRouting(input.manifest);
+    if (!initial.ok) {
+      throw new AssessmentTranscriptError("The pinned diagnostic routing manifest is invalid");
+    }
+    state = initial.state;
+  }
+  const scores = new Map(input.scores.map((score) => [score.itemIdentifier, score]));
+  for (const [index, entry] of input.transcript.administrations.entries()) {
+    const scoring = scores.get(entry.itemIdentifier);
+    if (!scoring) {
+      throw new AssessmentTranscriptError("Transcript item has no trusted grade", index);
+    }
+    if (input.manifest) {
+      if (typeof scoring.isCorrect !== "boolean" || !entry.routingNodeKey) {
+        throw new AssessmentTranscriptError("Diagnostic grading must be determinate", index);
+      }
+      const advanced = advanceDiagnosticRouting(input.manifest, ledger, {
+        routingNodeKey: entry.routingNodeKey,
+        itemIdentifier: entry.itemIdentifier,
+        isCorrect: scoring.isCorrect
+      });
+      if (!advanced.ok) {
+        throw new AssessmentTranscriptError("Transcript does not follow the pinned diagnostic route", index);
+      }
+      ledger.push(advanced.ledgerEntry);
+      state = advanced.state;
+    }
+    itemSubmissions.push({
+      submissionId: entry.submissionId,
+      itemIdentifier: entry.itemIdentifier,
+      responseVersion: index + 1,
+      submittedAt: input.submittedAt,
+      answered: Object.keys(entry.responses).length > 0,
+      score: scoring.score,
+      isCorrect: scoring.isCorrect,
+      ...scoring.grading ? { grading: scoring.grading } : {}
+    });
+  }
+  if (input.terminal) {
+    const count = itemSubmissions.length;
+    const conventionalComplete = assessmentFlowForPurpose(input.purpose) === "item-submit" ? count > 0 : count === input.itemCount;
+    const complete = state ? state.status === "ready-to-complete" && count > 0 : conventionalComplete;
+    if (!complete) {
+      throw new AssessmentTranscriptError("A complete administered transcript is required for submission", count);
+    }
+  }
+  return { itemSubmissions, ledger, state };
 }
-function assessmentResponseUpdateFlowFailure(purpose, itemSubmissions, update) {
-  const administered = administeredItemIdentifiers(itemSubmissions);
-  const committedUpdate = Object.keys(update).find((identifier) => administered.has(identifier));
-  return committedUpdate ? assessmentFlowViolation("A submitted item response cannot be edited.", {
-    itemIdentifier: committedUpdate,
-    flow: assessmentFlowForPurpose(purpose)
-  }) : null;
+function administeredItemIdentifiers(itemSubmissions) {
+  return new Set(itemSubmissions.map((submission) => submission.itemIdentifier));
 }
-function assessmentCompletionFlowFailure(purpose, itemSubmissions, itemCount) {
-  const flow = assessmentFlowForPurpose(purpose);
-  if (flow !== "item-submit") {
-    return null;
-  }
-  if (itemSubmissions.length > 0 && itemSubmissions.length <= itemCount) {
-    return null;
-  }
-  return assessmentFlowViolation("At least one candidate must be administered before the review can be completed.", {
-    flow,
-    submittedItemCount: itemSubmissions.length,
-    itemCount
-  });
+function itemAdministration(itemSubmissions, itemIdentifier) {
+  return itemSubmissions.find((submission) => submission.itemIdentifier === itemIdentifier);
 }
 function selectAssessmentCourseCandidate(candidates, subjectSpecified) {
   if (candidates.length === 0) {
     return { outcome: "none" };
   }
-  const serviceable = candidates.filter((candidate) => candidate.hasLiveTests || candidate.hasOpenAttempt);
-  if (serviceable.length === 0) {
+  const eligible = candidates.filter((candidate) => candidate.hasLiveTests);
+  if (eligible.length === 0) {
     return { outcome: "no_eligible_tests" };
   }
-  const withOpenAttempt = serviceable.filter((candidate) => candidate.hasOpenAttempt);
-  const eligible = withOpenAttempt.length > 0 ? withOpenAttempt : serviceable;
   const subjects = new Set(eligible.map((candidate) => candidate.subject)).size;
   if (!subjectSpecified && subjects > 1) {
     return { outcome: "ambiguous", subjects };
@@ -10780,12 +10762,9 @@ function assessmentAttemptTimestamp(value) {
   const parsed = Date.parse(value);
   return Number.isNaN(parsed) ? 0 : parsed;
 }
-function newestAttempt(left, right, field) {
-  const dateDifference = assessmentAttemptTimestamp(right[field]) - assessmentAttemptTimestamp(left[field]);
-  return dateDifference || left.attemptId.localeCompare(right.attemptId);
-}
 function compareNewestCompletedAssessmentAttempt(left, right) {
-  return newestAttempt(left, right, "scoreDate");
+  const dateDifference = assessmentAttemptTimestamp(right.scoreDate) - assessmentAttemptTimestamp(left.scoreDate);
+  return dateDifference || left.attemptId.localeCompare(right.attemptId);
 }
 function compareAssessmentCatalogOrder(left, right) {
   if (left.assessmentKey !== null && right.assessmentKey !== null) {
@@ -10808,31 +10787,22 @@ function orderRuntimeAssessmentTests(tests) {
   return [...tests].toSorted(compareAssessmentCatalogOrder);
 }
 function selectRuntimeAssessment(liveTests, attempts) {
-  const resumable = attempts.filter((attempt) => attempt.resumable !== false && (isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt))).toSorted((left, right) => newestAttempt(left, right, "updatedAt"));
-  if (resumable.length > 0) {
-    return {
-      kind: "resume",
-      attempt: resumable[0],
-      additionalResumableAttemptIds: resumable.slice(1).map((candidate) => candidate.attemptId)
-    };
-  }
   const orderedTests = orderRuntimeAssessmentTests(liveTests);
   if (orderedTests.length === 0) {
     return null;
   }
-  const completed = attempts.filter(isAssessmentAttemptCompleted);
-  const exposedAssessmentKeys = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedAssessmentKey));
+  const history = attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt) || isAssessmentAttemptCompleted(attempt) || isAssessmentAttemptSuperseded(attempt));
+  const exposedAssessmentKeys = new Set(history.map((attempt) => attempt.selectedAssessmentKey));
   const unattempted = orderedTests.find((test) => !exposedAssessmentKeys.has(test.assessmentKey));
   if (unattempted) {
-    return { kind: "start", test: unattempted, reason: "unattempted" };
+    return { test: unattempted, reason: "unattempted" };
   }
-  const latestCompleted = completed.toSorted(compareNewestCompletedAssessmentAttempt)[0];
-  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.assessmentKey === latestCompleted.selectedAssessmentKey) : -1;
+  const latest = history.toSorted(compareNewestCompletedAssessmentAttempt)[0];
+  const latestTestIndex = latest ? orderedTests.findIndex((test) => test.assessmentKey === latest.selectedAssessmentKey) : -1;
   if (latestTestIndex === -1) {
-    return { kind: "start", test: orderedTests[0], reason: "first_live" };
+    return { test: orderedTests[0], reason: "first_live" };
   }
   return {
-    kind: "start",
     test: orderedTests[(latestTestIndex + 1) % orderedTests.length],
     reason: "round_robin"
   };
@@ -11090,9 +11060,6 @@ function reviewRequestFingerprint(request, policy) {
 function reviewQuestionLineItemId(parentLineItemId, itemIdentifier) {
   return deterministicUUID(["playcademy:review-question-line-item:v1", parentLineItemId, itemIdentifier].join("\x00"));
 }
-function reviewQuestionResultId(parentAttemptId, childQuestionLineItemId) {
-  return deterministicUUID(["playcademy:review-question-result:v1", parentAttemptId, childQuestionLineItemId].join("\x00"));
-}
 function qtiQuestionByIdentifier(questions) {
   const byIdentifier = new Map;
   for (const entry of questions.questions) {
@@ -11652,11 +11619,8 @@ function isDiagnosticRoutingState(value) {
   const nextValid = value.next === null || isRecord(value.next) && isNonEmptyString(value.next.stageKey) && isNonEmptyString(value.next.trackKey) && isNonEmptyString(value.next.nodeKey) && isNonEmptyString(value.next.itemIdentifier);
   return stagesValid && tracksValid && nextValid && (value.status === "in-progress" && value.next !== null || value.status === "ready-to-complete" && value.next === null);
 }
-function isDiagnosticRoutingSnapshot(value, revision) {
-  return isRecord(value) && value.kind === "platform-routed-diagnostic" && value.revision === revision && (value.status === "in-progress" || value.status === "ready-to-complete") && (value.next === null || isRecord(value.next) && isNonEmptyString(value.next.stageKey) && isNonEmptyString(value.next.trackKey) && isNonEmptyString(value.next.nodeKey) && isNonEmptyString(value.next.itemIdentifier)) && Array.isArray(value.tracks) && value.tracks.every((track) => isRecord(track) && isNonEmptyString(track.trackKey) && (track.groupKey === undefined || isNonEmptyString(track.groupKey)) && ["pending", "active", "completed", "skipped"].includes(String(track.status)) && Number.isInteger(track.administeredCount) && Number(track.administeredCount) >= 0);
-}
 function isRoutedDiagnosticAttemptMetadata(value, itemSubmissions, responseVersion) {
-  if (!isRecord(value) || !isNonEmptyString(value.definitionId) || !isNonEmptyString(value.diagnosticKey) || !isNonEmptyString(value.testName) || !isNonEmptyString(value.routingRevision) || !Array.isArray(value.ledger) || !value.ledger.every(isDiagnosticRoutingLedgerEntry) || value.routingSnapshots !== undefined && (!Array.isArray(value.routingSnapshots) || value.routingSnapshots.length !== value.ledger.length || !value.routingSnapshots.every((snapshot) => isDiagnosticRoutingSnapshot(snapshot, String(value.routingRevision)))) || !isDiagnosticRoutingState(value.state) || value.ledger.length !== itemSubmissions.length || responseVersion !== itemSubmissions.length) {
+  if (!isRecord(value) || !isNonEmptyString(value.definitionId) || !isNonEmptyString(value.diagnosticKey) || !isNonEmptyString(value.testName) || !isNonEmptyString(value.routingRevision) || !Array.isArray(value.ledger) || !value.ledger.every(isDiagnosticRoutingLedgerEntry) || !isDiagnosticRoutingState(value.state) || value.ledger.length !== itemSubmissions.length || responseVersion !== itemSubmissions.length) {
     return false;
   }
   const itemIdentifiers = new Set;
@@ -11710,19 +11674,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") && 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)) {
-    return false;
-  }
-  return value.version === 1 && typeof value.parentAttemptId === "string" && typeof value.activityId === "string" && typeof value.integrationId === "string" && typeof value.enrollmentId === "string" && typeof value.bankRevision === "string" && typeof value.itemIdentifier === "string" && isAssessmentStandardRef(value.standard) && typeof value.deliveredAt === "string" && Number.isInteger(value.responseVersion) && Object.values(value.responses).every(isAssessmentResponseValue) && (value.submissionId === undefined || typeof value.submissionId === "string") && (value.isCorrect === undefined || value.isCorrect === null || typeof value.isCorrect === "boolean");
-}
-function isPlaycademyDiagnosticAssessmentItemResultMetadataV1(value) {
-  if (!isRecord(value) || !isRecord(value.responses)) {
-    return false;
-  }
-  return value.version === 1 && isNonEmptyString(value.parentAttemptId) && isNonEmptyString(value.activityId) && isNonEmptyString(value.integrationId) && isNonEmptyString(value.enrollmentId) && isNonEmptyString(value.definitionId) && isNonEmptyString(value.diagnosticKey) && isNonEmptyString(value.routingRevision) && isNonEmptyString(value.contentRevision) && isNonEmptyString(value.stageKey) && isNonEmptyString(value.trackKey) && isNonEmptyString(value.routingNodeKey) && isNonEmptyString(value.itemIdentifier) && isNonEmptyString(value.deliveredAt) && Number.isInteger(value.responseVersion) && Number(value.responseVersion) > 0 && Object.values(value.responses).every(isAssessmentResponseValue) && isNonEmptyString(value.submissionId) && typeof value.isCorrect === "boolean";
+  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)) && (metadata2.transcript === undefined || AssessmentTranscriptSchema.safeParse(metadata2.transcript).success) && isCompletionMetadata(metadata2.completion, metadata2.purpose, routedDiagnostic);
 }
 function playcademyAssessmentResultMetadata(value) {
   if (!isRecord(value)) {
@@ -11742,12 +11694,6 @@ function playcademyAssessmentResultMetadata(value) {
       diagnostic: { ...normalized.diagnostic, ledger: [] }
     };
   }
-  if (isRecord(normalized.diagnostic) && Array.isArray(normalized.diagnostic.ledger) && normalized.diagnostic.ledger.length === 0 && normalized.diagnostic.routingSnapshots === undefined) {
-    normalized = {
-      ...normalized,
-      diagnostic: { ...normalized.diagnostic, routingSnapshots: [] }
-    };
-  }
   if (isRecord(normalized.diagnostic) && isRecord(normalized.diagnostic.state)) {
     const state = normalized.diagnostic.state;
     const tracks = Array.isArray(state.tracks) ? state.tracks.map((track) => isRecord(track) ? {
@@ -11755,12 +11701,10 @@ function playcademyAssessmentResultMetadata(value) {
       currentNodeKey: track.currentNodeKey ?? null,
       terminal: track.terminal ?? null
     } : track) : state.tracks;
-    const routingSnapshots = Array.isArray(normalized.diagnostic.routingSnapshots) ? normalized.diagnostic.routingSnapshots.map((snapshot) => isRecord(snapshot) ? { ...snapshot, next: snapshot.next ?? null } : snapshot) : normalized.diagnostic.routingSnapshots;
     normalized = {
       ...normalized,
       diagnostic: {
         ...normalized.diagnostic,
-        ...routingSnapshots === undefined ? {} : { routingSnapshots },
         state: {
           ...state,
           ...tracks === undefined ? {} : { tracks },
@@ -11770,6 +11714,16 @@ function playcademyAssessmentResultMetadata(value) {
     };
   }
   const review = normalized.review;
+  if (isRecord(normalized.transcript)) {
+    const transcript = normalized.transcript;
+    normalized = {
+      ...normalized,
+      transcript: {
+        ...transcript,
+        administrations: Array.isArray(transcript.administrations) ? transcript.administrations.map((entry) => isRecord(entry) ? { ...entry, responses: entry.responses ?? {} } : entry) : transcript.administrations ?? []
+      }
+    };
+  }
   if (isRecord(review) && isRecord(review.fulfillment) && review.fulfillment.status === "complete" && review.fulfillment.shortages === undefined) {
     normalized = {
       ...normalized,
@@ -11784,29 +11738,7 @@ function playcademyAssessmentResultMetadata(value) {
   }
   return isPlaycademyAssessmentResultMetadataV1(normalized) ? normalized : null;
 }
-function playcademyAssessmentItemResultMetadata(value) {
-  if (!isRecord(value)) {
-    return null;
-  }
-  const metadata2 = value[PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY];
-  if (!isRecord(metadata2)) {
-    return null;
-  }
-  const normalized = metadata2.responses === undefined ? { ...metadata2, responses: {} } : metadata2;
-  return isPlaycademyReviewAssessmentItemResultMetadataV1(normalized) ? normalized : null;
-}
-function playcademyDiagnosticAssessmentItemResultMetadata(value) {
-  if (!isRecord(value)) {
-    return null;
-  }
-  const metadata2 = value[PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY];
-  if (!isRecord(metadata2)) {
-    return null;
-  }
-  const normalized = metadata2.responses === undefined ? { ...metadata2, responses: {} } : metadata2;
-  return isPlaycademyDiagnosticAssessmentItemResultMetadataV1(normalized) ? normalized : null;
-}
-var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, PRIVATE_PLAYABLE_KEYS, trimmedNonEmptyString, finiteNumber2, positiveFiniteNumber, IDENTIFIER_VALUE, DIRECTED_PAIR_VALUE, scoringMatchComparisonSchema, scoringNumericEqualComparisonSchema, scoringNumericEqualRoundedComparisonSchema, scoringRuleSchema, scoringRulesSchema, scoringItemSchema, assessmentScoringArtifactItemsSchema, assessmentScoringArtifactSchema, SUPPORTED_BASE_TYPES, SUPPORTED_CARDINALITIES, MATCH_CORRECT_TEMPLATES, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_ATTEMPT_AWAITING_AWARD, ASSESSMENT_ATTEMPT_SUPERSEDED, ASSESSMENT_RUNTIME_ERROR_STATUS, ROUTING_KEY_MAX_LENGTH = 128, ROUTING_RESULT_KEY_MAX_LENGTH = 256, ROUTING_STAGE_LIMIT = 32, ROUTING_TRACK_LIMIT = 128, ROUTING_NODE_LIMIT = 1000, ROUTING_TERMINAL_LIMIT = 1000, ROUTING_GROUP_LIMIT = 128, ROUTING_PREDICATE_DEPTH_LIMIT = 8, ROUTING_EXPLORATION_STATE_LIMIT = 200000, RoutingKeySchema, RoutingResultKeySchema, DiagnosticTrackOutcomeSchema, DiagnosticActivationPredicateSchema, DiagnosticRoutingTransitionSchema, DiagnosticRoutingManifestV1Schema, GRADE_VALUES, POINT_RESPONSE_PATTERN, ZERO_WIDTH_CHARACTERS, CURLY_SINGLE_QUOTES, CURLY_DOUBLE_QUOTES, UNICODE_DASHES, ARITHMETIC_OPERATOR_SPACING, THOUSANDS_GROUP, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank", PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1, DEFAULT_REVIEW_SELECTION_POLICY, ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 8, ASSESSMENT_CHILD_RESULT_KIND = "assessment-child-result", ASSESSMENT_CHILD_RESULT_VERSION = 1, ASSESSMENT_CHILD_RESULT_ID_NAMESPACE = "playcademy:assessment-child-result:v1", IdentitySchema, RecordedAtSchema, ResponseKeySchema, AssessmentResponseValueSchema, AssessmentScoreSchema, AssessmentStandardRefSchema, DiagnosticRoutingLedgerEntryV1Schema, AssessmentChildResultAttemptV1Schema, AssessmentChildResultAdministrationV1Schema, AssessmentChildResultGradingV1Schema, ReviewChildResultContextV1Schema, DiagnosticChildResultContextV1Schema, CommonPayloadShape, ReviewChildResultPayloadV1Schema, DiagnosticChildResultPayloadV1Schema, AssessmentChildResultPayloadV1Schema, AssessmentChildResultCommandV1Schema, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema2, AssessmentRuntimeIdentitySchema, ResponseKeySchema2, StartAssessmentBaseSchema, AssessmentStandardRefSchema2, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, AssessmentPreparationReceiptSchema, StartAssessmentRequestBodySchema, SaveAssessmentBodySchema, SubmitAssessmentItemBodySchema, SubmitAssessmentBodySchema, FinalizeAssessmentBodySchema, PrepareRuntimeAssessmentRequestSchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, SubmitAssessmentItemRuntimeRequestSchema, SubmitRuntimeAssessmentRequestSchema, FinalizeRuntimeAssessmentRequestSchema;
+var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, PRIVATE_PLAYABLE_KEYS, trimmedNonEmptyString, finiteNumber2, positiveFiniteNumber, IDENTIFIER_VALUE, DIRECTED_PAIR_VALUE, scoringMatchComparisonSchema, scoringNumericEqualComparisonSchema, scoringNumericEqualRoundedComparisonSchema, scoringRuleSchema, scoringRulesSchema, scoringItemSchema, assessmentScoringArtifactItemsSchema, assessmentScoringArtifactSchema, SUPPORTED_BASE_TYPES, SUPPORTED_CARDINALITIES, MATCH_CORRECT_TEMPLATES, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_ATTEMPT_AWAITING_AWARD, ASSESSMENT_ATTEMPT_SUPERSEDED, ASSESSMENT_RUNTIME_ERROR_STATUS, GRADE_VALUES, ROUTING_KEY_MAX_LENGTH = 128, ROUTING_RESULT_KEY_MAX_LENGTH = 256, ROUTING_STAGE_LIMIT = 32, ROUTING_TRACK_LIMIT = 128, ROUTING_NODE_LIMIT = 1000, ROUTING_TERMINAL_LIMIT = 1000, ROUTING_GROUP_LIMIT = 128, ROUTING_PREDICATE_DEPTH_LIMIT = 8, ROUTING_EXPLORATION_STATE_LIMIT = 200000, RoutingKeySchema, RoutingResultKeySchema, DiagnosticTrackOutcomeSchema, DiagnosticActivationPredicateSchema, DiagnosticRoutingTransitionSchema, DiagnosticRoutingManifestV1Schema, POINT_RESPONSE_PATTERN, Identity, AssessmentTranscriptSchema, AssessmentTranscriptError, ZERO_WIDTH_CHARACTERS, CURLY_SINGLE_QUOTES, CURLY_DOUBLE_QUOTES, UNICODE_DASHES, ARITHMETIC_OPERATOR_SPACING, THOUSANDS_GROUP, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank", PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1, DEFAULT_REVIEW_SELECTION_POLICY, ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 8, ASSESSMENT_CHILD_RESULT_KIND = "assessment-child-result", ASSESSMENT_CHILD_RESULT_VERSION = 1, ASSESSMENT_CHILD_RESULT_ID_NAMESPACE = "playcademy:assessment-child-result:v1", IdentitySchema, RecordedAtSchema, ResponseKeySchema, AssessmentResponseValueSchema, AssessmentScoreSchema, AssessmentStandardRefSchema, DiagnosticRoutingLedgerEntryV1Schema, AssessmentChildResultAttemptV1Schema, AssessmentChildResultAdministrationV1Schema, AssessmentChildResultGradingV1Schema, ReviewChildResultContextV1Schema, FixedChildResultContextV1Schema, DiagnosticChildResultContextV1Schema, CommonPayloadShape, ReviewChildResultPayloadV1Schema, FixedChildResultPayloadV1Schema, DiagnosticChildResultPayloadV1Schema, AssessmentChildResultPayloadV1Schema, AssessmentChildResultCommandV1Schema, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema2, AssessmentRuntimeIdentitySchema, ResponseKeySchema2, StartAssessmentBaseSchema, AssessmentStandardRefSchema2, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, AssessmentPreparationReceiptSchema, StartAssessmentRequestBodySchema, SaveAssessmentBodySchema, RecordAssessmentProgressBodySchema, ResumeAssessmentBodySchema, ResumeRuntimeAssessmentRequestSchema, SubmitAssessmentItemBodySchema, SubmitAssessmentBodySchema, FinalizeAssessmentBodySchema, PrepareRuntimeAssessmentRequestSchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, RecordRuntimeAssessmentProgressRequestSchema, SubmitAssessmentItemRuntimeRequestSchema, SubmitRuntimeAssessmentRequestSchema, FinalizeRuntimeAssessmentRequestSchema;
 var init_assessment_runtime2 = __esm(() => {
   init_timeback3();
   init_timeback3();
@@ -11816,13 +11748,14 @@ var init_assessment_runtime2 = __esm(() => {
   init_timeback3();
   init_esm();
   init_esm();
+  init_src();
+  init_uuid();
+  init_esm();
   init_timeback4();
   init_src();
   init_timeback3();
   init_src();
   init_uuid();
-  init_src();
-  init_uuid();
   init_esm();
   init_src();
   init_uuid();
@@ -12118,6 +12051,7 @@ var init_assessment_runtime2 = __esm(() => {
     ATTEMPT_ALREADY_SUBMITTED: 409,
     ASSESSMENT_FLOW_VIOLATION: 409
   };
+  GRADE_VALUES = TIMEBACK_GRADES;
   RoutingKeySchema = exports_external.string().trim().min(1).max(ROUTING_KEY_MAX_LENGTH);
   RoutingResultKeySchema = exports_external.string().trim().min(1).max(ROUTING_RESULT_KEY_MAX_LENGTH);
   DiagnosticTrackOutcomeSchema = exports_external.enum(DIAGNOSTIC_TRACK_OUTCOMES);
@@ -12175,8 +12109,31 @@ var init_assessment_runtime2 = __esm(() => {
       resultKey: RoutingResultKeySchema
     }).strict()).min(1).max(ROUTING_TERMINAL_LIMIT)
   }).strict();
-  GRADE_VALUES = TIMEBACK_GRADES;
   POINT_RESPONSE_PATTERN = /^-?\d+(?:\.\d+)? -?\d+(?:\.\d+)?$/;
+  Identity = exports_external.string().min(1).max(512).refine((value) => value.trim() === value);
+  AssessmentTranscriptSchema = exports_external.object({
+    version: exports_external.literal(1),
+    attemptId: Identity,
+    contentRevision: Identity,
+    administrations: exports_external.array(exports_external.object({
+      submissionId: Identity,
+      itemIdentifier: Identity,
+      routingNodeKey: Identity.optional(),
+      responses: exports_external.record(Identity, exports_external.custom(isAssessmentResponseValue))
+    }).strict()).max(1000)
+  }).strict().refine((value) => new TextEncoder().encode(JSON.stringify(value)).length <= 256000, {
+    message: "Assessment transcript exceeds 256 KB"
+  });
+  AssessmentTranscriptError = class AssessmentTranscriptError extends Error {
+    index;
+    code;
+    constructor(message, index = 0, code = "ASSESSMENT_FLOW_VIOLATION") {
+      super(message);
+      this.name = "AssessmentTranscriptError";
+      this.index = index;
+      this.code = code;
+    }
+  };
   ZERO_WIDTH_CHARACTERS = /[\u200B\uFEFF\u200C\u200D]/g;
   CURLY_SINGLE_QUOTES = /[\u2018\u2019\u201A\u201B]/g;
   CURLY_DOUBLE_QUOTES = /[\u201C\u201D\u201E\u201F]/g;
@@ -12268,6 +12225,10 @@ var init_assessment_runtime2 = __esm(() => {
     bankRevision: IdentitySchema,
     standard: AssessmentStandardRefSchema
   }).strict();
+  FixedChildResultContextV1Schema = exports_external.object({
+    kind: exports_external.literal("fixed"),
+    purpose: exports_external.enum(["mastery", "end_of_course", "diagnostic"])
+  }).strict();
   DiagnosticChildResultContextV1Schema = exports_external.object({
     kind: exports_external.literal("platform-routed-diagnostic"),
     definitionId: IdentitySchema,
@@ -12287,6 +12248,11 @@ var init_assessment_runtime2 = __esm(() => {
     isCorrect: exports_external.boolean().optional(),
     context: ReviewChildResultContextV1Schema
   }).strict();
+  FixedChildResultPayloadV1Schema = exports_external.object({
+    ...CommonPayloadShape,
+    isCorrect: exports_external.boolean().optional(),
+    context: FixedChildResultContextV1Schema
+  }).strict();
   DiagnosticChildResultPayloadV1Schema = exports_external.object({
     ...CommonPayloadShape,
     isCorrect: exports_external.boolean(),
@@ -12302,7 +12268,8 @@ var init_assessment_runtime2 = __esm(() => {
   });
   AssessmentChildResultPayloadV1Schema = exports_external.union([
     ReviewChildResultPayloadV1Schema,
-    DiagnosticChildResultPayloadV1Schema
+    DiagnosticChildResultPayloadV1Schema,
+    FixedChildResultPayloadV1Schema
   ]);
   AssessmentChildResultCommandV1Schema = exports_external.object({
     kind: exports_external.literal(ASSESSMENT_CHILD_RESULT_KIND),
@@ -12379,9 +12346,19 @@ var init_assessment_runtime2 = __esm(() => {
   StartAssessmentRequestBodySchema = exports_external.intersection(StartAssessmentBodySchema, exports_external.object({ preparationReceipt: AssessmentPreparationReceiptSchema.optional() }));
   SaveAssessmentBodySchema = exports_external.object({
     expectedResponseVersion: exports_external.number().int().nonnegative(),
-    responses: exports_external.record(ResponseKeySchema2, exports_external.record(ResponseKeySchema2, AssessmentResponseValueSchema2.nullable()))
+    transcript: AssessmentTranscriptSchema
+  });
+  RecordAssessmentProgressBodySchema = SaveAssessmentBodySchema.extend({
+    assessmentToken: exports_external.string().min(1).max(32000),
+    itemIdentifier: ResponseKeySchema2
   });
+  ResumeAssessmentBodySchema = exports_external.object({
+    transcript: AssessmentTranscriptSchema.optional()
+  });
+  ResumeRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(ResumeAssessmentBodySchema.shape);
   SubmitAssessmentItemBodySchema = exports_external.object({
+    assessmentToken: exports_external.string().min(1).max(32000),
+    transcript: AssessmentTranscriptSchema,
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     submissionId: exports_external.string().trim().min(1),
     itemIdentifier: ResponseKeySchema2,
@@ -12389,6 +12366,7 @@ var init_assessment_runtime2 = __esm(() => {
     responses: exports_external.record(ResponseKeySchema2, AssessmentResponseValueSchema2.nullable())
   });
   SubmitAssessmentBodySchema = exports_external.object({
+    transcript: AssessmentTranscriptSchema,
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     submissionId: exports_external.string().trim().min(1),
     session: exports_external.custom(isAssessmentSessionTiming, {
@@ -12407,6 +12385,7 @@ var init_assessment_runtime2 = __esm(() => {
   PrepareRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentBodySchema);
   StartRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentRequestBodySchema);
   SaveRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SaveAssessmentBodySchema.shape);
+  RecordRuntimeAssessmentProgressRequestSchema = AssessmentRuntimeIdentitySchema.extend(RecordAssessmentProgressBodySchema.shape);
   SubmitAssessmentItemRuntimeRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentItemBodySchema.shape);
   SubmitRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentBodySchema.shape).extend({
     appName: exports_external.string().trim().min(1),
@@ -100206,22 +100185,6 @@ 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();
 }
@@ -100294,17 +100257,6 @@ var init_assessment_runtime_lock_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;
@@ -100370,7 +100322,7 @@ function buildConventionalAssessmentSnapshot(input) {
     ...input.activityData ? { activityData: input.activityData } : {},
     assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
     responses: metadata2.responses,
-    itemSubmissions: metadata2.itemSubmissions,
+    itemSubmissions: assessmentFlowForPurpose(metadata2.purpose) === "item-submit" ? metadata2.itemSubmissions : [],
     score: null,
     selection
   };
@@ -100385,13 +100337,6 @@ function buildAssessmentAwardRecord(input, mastery) {
     ...mastery.warnings ? { warnings: mastery.warnings } : {}
   };
 }
-function stageAssessmentAttemptSupersession(attempt) {
-  Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
-  Object.assign(attempt.selection, ASSESSMENT_ATTEMPT_SUPERSEDED);
-}
-function shouldConfirmAssessmentVersionUnavailable(details) {
-  return typeof details === "object" && details !== null && "expectedRevision" in details && typeof details.expectedRevision === "string" && !("currentRevision" in details);
-}
 function buildAssessmentAttemptSupersessionUpdate(result) {
   if (result.status !== "active" || !isAssessmentAttemptOpen({
     inProgress: result.inProgress ?? "",
@@ -100409,162 +100354,9 @@ function buildAssessmentAttemptSupersessionUpdate(result) {
     metadata: result.metadata ?? {}
   };
 }
-async function resolveAvailableAssessmentAttempt(initialDecision, select3, resume) {
-  let decision = initialDecision;
-  while (decision?.kind === "resume") {
-    const snapshot = await resume(decision);
-    if (snapshot !== null) {
-      return { kind: "resumed", snapshot };
-    }
-    decision = select3();
-  }
-  return { kind: "continue", decision };
-}
-function buildReviewItemResultMetadata(input) {
-  const administration = itemAdministration(input.metadata.itemSubmissions, input.selection.itemIdentifier);
-  if (!administration) {
-    throw new Error(`Cannot create a review result for unadministered candidate ${input.selection.itemIdentifier}`);
-  }
-  return {
-    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
-    parentAttemptId: input.parentAttemptId,
-    activityId: input.metadata.activityId,
-    integrationId: input.metadata.integrationId,
-    enrollmentId: input.metadata.enrollmentId,
-    bankRevision: input.metadata.review.bankRevision,
-    itemIdentifier: input.selection.itemIdentifier,
-    standard: input.selection.standard,
-    deliveredAt: administration.submittedAt,
-    responseVersion: input.responseVersion ?? input.metadata.responseVersion,
-    responses: input.metadata.responses[input.selection.itemIdentifier] ?? {},
-    ...input.submissionId ? { submissionId: input.submissionId } : {},
-    ...input.isCorrect === undefined ? {} : { isCorrect: input.isCorrect }
-  };
-}
-function buildOpenReviewChildResult(input) {
-  return {
-    status: "active",
-    assessmentLineItem: { sourcedId: input.childLineItemId },
-    student: input.student,
-    score: 0,
-    scoreDate: input.metadata.deliveredAt,
-    ...ASSESSMENT_ATTEMPT_OPEN,
-    metadata: {
-      [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: input.metadata
-    }
-  };
-}
 function diagnosticQuestionLineItemId(parentLineItemId, itemIdentifier) {
   return deterministicUUID(["playcademy:diagnostic-question-line-item:v1", parentLineItemId, itemIdentifier].join("\x00"));
 }
-function diagnosticQuestionResultId(parentAttemptId, childLineItemId) {
-  return deterministicUUID(["playcademy:diagnostic-question-result:v1", parentAttemptId, childLineItemId].join("\x00"));
-}
-function diagnosticAdministration(input) {
-  const ledgerIndex = input.metadata.diagnostic.ledger.findIndex((entry) => entry.routingNodeKey === input.ledgerEntry.routingNodeKey);
-  const persistedEntry = input.metadata.diagnostic.ledger[ledgerIndex];
-  const administration = input.metadata.itemSubmissions[ledgerIndex];
-  if (ledgerIndex === -1 || !persistedEntry || !administration || persistedEntry.stageKey !== input.ledgerEntry.stageKey || persistedEntry.trackKey !== input.ledgerEntry.trackKey || persistedEntry.itemIdentifier !== input.ledgerEntry.itemIdentifier || persistedEntry.isCorrect !== input.ledgerEntry.isCorrect || administration.itemIdentifier !== input.ledgerEntry.itemIdentifier || administration.isCorrect !== input.ledgerEntry.isCorrect) {
-    throw new Error(`Cannot create a diagnostic result for uncommitted routing node ${input.ledgerEntry.routingNodeKey}`);
-  }
-  return administration;
-}
-function buildDiagnosticItemResultMetadata(input) {
-  const administration = diagnosticAdministration(input);
-  return {
-    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
-    parentAttemptId: input.parentAttemptId,
-    activityId: input.metadata.activityId,
-    integrationId: input.metadata.integrationId,
-    enrollmentId: input.metadata.enrollmentId,
-    definitionId: input.metadata.diagnostic.definitionId,
-    diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-    routingRevision: input.metadata.diagnostic.routingRevision,
-    contentRevision: input.metadata.selectedTest.contentRevision,
-    stageKey: input.ledgerEntry.stageKey,
-    trackKey: input.ledgerEntry.trackKey,
-    routingNodeKey: input.ledgerEntry.routingNodeKey,
-    itemIdentifier: input.ledgerEntry.itemIdentifier,
-    deliveredAt: administration.submittedAt,
-    responseVersion: administration.responseVersion,
-    responses: input.metadata.responses[input.ledgerEntry.itemIdentifier] ?? {},
-    submissionId: administration.submissionId,
-    isCorrect: input.ledgerEntry.isCorrect
-  };
-}
-function resolveDiagnosticChildResult(input) {
-  if (!input.childResult) {
-    return { action: "create" };
-  }
-  const childMetadata = playcademyDiagnosticAssessmentItemResultMetadata(input.childResult.metadata);
-  const expectedMetadata = buildDiagnosticItemResultMetadata({
-    metadata: input.parentMetadata,
-    ledgerEntry: input.ledgerEntry,
-    parentAttemptId: input.parentResult.sourcedId
-  });
-  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || canonicalJson2(childMetadata) !== canonicalJson2(expectedMetadata)) {
-    return { action: "restore", reason: "incompatible" };
-  }
-  return input.childResult.status === "active" ? { action: "reuse", metadata: expectedMetadata } : { action: "restore", reason: "inactive" };
-}
-function buildFinalizedDiagnosticChildResult(input) {
-  const administration = diagnosticAdministration(input);
-  const metadata2 = buildDiagnosticItemResultMetadata(input);
-  return {
-    resultUpdate: {
-      status: "active",
-      assessmentLineItem: { sourcedId: input.childLineItemId },
-      student: input.student,
-      score: administration.score.earned,
-      scoreDate: administration.submittedAt,
-      ...ASSESSMENT_ATTEMPT_COMPLETED,
-      metadata: {
-        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
-      }
-    }
-  };
-}
-function buildFinalizedReviewChildResult(input) {
-  const metadata2 = buildReviewItemResultMetadata({
-    metadata: input.metadata,
-    selection: input.selection,
-    parentAttemptId: input.parentAttemptId,
-    submissionId: input.submissionId,
-    isCorrect: input.itemResult.isCorrect
-  });
-  return {
-    resultUpdate: {
-      status: "active",
-      assessmentLineItem: { sourcedId: input.childLineItemId },
-      student: input.student,
-      score: input.itemResult.score.earned,
-      scoreDate: input.timestamp,
-      ...ASSESSMENT_ATTEMPT_COMPLETED,
-      metadata: {
-        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
-      }
-    },
-    outcome: {
-      itemIdentifier: input.selection.itemIdentifier,
-      standard: input.selection.standard,
-      answered: Object.keys(input.metadata.responses[input.selection.itemIdentifier] ?? {}).length > 0,
-      score: input.itemResult.score,
-      isCorrect: input.itemResult.isCorrect
-    }
-  };
-}
-function resolveReviewChildResult(input) {
-  if (!input.childResult) {
-    return { action: "create" };
-  }
-  const childMetadata = playcademyAssessmentItemResultMetadata(input.childResult.metadata);
-  const expectedResponses = input.parentMetadata.responses[input.selection.itemIdentifier] ?? {};
-  const administration = itemAdministration(input.parentMetadata.itemSubmissions, input.selection.itemIdentifier);
-  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || childMetadata.parentAttemptId !== input.parentResult.sourcedId || childMetadata.activityId !== input.parentMetadata.activityId || childMetadata.integrationId !== input.parentMetadata.integrationId || childMetadata.enrollmentId !== input.parentMetadata.enrollmentId || childMetadata.bankRevision !== input.parentMetadata.review.bankRevision || childMetadata.itemIdentifier !== input.selection.itemIdentifier || childMetadata.standard.framework !== input.selection.standard.framework || childMetadata.standard.identifier !== input.selection.standard.identifier || childMetadata.deliveredAt !== administration?.submittedAt || childMetadata.responseVersion > input.parentMetadata.responseVersion || canonicalJson2(childMetadata.responses) !== canonicalJson2(expectedResponses)) {
-    return { action: "restore", reason: "incompatible" };
-  }
-  return input.childResult.status === "active" ? { action: "reuse", metadata: childMetadata } : { action: "restore", reason: "inactive" };
-}
 function buildAssessmentSubmitResult(input) {
   if (!input.metadata.score || !input.metadata.submissionId) {
     return null;
@@ -100950,32 +100742,12 @@ 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 itemResponses = responses[input.itemIdentifier];
-  validateAssessmentDraftResponses(assessment, itemResponses ? { [input.itemIdentifier]: itemResponses } : {});
-  return responses;
-}
 function validateAssessmentResponseUpdate(assessment, update2) {
   const message = assessmentResponseUpdateValidationMessage(assessment, update2);
   if (message) {
     throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
   }
 }
-function validateAssessmentResponses(assessment, responses) {
-  const message = assessmentResponseValidationMessage(assessment, responses);
-  if (message) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
-  }
-}
-function validateAssessmentDraftResponses(assessment, responses) {
-  const message = assessmentDraftResponseValidationMessage(assessment, responses);
-  if (message) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
-  }
-}
 function assessmentScoringRequests(assessment, responses) {
   return assessment.items.map((item) => ({
     itemIdentifier: item.identifier,
@@ -101015,6 +100787,21 @@ function assessmentScoreFromPercentage(percentage, possible) {
   const earned = Math.round(normalized * possible * 1e6) / 1e6;
   return { earned, possible, normalized };
 }
+function buildAssessmentResultCheckpoint(input) {
+  return {
+    status: input.result.status,
+    assessmentLineItem: input.result.assessmentLineItem,
+    student: input.result.student,
+    score: input.result.score ?? 0,
+    scoreDate: input.result.scoreDate,
+    ...ASSESSMENT_ATTEMPT_OPEN,
+    metadata: mergeAssessmentRuntimeMetadata(input.result.metadata, {
+      ...input.metadata,
+      transcript: input.transcript,
+      updatedAt: input.timestamp
+    })
+  };
+}
 function buildAssessmentResultSubmission(input) {
   const metadata2 = {
     ...input.metadata,
@@ -102419,6 +102206,183 @@ var init_timeback_assessment_artifacts_util = __esm(() => {
   init_timeback_review_mapping_util();
 });
 
+// ../api-core/src/utils/timeback-assessment-scoring.util.ts
+async function scoreCachedAssessmentItems(input) {
+  const selected = input.assessment.items.filter((item) => input.itemIdentifiers.has(item.identifier));
+  const keys = new Map(await Promise.all(selected.map(async (item) => [
+    item.identifier,
+    await sha256Hex(canonicalJson2({
+      identity: input.artifactIdentity,
+      purpose: input.purpose,
+      itemIdentifier: item.identifier,
+      responses: input.responses[item.identifier] ?? {},
+      strategy: input.artifact?.items.find((candidate) => candidate.itemIdentifier === item.identifier)?.strategy ?? "qti"
+    }))
+  ])));
+  const scored = new Map;
+  for (const item of selected) {
+    const cached3 = input.cache.get(keys.get(item.identifier));
+    if (cached3) {
+      scored.set(item.identifier, cached3);
+    }
+  }
+  const missing = new Set(selected.filter((item) => !scored.has(item.identifier)).map((item) => item.identifier));
+  const fresh = await scoreAssessmentItems({ ...input, itemIdentifiers: missing });
+  for (const result of fresh) {
+    input.cache.set(keys.get(result.itemIdentifier), result);
+    scored.set(result.itemIdentifier, result);
+  }
+  return selected.map((item) => scored.get(item.identifier));
+}
+async function scoreAssessmentItems({
+  assessment,
+  responses,
+  artifactIdentity,
+  purpose,
+  itemIdentifiers,
+  artifact,
+  processResponse,
+  onEvent
+}) {
+  const scoringItems = assessmentScoringRequests(assessment, responses).filter((item) => !itemIdentifiers || itemIdentifiers.has(item.itemIdentifier));
+  const artifactItems = new Map(artifact?.items.map((item) => [item.itemIdentifier, item]));
+  const scored = new Map;
+  const qti2 = [];
+  for (const item of scoringItems) {
+    const artifactItem = artifactItems.get(item.itemIdentifier);
+    let fallback2 = null;
+    if (!artifact) {
+      fallback2 = { reason: "artifact-unavailable" };
+    } else if (!artifactItem) {
+      fallback2 = { reason: "artifact-item-missing" };
+    } else if (artifactItem.strategy === "qti") {
+      fallback2 = { reason: "artifact-qti", artifactReason: artifactItem.reason };
+    } else {
+      const startedAt = Date.now();
+      try {
+        scored.set(item.itemIdentifier, {
+          ...scorePlatformAssessmentItem(artifactItem, responses[item.itemIdentifier]),
+          grading: PLATFORM_CHILD_GRADING
+        });
+        onEvent("assessment.item_scoring", {
+          "app.assessment.qti_item_identifier": item.itemIdentifier,
+          "app.assessment.purpose": purpose,
+          "app.assessment.artifact_identity_kind": artifactIdentity.kind,
+          "app.assessment.grading_source": "platform-artifact",
+          "app.assessment.grading_duration_ms": Date.now() - startedAt
+        });
+      } catch (error88) {
+        fallback2 = { reason: "platform-grader-error", error: error88 };
+      }
+    }
+    if (fallback2) {
+      qti2.push({ item, ...fallback2 });
+    }
+  }
+  if (qti2.length > 0) {
+    const fallbackTasks = qti2.flatMap(({ item, reason, artifactReason, error: graderError }) => {
+      const interactionResults = [];
+      let startedAt;
+      let completedInteractions = 0;
+      let failed = false;
+      const omittedResponseCount = item.requests.filter((request) => responses[item.itemIdentifier]?.[request.identifier] === undefined).length;
+      let qtiRemoteInteractionCount = 0;
+      let syntheticIncorrectInteractionCount = 0;
+      function fallbackEvent(outcome) {
+        onEvent("assessment.item_scoring_fallback", {
+          "app.assessment.qti_item_identifier": item.itemIdentifier,
+          "app.assessment.purpose": purpose,
+          "app.assessment.artifact_identity_kind": artifactIdentity.kind,
+          "app.assessment.grading_source": omittedResponseCount > 0 ? "platform-qti-adapter" : "timeback-qti",
+          "app.assessment.fallback_reason": reason,
+          "app.assessment.fallback_duration_ms": startedAt === undefined ? 0 : Date.now() - startedAt,
+          "app.assessment.qti_remote_interaction_count": qtiRemoteInteractionCount,
+          "app.assessment.synthetic_incorrect_interaction_count": syntheticIncorrectInteractionCount,
+          ...artifactReason ? { "app.assessment.artifact_fallback_reason": artifactReason } : {},
+          ...graderError ? {
+            "app.assessment.platform_grader_exception_type": errorType(graderError)
+          } : {},
+          ...outcome
+        });
+      }
+      function completeItem() {
+        const earned = assessmentItemEarnedScore(interactionResults.map((result) => Number.isFinite(result.score) ? result.score : 0), item.maxScore);
+        const possible = item.maxScore;
+        fallbackEvent({ "app.assessment.fallback_outcome": "succeeded" });
+        scored.set(item.itemIdentifier, {
+          itemIdentifier: item.itemIdentifier,
+          score: {
+            earned,
+            possible,
+            normalized: possible === 0 ? 0 : earned / possible
+          },
+          isCorrect: assessmentItemCorrectness(interactionResults.map((result) => result.isCorrect)),
+          grading: omittedResponseCount > 0 ? PLATFORM_QTI_ADAPTER_CHILD_GRADING : QTI_CHILD_GRADING
+        });
+      }
+      if (item.requests.length === 0) {
+        completeItem();
+        return [];
+      }
+      return item.requests.map((request, index2) => async () => {
+        startedAt ??= Date.now();
+        try {
+          const response = responses[item.itemIdentifier]?.[request.identifier];
+          if (response === undefined) {
+            syntheticIncorrectInteractionCount += 1;
+            interactionResults[index2] = { score: 0, isCorrect: false };
+          } else {
+            qtiRemoteInteractionCount += 1;
+            interactionResults[index2] = await processResponse(item.itemIdentifier, request);
+          }
+          completedInteractions += 1;
+          if (completedInteractions === item.requests.length && !failed) {
+            completeItem();
+          }
+        } catch (error88) {
+          if (!failed) {
+            failed = true;
+            fallbackEvent({
+              "app.assessment.fallback_outcome": "failed",
+              "exception.type": errorType(error88),
+              "app.error.message": errorMessage(error88)
+            });
+          }
+          throw error88;
+        }
+      });
+    });
+    await runWithConcurrency(fallbackTasks, SCORING_CONCURRENCY, (task) => task());
+  }
+  return scoringItems.map((item) => {
+    const result = scored.get(item.itemIdentifier);
+    if (!result) {
+      throw new Error(`Assessment item ${item.itemIdentifier} was not scored`);
+    }
+    return result;
+  });
+}
+var QTI_CHILD_GRADING, PLATFORM_QTI_ADAPTER_CHILD_GRADING, PLATFORM_CHILD_GRADING, SCORING_CONCURRENCY = 4;
+var init_timeback_assessment_scoring_util = __esm(() => {
+  init_assessment_runtime2();
+  init_assessment_artifact_envelope_util();
+  init_timeback_assessment_runtime_util();
+  QTI_CHILD_GRADING = {
+    source: "timeback-qti",
+    graderVersion: "timeback-qti-process-response-v1"
+  };
+  PLATFORM_QTI_ADAPTER_CHILD_GRADING = {
+    source: "platform-qti-adapter",
+    graderVersion: "platform-qti-adapter-v1",
+    qtiGraderVersion: "timeback-qti-process-response-v1"
+  };
+  PLATFORM_CHILD_GRADING = {
+    source: "platform-artifact",
+    artifactVersion: `assessment-artifact-v${ASSESSMENT_ARTIFACT_SCHEMA_VERSION}`,
+    graderVersion: `platform-grader-v${ASSESSMENT_GRADER_PROTOCOL_VERSION}`
+  };
+});
+
 // ../api-core/src/utils/timeback-assessment-child-result.util.ts
 async function buildSubmissionChildResultCommand(input) {
   const { submission, context: context2 } = input;
@@ -102434,12 +102398,9 @@ async function buildSubmissionChildResultCommand(input) {
     score: submission.score,
     grading: input.grading
   };
-  if (context2.kind === "review") {
-    return buildAssessmentChildResultCommand({
-      ...common2,
-      ...typeof isCorrect === "boolean" ? { isCorrect } : {},
-      context: context2
-    }, submission.submittedAt);
+  if (context2.kind !== "platform-routed-diagnostic") {
+    const payload = { ...common2, ...typeof isCorrect === "boolean" ? { isCorrect } : {} };
+    return context2.kind === "review" ? buildAssessmentChildResultCommand({ ...payload, context: context2 }, submission.submittedAt) : buildAssessmentChildResultCommand({ ...payload, context: context2 }, submission.submittedAt);
   }
   if (typeof isCorrect !== "boolean") {
     throw new Error("Diagnostic child results require determinate correctness");
@@ -102460,11 +102421,7 @@ function assessmentChildLineItemMetadataMatches(key, stored, expected) {
   if (!Array.isArray(storedStandards) || !Array.isArray(expectedStandards)) {
     return false;
   }
-  const sameDefinition = canonicalJson2(reviewDefinitionWithoutStandards(storedDefinition)) === canonicalJson2(reviewDefinitionWithoutStandards(expectedDefinition));
-  function contains(standards, candidate) {
-    return standards.some((standard) => canonicalJson2(standard) === canonicalJson2(candidate));
-  }
-  return sameDefinition && (expectedStandards.every((standard) => contains(storedStandards, standard)) || storedStandards.every((standard) => contains(expectedStandards, standard)));
+  return canonicalJson2(reviewDefinitionWithoutStandards(storedDefinition)) === canonicalJson2(reviewDefinitionWithoutStandards(expectedDefinition));
 }
 function assessmentChildLineItemMatches(stored, expected) {
   if (stored.status !== expected.status || stored.parentAssessmentLineItem?.sourcedId !== expected.parentAssessmentLineItem.sourcedId || stored.course?.sourcedId !== expected.course.sourcedId || stored.resultValueMin !== expected.resultValueMin || stored.resultValueMax !== expected.resultValueMax || typeof stored.metadata !== "object" || stored.metadata === null) {
@@ -102522,19 +102479,14 @@ async function classifyAssessmentChildResult(input) {
     result.scoreScale,
     result.scorePercentile,
     result.comment,
-    result.learningObjectiveSet,
-    result.incomplete,
-    result.late,
-    result.missing
+    result.learningObjectiveSet
   ];
-  if (auxiliaryFields.some((value) => value !== undefined && value !== null)) {
+  const flags2 = [result.incomplete, result.late, result.missing];
+  if (auxiliaryFields.some((value) => value !== undefined && value !== null) || flags2.some((value) => value !== undefined && value !== null && value !== "false")) {
     return { outcome: "conflict", reason: "auxiliary-field-mismatch" };
   }
   return { outcome: "replay" };
 }
-function hasApiStatus(error88, statusCode) {
-  return isApiError(error88) && error88.statusCode === statusCode;
-}
 async function persistAssessmentChildResult(input) {
   const { assessmentResults, childLineItemId } = input;
   const verification2 = await verifyAssessmentChildResultCommand(input.command);
@@ -102543,38 +102495,127 @@ async function persistAssessmentChildResult(input) {
   }
   const { command } = verification2;
   const resultId = await assessmentChildResultId(command.payload.attempt.attemptId, command.payload.administration.submissionId);
-  async function classifyOccupant() {
-    const resolution = await classifyAssessmentChildResult({
-      result: await assessmentResults.get(resultId),
+  await assessmentResults.upsert(resultId, buildAssessmentChildResultUpdate(command, childLineItemId));
+}
+function assessmentTranscriptChildLineItemId(context2, itemIdentifier) {
+  return context2.metadata.purpose === "review" ? reviewQuestionLineItemId(context2.parentLineItemId, itemIdentifier) : diagnosticQuestionLineItemId(context2.parentLineItemId, itemIdentifier);
+}
+async function reconcileAssessmentTranscriptChildren({
+  context: context2,
+  graded,
+  only,
+  assessmentResults,
+  ensureLineItems,
+  onPersisted
+}) {
+  const metadata2 = graded.metadata;
+  const assessmentKey = metadata2.selectedTest.assessmentKey;
+  if (!assessmentKey) {
+    throw new Error("Assessment context requires a selected assessment key");
+  }
+  const submissions = metadata2.itemSubmissions.filter((submission) => !only || only.has(submission.submissionId));
+  const administered = new Set(submissions.map((submission) => submission.itemIdentifier));
+  await ensureLineItems({
+    items: graded.assessment.items.filter((item) => administered.has(item.identifier))
+  });
+  await runWithConcurrency(submissions, 4, async (submission) => {
+    const index2 = submission.responseVersion - 1;
+    let flow;
+    if (metadata2.purpose === "review") {
+      const selection = metadata2.review.selections.find((item) => item.itemIdentifier === submission.itemIdentifier);
+      flow = {
+        kind: "review",
+        bankRevision: metadata2.review.bankRevision,
+        standard: selection.standard
+      };
+    } else if (metadata2.purpose === "diagnostic" && metadata2.diagnostic) {
+      flow = {
+        kind: "platform-routed-diagnostic",
+        definitionId: metadata2.diagnostic.definitionId,
+        diagnosticKey: metadata2.diagnostic.diagnosticKey,
+        routingRevision: metadata2.diagnostic.routingRevision,
+        transition: metadata2.diagnostic.ledger[index2]
+      };
+    } else {
+      flow = { kind: "fixed", purpose: metadata2.purpose };
+    }
+    const command = await buildSubmissionChildResultCommand({
+      attempt: {
+        attemptId: context2.attemptId,
+        gameId: context2.gameId,
+        studentId: context2.studentId,
+        activityId: metadata2.activityId,
+        courseId: metadata2.courseId,
+        integrationId: metadata2.integrationId,
+        enrollmentId: metadata2.enrollmentId,
+        selectedTest: { ...metadata2.selectedTest, assessmentKey }
+      },
+      submission,
+      responses: graded.transcript.administrations[index2].responses,
+      grading: submission.grading ?? QTI_CHILD_GRADING,
+      context: flow
+    });
+    await persistAssessmentChildResult({
+      assessmentResults,
       command,
-      childLineItemId
+      childLineItemId: await assessmentTranscriptChildLineItemId(context2, submission.itemIdentifier)
     });
-    return resolution.outcome === "replay" ? { outcome: "replay", resultId } : { outcome: "conflict", resultId, reason: resolution.reason };
+    onPersisted?.(submission.submissionId);
+  });
+}
+async function recoveredAssessmentAdministration(context2, result) {
+  const verified = await verifyAssessmentChildResultCommand(result.metadata);
+  if (!verified.ok) {
+    return null;
   }
-  try {
-    return await classifyOccupant();
-  } catch (error88) {
-    if (!hasApiStatus(error88, 404)) {
-      throw error88;
+  const { command } = verified;
+  const { attempt, administration, responses, context: flow } = command.payload;
+  if (attempt.attemptId !== context2.attemptId || attempt.gameId !== context2.gameId || attempt.studentId !== context2.studentId || attempt.integrationId !== context2.metadata.integrationId || attempt.enrollmentId !== context2.metadata.enrollmentId || attempt.courseId !== context2.metadata.courseId || attempt.activityId !== context2.metadata.activityId || canonicalJson2(attempt.selectedTest) !== canonicalJson2(context2.metadata.selectedTest) || result.sourcedId !== await assessmentChildResultId(context2.attemptId, administration.submissionId)) {
+    return null;
+  }
+  const disposition = await classifyAssessmentChildResult({
+    result,
+    command,
+    childLineItemId: await assessmentTranscriptChildLineItemId(context2, administration.itemIdentifier)
+  });
+  if (disposition.outcome !== "replay") {
+    return null;
+  }
+  return {
+    sequence: administration.responseVersion,
+    entry: {
+      submissionId: administration.submissionId,
+      itemIdentifier: administration.itemIdentifier,
+      responses,
+      ...flow.kind === "platform-routed-diagnostic" ? { routingNodeKey: flow.transition.routingNodeKey } : {}
+    }
+  };
+}
+async function recoverAssessmentTranscript(context2, results) {
+  const entries = new Map;
+  for (const result of results) {
+    const recovered = await recoveredAssessmentAdministration(context2, result);
+    if (recovered) {
+      const atPosition = entries.get(recovered.sequence) ?? new Map;
+      atPosition.set(recovered.entry.submissionId, recovered.entry);
+      entries.set(recovered.sequence, atPosition);
     }
   }
-  try {
-    await assessmentResults.create({
-      sourcedId: resultId,
-      ...buildAssessmentChildResultUpdate(command, childLineItemId)
-    });
-    return { outcome: "created", resultId };
-  } catch (error88) {
-    if (!hasApiStatus(error88, 409)) {
-      throw error88;
+  const transcript = emptyAssessmentTranscript(context2.attemptId, context2.metadata.selectedTest.contentRevision);
+  for (let sequence2 = 1;sequence2 <= entries.size; sequence2 += 1) {
+    const candidates = entries.get(sequence2);
+    if (!candidates || candidates.size !== 1) {
+      break;
     }
+    transcript.administrations.push(candidates.values().next().value);
   }
-  return classifyOccupant();
+  return transcript;
 }
-var init_timeback_assessment_child_result_util = __esm(async () => {
+var init_timeback_assessment_child_result_util = __esm(() => {
   init_src();
   init_assessment_runtime2();
-  await init_errors8();
+  init_timeback_assessment_runtime_util();
+  init_timeback_assessment_scoring_util();
 });
 
 // ../api-core/src/utils/timeback-assessment-preparation.util.ts
@@ -102613,21 +102654,6 @@ function assessmentPreparationFlightKey(input) {
 async function assessmentPreparationReceiptMatches(plan, request) {
   return plan.gameId === request.gameId && plan.studentId === request.studentId && plan.activityId === request.input.activityId && plan.purpose === request.input.purpose && plan.requestHash === await assessmentPreparationRequestHash(request.input);
 }
-function resolveAssessmentPreparationSelection(decision, candidateCourseCount) {
-  if (decision?.kind === "resume") {
-    return {
-      status: "blocked",
-      result: { status: "canonical_required", reason: "resumable_attempt" }
-    };
-  }
-  if (candidateCourseCount !== 1) {
-    return {
-      status: "blocked",
-      result: { status: "unprepared", reason: "prerequisite_unavailable" }
-    };
-  }
-  return decision ? { status: "ready", decision } : { status: "unavailable" };
-}
 function preparedAssessmentIntegration(plan, candidates) {
   if (candidates.rows.length !== 1) {
     return null;
@@ -102679,6 +102705,7 @@ function buildPreparedAssessmentMetadata(plan, timestamp6, testName) {
     version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
     activityId: plan.activityId,
     courseId: plan.courseId,
+    courseName: plan.courseName,
     integrationId: plan.integrationId,
     enrollmentId: plan.enrollmentId,
     selectedTest: plan.selectedTest,
@@ -102709,7 +102736,6 @@ function buildPreparedAssessmentMetadata(plan, timestamp6, testName) {
         testName,
         routingRevision: plan.diagnostic.routingRevision,
         ledger: [],
-        routingSnapshots: [],
         state: plan.diagnostic.initialState
       }
     };
@@ -103004,127 +103030,6 @@ var init_timeback_assessment_publication_util = __esm(() => {
   MANAGED_ASSET_URL = new RegExp(`https?://[^\\s"')]+/(${ASSESSMENT_ASSET_KEY_PREFIX}v1/sha256/[a-f0-9]{64}\\.[a-z0-9]+)`, "gi");
 });
 
-// ../api-core/src/utils/timeback-assessment-reconciliation.util.ts
-function assessmentChildProjectionIsTerminal(result) {
-  const state = { inProgress: result.inProgress ?? "", scoreStatus: result.scoreStatus };
-  return isAssessmentAttemptAwaitingAward(state) || isAssessmentAttemptCompleted(state);
-}
-async function reconcileReviewChildResults({
-  initial,
-  writeOpen,
-  crossBarrier,
-  readLatest,
-  restoreTerminal
-}) {
-  if (initial.metadata.purpose !== "review") {
-    throw new Error("A standards-review request selected a non-review attempt");
-  }
-  if (assessmentChildProjectionIsTerminal(initial.result)) {
-    const settled = { result: initial.result, metadata: initial.metadata };
-    await restoreTerminal(settled);
-    return settled;
-  }
-  await writeOpen();
-  await crossBarrier();
-  const current = await readLatest();
-  if (current.metadata.purpose !== "review") {
-    throw new Error("A standards-review request selected a non-review attempt");
-  }
-  const reviewed = { result: current.result, metadata: current.metadata };
-  if (assessmentChildProjectionIsTerminal(current.result)) {
-    await restoreTerminal(reviewed);
-  }
-  return reviewed;
-}
-var init_timeback_assessment_reconciliation_util = __esm(() => {
-  init_assessment_runtime2();
-});
-
-// ../api-core/src/utils/timeback-assessment-replay.util.ts
-function resolveDiagnosticItemReplay(metadata2, input) {
-  const priorIndex = metadata2.itemSubmissions.findIndex((submission) => submission.submissionId === input.submissionId);
-  if (priorIndex === -1) {
-    return { action: "missing" };
-  }
-  const prior = metadata2.itemSubmissions[priorIndex];
-  const ledgerEntry = metadata2.diagnostic.ledger[priorIndex];
-  if (!prior || !ledgerEntry || prior.itemIdentifier !== input.itemIdentifier || ledgerEntry.routingNodeKey !== input.routingNodeKey || !itemResponseUpdateMatches(metadata2.responses[input.itemIdentifier], input.responses)) {
-    return {
-      action: "conflict",
-      failure: assessmentFlowViolation("This diagnostic submission ID was already used for a different request.", {
-        submissionId: input.submissionId,
-        routingNodeKey: input.routingNodeKey,
-        itemIdentifier: input.itemIdentifier
-      })
-    };
-  }
-  return {
-    action: "replay",
-    submission: prior,
-    ledgerEntry,
-    priorIndex,
-    routing: metadata2.diagnostic.routingSnapshots?.[priorIndex]
-  };
-}
-function buildAssessmentItemReplayResult(attemptId, metadata2, submission) {
-  return {
-    attemptId,
-    responseVersion: metadata2.responseVersion,
-    status: "in_progress",
-    responses: metadata2.responses,
-    itemSubmissions: metadata2.itemSubmissions,
-    submission
-  };
-}
-function diagnosticReceipt(submission, ledgerEntry) {
-  return {
-    submissionId: submission.submissionId,
-    routingNodeKey: ledgerEntry.routingNodeKey,
-    itemIdentifier: submission.itemIdentifier,
-    submittedAt: submission.submittedAt,
-    responseVersion: submission.responseVersion,
-    answered: submission.answered,
-    score: submission.score,
-    isCorrect: ledgerEntry.isCorrect
-  };
-}
-function buildDiagnosticItemReplayResult(attemptId, submission, ledgerEntry, routing) {
-  return {
-    attemptId,
-    responseVersion: submission.responseVersion,
-    status: "in_progress",
-    routing,
-    submission: diagnosticReceipt(submission, ledgerEntry)
-  };
-}
-function requireAssessmentMutationAccess(attemptId, integrationStatus, enrollment) {
-  if (!enrollment || integrationStatus === "deactivated") {
-    throw AssessmentRuntimeError.from(assessmentAttemptUnauthorized(attemptId));
-  }
-  return enrollment;
-}
-function committedReviewItemResults(metadata2, assessment) {
-  const available = new Set(assessment.items.map((item) => item.identifier));
-  const seen = new Set;
-  return metadata2.itemSubmissions.map((submission) => {
-    if (!available.has(submission.itemIdentifier) || seen.has(submission.itemIdentifier)) {
-      throw AssessmentRuntimeError.from(assessmentFlowViolation("The persisted review item-submission ledger is corrupt.", {
-        itemIdentifier: submission.itemIdentifier
-      }));
-    }
-    seen.add(submission.itemIdentifier);
-    return {
-      itemIdentifier: submission.itemIdentifier,
-      score: submission.score,
-      isCorrect: submission.isCorrect
-    };
-  });
-}
-var init_timeback_assessment_replay_util = __esm(() => {
-  init_assessment_runtime2();
-  init_errors2();
-});
-
 // ../api-core/src/utils/timeback-assessment-routing.util.ts
 function diagnosticRoutingFallbackReason(artifact, routingRevision) {
   if (!artifact) {
@@ -103274,154 +103179,256 @@ var init_timeback_assessment_rules_util = __esm(() => {
   init_errors2();
 });
 
-// ../api-core/src/utils/timeback-assessment-scoring.util.ts
-async function scoreAssessmentItems({
-  assessment,
-  responses,
-  artifactIdentity,
-  purpose,
-  itemIdentifiers,
-  artifact,
-  processResponse,
-  onEvent
-}) {
-  const scoringItems = assessmentScoringRequests(assessment, responses).filter((item) => !itemIdentifiers || itemIdentifiers.has(item.itemIdentifier));
-  const artifactItems = new Map(artifact?.items.map((item) => [item.itemIdentifier, item]));
-  const scored = new Map;
-  const qti2 = [];
-  for (const item of scoringItems) {
-    const artifactItem = artifactItems.get(item.itemIdentifier);
-    let fallback2 = null;
-    if (!artifact) {
-      fallback2 = { reason: "artifact-unavailable" };
-    } else if (!artifactItem) {
-      fallback2 = { reason: "artifact-item-missing" };
-    } else if (artifactItem.strategy === "qti") {
-      fallback2 = { reason: "artifact-qti", artifactReason: artifactItem.reason };
-    } else {
-      const startedAt = Date.now();
-      try {
-        scored.set(item.itemIdentifier, {
-          ...scorePlatformAssessmentItem(artifactItem, responses[item.itemIdentifier]),
-          grading: PLATFORM_CHILD_GRADING
-        });
-        onEvent("assessment.item_scoring", {
-          "app.assessment.qti_item_identifier": item.itemIdentifier,
-          "app.assessment.purpose": purpose,
-          "app.assessment.artifact_identity_kind": artifactIdentity.kind,
-          "app.assessment.grading_source": "platform-artifact",
-          "app.assessment.grading_duration_ms": Date.now() - startedAt
-        });
-      } catch (error88) {
-        fallback2 = { reason: "platform-grader-error", error: error88 };
+// ../api-core/src/utils/timeback-assessment-replay.util.ts
+function diagnosticReceipt(submission, ledgerEntry) {
+  return {
+    submissionId: submission.submissionId,
+    routingNodeKey: ledgerEntry.routingNodeKey,
+    itemIdentifier: submission.itemIdentifier,
+    submittedAt: submission.submittedAt,
+    responseVersion: submission.responseVersion,
+    answered: submission.answered,
+    score: submission.score,
+    isCorrect: ledgerEntry.isCorrect
+  };
+}
+
+// ../api-core/src/utils/timeback-assessment-transcript.util.ts
+function parseAssessmentTranscript(value) {
+  const parsed = AssessmentTranscriptSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new ValidationError("Invalid assessment transcript");
+  }
+  return parsed.data;
+}
+function assessmentTokenMetadata(metadata2) {
+  const context2 = { ...metadata2, updatedAt: metadata2.startedAt };
+  delete context2.transcript;
+  return context2;
+}
+function requireAssessmentTokenContext(context2, scope) {
+  if (!context2 || context2.gameId !== scope.gameId || context2.studentId !== scope.studentId || context2.attemptId !== scope.attemptId) {
+    throw AssessmentRuntimeError.from(assessmentAttemptUnauthorized(scope.attemptId));
+  }
+  return context2;
+}
+function requireAssessmentFeedbackContext(tokenContext, scope) {
+  const context2 = requireAssessmentTokenContext(tokenContext, scope);
+  const metadata2 = context2.metadata;
+  if (assessmentFlowForPurpose(metadata2.purpose) === "attempt-submit" && !(metadata2.purpose === "diagnostic" && metadata2.diagnostic)) {
+    throw AssessmentRuntimeError.from(assessmentFlowViolation("This assessment accepts a complete attempt, not per-item feedback."));
+  }
+  return context2;
+}
+function prepareAssessmentProgress(tokenContext, scope, input) {
+  const context2 = requireAssessmentTokenContext(tokenContext, scope);
+  const transcript = parseAssessmentTranscript(input.transcript);
+  const progress = assessmentProgressAdministration(context2.metadata.purpose, {
+    ...input,
+    transcript
+  });
+  if (!progress.ok) {
+    throw AssessmentRuntimeError.from(progress.failure);
+  }
+  return { context: context2, transcript, submissionId: progress.submissionId };
+}
+function prepareAssessmentItemTranscript(assessment, input) {
+  validateAssessmentResponseUpdate(assessment, { [input.itemIdentifier]: input.responses });
+  const appended = appendAssessmentAdministration(input.transcript, input);
+  if (!appended.ok) {
+    throw AssessmentRuntimeError.from(appended.failure);
+  }
+  return appended;
+}
+function prepareAttemptAssessmentTranscript(context2, assessment, transcript, terminal = false) {
+  return prepareAssessmentTranscript({
+    transcript,
+    attemptId: context2.attemptId,
+    contentRevision: context2.metadata.selectedTest.contentRevision,
+    assessment,
+    routed: context2.metadata.purpose === "diagnostic" && context2.metadata.diagnostic !== undefined,
+    allowIncomplete: !terminal && assessmentFlowForPurpose(context2.metadata.purpose) === "attempt-submit"
+  });
+}
+function requireTranscriptWriteAccess(attemptId, integrationStatus) {
+  if (integrationStatus === "deactivated") {
+    throw AssessmentRuntimeError.from(assessmentAttemptUnauthorized(attemptId));
+  }
+}
+function requireTranscriptVersion(transcript, expectedResponseVersion) {
+  if (expectedResponseVersion !== transcript.administrations.length) {
+    throw AssessmentRuntimeError.from(assessmentResponseVersionConflict(expectedResponseVersion, transcript.administrations.length));
+  }
+}
+function requireAssessmentTranscriptCheckpoint(attempt, integrationStatus, input) {
+  requireTranscriptWriteAccess(attempt.sourcedId, integrationStatus);
+  requireTranscriptVersion(input.transcript, input.expectedResponseVersion);
+  if (!isAssessmentAttemptOpen({ ...attempt, inProgress: attempt.inProgress ?? "" })) {
+    throw AssessmentRuntimeError.from(assessmentAttemptNotOpen(attempt.sourcedId));
+  }
+}
+function assessmentTranscriptRequestHash(input) {
+  return sha256Hex(canonicalJson2({
+    transcript: input.transcript,
+    ...input.session ? { session: input.session } : {}
+  }));
+}
+function resolveAssessmentTranscriptSubmission(attempt, metadata2, integrationStatus, input, requestHash) {
+  const disposition = classifyAssessmentSubmission({
+    inProgress: attempt.inProgress ?? "",
+    scoreStatus: attempt.scoreStatus,
+    submissionId: metadata2.submissionId
+  }, input.submissionId);
+  if (disposition === "replay" && metadata2.completion?.requestHash === requestHash) {
+    return "replay";
+  }
+  if (disposition === "reject") {
+    throw AssessmentRuntimeError.from(assessmentAlreadySubmitted(attempt.sourcedId));
+  }
+  if (disposition !== "submit") {
+    throw AssessmentRuntimeError.from(assessmentFlowViolation("A different completion was already accepted for this attempt."));
+  }
+  requireTranscriptWriteAccess(attempt.sourcedId, integrationStatus);
+  if (input.session && input.session.runId !== attempt.sourcedId) {
+    throw new ValidationError("Assessment session runId must match the attemptId.");
+  }
+  requireTranscriptVersion(input.transcript, input.expectedResponseVersion);
+  return "submit";
+}
+function buildGradedAssessmentTranscript(input) {
+  const { context: context2, prepared, itemResults, assessment, submittedAt, manifest } = input;
+  const completed = completeAssessmentTranscript({
+    transcript: prepared.transcript,
+    scores: itemResults,
+    purpose: context2.metadata.purpose,
+    itemCount: assessment.items.length,
+    submittedAt,
+    manifest,
+    terminal: input.terminal
+  });
+  const common2 = {
+    ...context2.metadata,
+    responses: prepared.responses,
+    responseVersion: completed.itemSubmissions.length,
+    itemSubmissions: completed.itemSubmissions,
+    updatedAt: submittedAt,
+    transcript: prepared.transcript
+  };
+  const diagnostic = context2.metadata.purpose === "diagnostic" ? context2.metadata.diagnostic : undefined;
+  const metadata2 = diagnostic ? {
+    ...common2,
+    purpose: "diagnostic",
+    diagnostic: { ...diagnostic, ledger: completed.ledger, state: completed.state }
+  } : common2;
+  return {
+    metadata: metadata2,
+    transcript: prepared.transcript,
+    assessment,
+    itemResults,
+    manifest,
+    score: aggregateAssessmentScore(itemResults.map((item) => item.score.earned), itemResults.reduce((sum, item) => sum + item.score.possible, 0)),
+    correctQuestions: countCorrectQuestions(itemResults.map((item) => item.isCorrect))
+  };
+}
+function assessmentTranscriptRuntimeError(error88) {
+  return error88 instanceof AssessmentTranscriptError ? AssessmentRuntimeError.from({
+    code: error88.code,
+    message: error88.message,
+    details: { transcriptIndex: error88.index }
+  }) : error88;
+}
+function buildAssessmentTranscriptFeedback(attemptId, graded, index2) {
+  const { metadata: metadata2 } = graded;
+  const submission = metadata2.itemSubmissions[index2];
+  const common2 = {
+    attemptId,
+    responseVersion: metadata2.responseVersion,
+    status: "in_progress",
+    transcript: graded.transcript
+  };
+  return metadata2.purpose === "diagnostic" && metadata2.diagnostic ? {
+    ...common2,
+    routing: projectDiagnosticRoutingSnapshot(metadata2.diagnostic.routingRevision, metadata2.diagnostic.state),
+    submission: diagnosticReceipt(submission, metadata2.diagnostic.ledger[index2])
+  } : {
+    ...common2,
+    responses: metadata2.responses,
+    itemSubmissions: metadata2.itemSubmissions,
+    submission
+  };
+}
+async function resumeAssessmentTranscript(input) {
+  const retained = input.suppliedTranscript ?? input.checkpointTranscript;
+  let transcript = retained ?? await input.recover();
+  while (true) {
+    try {
+      return await input.grade(transcript);
+    } catch (error88) {
+      const index2 = error88 instanceof AssessmentRuntimeError && isRecord(error88.details) ? error88.details.transcriptIndex : undefined;
+      if (retained !== undefined || typeof index2 !== "number" || index2 < 0 || index2 >= transcript.administrations.length) {
+        throw error88;
       }
-    }
-    if (fallback2) {
-      qti2.push({ item, ...fallback2 });
+      transcript = {
+        ...transcript,
+        administrations: transcript.administrations.slice(0, index2)
+      };
     }
   }
-  if (qti2.length > 0) {
-    const fallbackTasks = qti2.flatMap(({ item, reason, artifactReason, error: graderError }) => {
-      const interactionResults = [];
-      let startedAt;
-      let completedInteractions = 0;
-      let failed = false;
-      const omittedResponseCount = item.requests.filter((request) => responses[item.itemIdentifier]?.[request.identifier] === undefined).length;
-      let qtiRemoteInteractionCount = 0;
-      let syntheticIncorrectInteractionCount = 0;
-      function fallbackEvent(outcome) {
-        onEvent("assessment.item_scoring_fallback", {
-          "app.assessment.qti_item_identifier": item.itemIdentifier,
-          "app.assessment.purpose": purpose,
-          "app.assessment.artifact_identity_kind": artifactIdentity.kind,
-          "app.assessment.grading_source": omittedResponseCount > 0 ? "platform-qti-adapter" : "timeback-qti",
-          "app.assessment.fallback_reason": reason,
-          "app.assessment.fallback_duration_ms": startedAt === undefined ? 0 : Date.now() - startedAt,
-          "app.assessment.qti_remote_interaction_count": qtiRemoteInteractionCount,
-          "app.assessment.synthetic_incorrect_interaction_count": syntheticIncorrectInteractionCount,
-          ...artifactReason ? { "app.assessment.artifact_fallback_reason": artifactReason } : {},
-          ...graderError ? {
-            "app.assessment.platform_grader_exception_type": errorType(graderError)
-          } : {},
-          ...outcome
-        });
-      }
-      function completeItem() {
-        const earned = assessmentItemEarnedScore(interactionResults.map((result) => Number.isFinite(result.score) ? result.score : 0), item.maxScore);
-        const possible = item.maxScore;
-        fallbackEvent({ "app.assessment.fallback_outcome": "succeeded" });
-        scored.set(item.itemIdentifier, {
-          itemIdentifier: item.itemIdentifier,
-          score: {
-            earned,
-            possible,
-            normalized: possible === 0 ? 0 : earned / possible
-          },
-          isCorrect: assessmentItemCorrectness(interactionResults.map((result) => result.isCorrect)),
-          grading: omittedResponseCount > 0 ? PLATFORM_QTI_ADAPTER_CHILD_GRADING : QTI_CHILD_GRADING
-        });
-      }
-      if (item.requests.length === 0) {
-        completeItem();
-        return [];
+}
+function assessmentReviewTranscriptOutcomes(input) {
+  const resultByItem = new Map(input.itemResults.map((item) => [item.itemIdentifier, item]));
+  const administered = administeredItemIdentifiers(input.metadata.itemSubmissions);
+  return input.metadata.review.selections.filter((selection) => administered.has(selection.itemIdentifier)).map((selection) => {
+    const result = resultByItem.get(selection.itemIdentifier);
+    const submission = itemAdministration(input.metadata.itemSubmissions, selection.itemIdentifier);
+    if (!result || !submission) {
+      throw new Error(`Scoring omitted selected review item ${selection.itemIdentifier}`);
+    }
+    return {
+      itemIdentifier: selection.itemIdentifier,
+      standard: selection.standard,
+      answered: submission.answered,
+      score: result.score,
+      isCorrect: result.isCorrect
+    };
+  });
+}
+function assessmentReviewTranscriptExposures(input) {
+  const exposures = [];
+  const authoritative = new Set;
+  for (const { result, metadata: metadata2 } of input.attempts) {
+    const state = { ...result, inProgress: result.inProgress ?? "" };
+    const settled = isAssessmentAttemptAwaitingAward(state) || isAssessmentAttemptCompleted(state);
+    const useTranscript = !settled && metadata2.transcript !== undefined;
+    if (metadata2.purpose === "review" && (useTranscript || settled)) {
+      authoritative.add(result.sourcedId);
+      if (metadata2.review.bankRevision === input.bankRevision) {
+        const accepted = useTranscript ? metadata2.transcript.administrations.map((entry) => ({
+          itemIdentifier: entry.itemIdentifier,
+          deliveredAt: metadata2.updatedAt
+        })) : metadata2.itemSubmissions.map((submission) => ({
+          itemIdentifier: submission.itemIdentifier,
+          deliveredAt: submission.submittedAt
+        }));
+        exposures.push(...accepted);
       }
-      return item.requests.map((request, index2) => async () => {
-        startedAt ??= Date.now();
-        try {
-          const response = responses[item.itemIdentifier]?.[request.identifier];
-          if (response === undefined) {
-            syntheticIncorrectInteractionCount += 1;
-            interactionResults[index2] = { score: 0, isCorrect: false };
-          } else {
-            qtiRemoteInteractionCount += 1;
-            interactionResults[index2] = await processResponse(item.itemIdentifier, request);
-          }
-          completedInteractions += 1;
-          if (completedInteractions === item.requests.length && !failed) {
-            completeItem();
-          }
-        } catch (error88) {
-          if (!failed) {
-            failed = true;
-            fallbackEvent({
-              "app.assessment.fallback_outcome": "failed",
-              "exception.type": errorType(error88),
-              "app.error.message": errorMessage(error88)
-            });
-          }
-          throw error88;
-        }
-      });
-    });
-    await runWithConcurrency(fallbackTasks, SCORING_CONCURRENCY, (task) => task());
+    }
   }
-  return scoringItems.map((item) => {
-    const result = scored.get(item.itemIdentifier);
-    if (!result) {
-      throw new Error(`Assessment item ${item.itemIdentifier} was not scored`);
+  for (const command of input.children) {
+    const { attempt, administration, context: context2 } = command.payload;
+    if (!authoritative.has(attempt.attemptId) && context2.kind === "review" && context2.bankRevision === input.bankRevision) {
+      exposures.push({
+        itemIdentifier: administration.itemIdentifier,
+        deliveredAt: command.recordedAt
+      });
     }
-    return result;
-  });
+  }
+  return exposures;
 }
-var QTI_CHILD_GRADING, PLATFORM_QTI_ADAPTER_CHILD_GRADING, PLATFORM_CHILD_GRADING, SCORING_CONCURRENCY = 4;
-var init_timeback_assessment_scoring_util = __esm(() => {
+var init_timeback_assessment_transcript_util = __esm(() => {
   init_assessment_runtime2();
-  init_assessment_artifact_envelope_util();
+  init_errors2();
   init_timeback_assessment_runtime_util();
-  QTI_CHILD_GRADING = {
-    source: "timeback-qti",
-    graderVersion: "timeback-qti-process-response-v1"
-  };
-  PLATFORM_QTI_ADAPTER_CHILD_GRADING = {
-    source: "platform-qti-adapter",
-    graderVersion: "platform-qti-adapter-v1",
-    qtiGraderVersion: "timeback-qti-process-response-v1"
-  };
-  PLATFORM_CHILD_GRADING = {
-    source: "platform-artifact",
-    artifactVersion: `assessment-artifact-v${ASSESSMENT_ARTIFACT_SCHEMA_VERSION}`,
-    graderVersion: `platform-grader-v${ASSESSMENT_GRADER_PROTOCOL_VERSION}`
-  };
 });
 
 // ../api-core/src/utils/timeback-qti-hydration.util.ts
@@ -103508,20 +103515,19 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   init_assessment_artifact_runtime_util();
   init_assessment_runtime_lock_util();
   init_timeback_assessment_artifacts_util();
+  init_timeback_assessment_child_result_util();
   init_timeback_assessment_preparation_util();
   init_timeback_assessment_publication_util();
-  init_timeback_assessment_reconciliation_util();
-  init_timeback_assessment_replay_util();
   init_timeback_assessment_routing_util();
   init_timeback_assessment_rules_util();
   init_timeback_assessment_runtime_util();
   init_timeback_assessment_scoring_util();
+  init_timeback_assessment_transcript_util();
   init_timeback_qti_hydration_util();
   await __promiseAll([
     init_dist5(),
     init_errors8(),
-    init_assessment_artifact_loader_util(),
-    init_timeback_assessment_child_result_util()
+    init_assessment_artifact_loader_util()
   ]);
   AssessmentPreparationPrerequisiteError = class AssessmentPreparationPrerequisiteError extends Error {
     original;
@@ -103536,8 +103542,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     static PREPARATION_IN_FLIGHT_LIMIT = 32;
     static ASSESSMENT_CACHE_TTL_MS = 60000;
     static EXPORT_CONCURRENCY = 4;
-    static ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS = 3;
-    static ASSESSMENT_VERSION_CONFIRMATION_DELAY_MS = 25;
     static SCORING_CONCURRENCY = 4;
     static STALE_AWARD_AGE_MS = 15 * 60 * 1000;
     deps;
@@ -103554,6 +103558,14 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       maxSize: TimebackAssessmentRuntimeService.ASSESSMENT_CACHE_LIMIT
     });
     artifactLoader;
+    itemScoreCache = new TimebackCache({
+      defaultTTL: 5 * 60000,
+      maxSize: 512
+    });
+    childLineItemCache = new TimebackCache({
+      defaultTTL: 5 * 60000,
+      maxSize: 512
+    });
     preparations = new AssessmentPreparationFlights(TimebackAssessmentRuntimeService.PREPARATION_IN_FLIGHT_LIMIT);
     constructor(deps) {
       this.deps = deps;
@@ -103619,8 +103631,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         return this.startReview({ gameId, studentId, input, user });
       }
       const masteryStandard = input.purpose === "mastery" ? normalizeMasteryStandard(input.standard) : undefined;
-      const requestFingerprint = this.startRequestFingerprint(input);
-      const pendingSupersessions = new Set;
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
         studentId,
@@ -103629,7 +103639,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -103642,44 +103652,34 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2, masteryStandard),
           this.listAttempts(attemptScope)
         ]);
-        const attempts = listing.attempts;
-        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeSnapshot(resumeDecision, attempts, context2.integration));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
-        }
-        let decision = this.requireDecision(initialResolution.decision, input.purpose);
-        let assessment = await this.loadAssessment(decision.test.qtiTestIdentifier);
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeSnapshot(resumeDecision, refreshed, context2.integration));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        decision = this.requireDecision(refreshedResolution.decision, input.purpose);
-        if (assessment.identifier !== decision.test.qtiTestIdentifier) {
-          assessment = await this.loadAssessment(decision.test.qtiTestIdentifier);
-        }
-        const classId = await this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId);
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
+        }
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
+        const [assessment, classId, { attemptNumber, attemptId }] = await Promise.all([
+          this.loadAssessment(decision.test.qtiTestIdentifier),
+          this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
         const lineItemId = await this.ensureLineItem({
           classId,
           integration: context2.integration,
           purpose: input.purpose,
           assessment
         });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
         const timestamp6 = new Date().toISOString();
         const metadataBase = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
           activityId: input.activityId,
           courseId: context2.integration.courseId,
+          courseName: context2.enrollment.course.title,
           integrationId: context2.integration.id,
           enrollmentId: context2.enrollment.id,
           selectedTest: {
@@ -103698,7 +103698,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...metadataBase,
           purpose: input.purpose,
           mastery: {
-            requestFingerprint,
+            requestFingerprint: masteryRequestFingerprint(input),
             standard: masteryStandard
           }
         } : { ...metadataBase, purpose: input.purpose };
@@ -103716,8 +103716,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-        return this.snapshot(result, metadata2, assessment, context2.integration);
+        const [snapshot] = await Promise.all([
+          this.snapshot(result, metadata2, assessment, context2.integration),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
+        return snapshot;
       });
     }
     async prepareNewAttempt(params, requestHash) {
@@ -103726,7 +103729,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         this.candidateIntegrations(params.gameId, params.studentId, params.input),
         this.studentAssessmentResults(params.studentId)
       ]);
-      const context2 = await this.selectIntegration(candidates, params.studentId, params.input, results);
+      const context2 = await this.selectIntegration(candidates, params.input);
       const attemptScope = {
         studentId: params.studentId,
         activityId: params.input.activityId,
@@ -103736,29 +103739,31 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         enrollmentId: context2.enrollment.id
       };
       const tests = await this.liveTests(context2.integration.id, params.input.purpose, this.deps.db, params.input.purpose === "mastery" ? params.input.standard : undefined, params.input.purpose === "diagnostic" ? params.input.diagnosticKey : undefined);
-      const listing = this.attemptListing(results, attemptScope);
-      const decision = selectRuntimeAssessment(tests, [
-        ...this.attemptsMatchingRequest(listing.attempts, this.startRequestFingerprint(params.input)).values()
-      ].map((entry) => entry.selection));
-      const selection = resolveAssessmentPreparationSelection(decision, candidates.rows.length);
-      if (selection.status === "blocked") {
-        this.recordPreparation(selection.result.status, params.input.purpose, startedAt, {
-          reason: selection.result.status === "canonical_required" ? selection.result.reason : "multiple_candidate_courses"
+      const listing = await this.attemptListing(results, attemptScope);
+      if (this.pendingAwardAttempt(listing, context2.enrollment.id)) {
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason: "pending_award"
         });
-        return selection.result;
+        return { status: "unprepared", reason: "prerequisite_unavailable" };
       }
-      if (selection.status === "unavailable") {
-        throw AssessmentRuntimeError.from(assessmentNoEligibleTests(params.input.purpose));
+      if (candidates.rows.length !== 1) {
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason: "multiple_candidate_courses"
+        });
+        return { status: "unprepared", reason: "prerequisite_unavailable" };
       }
       const preparation = {
         context: context2,
         tests,
         listing,
-        decision: selection.decision
+        decision: this.selectFreshStart(tests, listing, params.input.purpose)
       };
       let prepared;
       try {
         prepared = await this.buildPreparationPlan(params, requestHash, preparation);
+        if (!await this.loadPreparedPlanAssessment(prepared.plan)) {
+          throw new Error("Prepared assessment artifact is unavailable");
+        }
       } catch (error88) {
         if (error88 instanceof ValidationError || error88 instanceof AssessmentRuntimeError) {
           throw error88;
@@ -103844,8 +103849,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         integrationId: context2.integration.id,
         enrollmentId: context2.enrollment.id,
         courseId: context2.integration.courseId,
+        courseName: context2.enrollment.course.title,
         ...attempt,
         parentLineItemId,
+        supersedes: [...this.replacedAttemptIds(listing.attempts, context2.enrollment.id)],
         selectedTest: {
           assessmentKey: decision.test.assessmentKey,
           identifier: assessment.identifier,
@@ -103884,7 +103891,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const selected = selectReviewItems({
         request: params.input,
         bank: catalog.bank,
-        exposures: this.reviewExposures(listing.reviewChildren.values(), {
+        exposures: assessmentReviewTranscriptExposures({
+          attempts: listing.attempts.values(),
+          children: listing.reviewChildren.values(),
           bankRevision: catalog.bank.bankRevision
         })
       });
@@ -103895,26 +103904,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         throw AssessmentRuntimeError.from(assessmentReviewBankShortage(selected.fulfillment));
       }
       const artifact = await this.loadOrCompileReviewBankArtifact(catalog);
-      const assessment = projectReviewAssessment(artifact.assessment, catalog.bank, selected.selections);
       const source = { assessment: artifact.assessment, bank: catalog.bank };
       const parentLineItemId = await this.provisionPreparationPrerequisites(() => this.ensureReviewBankLineItem({
         integration: context2.integration,
         activityId: params.input.activityId,
         source
       }));
-      await this.provisionPreparationPrerequisites(() => runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, (item) => {
-        const indexed = catalog.bank.items.find((candidate) => candidate.itemIdentifier === item.identifier);
-        if (!indexed) {
-          throw new Error(`Review-bank index is missing item ${item.identifier}`);
-        }
-        return this.ensureReviewQuestionLineItem({
-          parentLineItemId,
-          integration: context2.integration,
-          bankRevision: catalog.bank.bankRevision,
-          standards: [...indexed.standards],
-          item
-        });
-      }));
       const attempt = await this.provisionPreparationPrerequisites(() => this.claimAttemptId({
         gameId: params.gameId,
         studentId: params.studentId,
@@ -103933,8 +103928,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         integrationId: context2.integration.id,
         enrollmentId: context2.enrollment.id,
         courseId: context2.integration.courseId,
+        courseName: context2.enrollment.course.title,
         ...attempt,
         parentLineItemId,
+        supersedes: [...this.replacedAttemptIds(listing.attempts, context2.enrollment.id)],
         selectedTest: {
           assessmentKey: decision.test.assessmentKey,
           identifier: artifact.assessment.identifier,
@@ -103983,10 +103980,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           if (!integration || !await this.preparedPlanTestIsLive(verified, db2)) {
             return null;
           }
-          if (await this.attemptIdOccupied(verified.attemptId)) {
-            return null;
-          }
-          return this.createPreparedAttempt(verified, assessment, integration);
+          return this.claimPreparedAttempt(db2, verified, assessment, integration);
         });
         if (!outcome) {
           this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
@@ -104011,8 +104005,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       studentId,
       input
     }) {
-      const requestFingerprint = this.startRequestFingerprint(input);
-      const pendingSupersessions = new Set;
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
         studentId,
@@ -104021,7 +104013,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -104034,32 +104026,25 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2, undefined, input.diagnosticKey),
           this.listAttempts(attemptScope)
         ]);
-        const initialResolution = await this.resumeAvailableAttempt(tests, listing.attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeDiagnosticSnapshot(resumeDecision, listing.attempts, context2.integration, db2));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
         }
-        let decision = this.requireDecision(initialResolution.decision, input.purpose);
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
         let definition = await this.requireDiagnosticDefinition(decision.test.id, context2.integration.id, db2, true);
-        let assessment = await this.loadAssessment(definition.qtiTestIdentifier);
-        let routing = await this.initializeHostedDiagnostic(definition, assessment);
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeDiagnosticSnapshot(resumeDecision, refreshed, context2.integration, db2));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        decision = this.requireDecision(refreshedResolution.decision, input.purpose);
-        if (definition.id !== decision.test.id) {
-          definition = await this.requireDiagnosticDefinition(decision.test.id, context2.integration.id, db2, true);
-          assessment = await this.loadAssessment(definition.qtiTestIdentifier);
-          routing = await this.initializeHostedDiagnostic(definition, assessment);
-        } else {
-          definition = await this.requireDiagnosticDefinition(definition.id, context2.integration.id, db2, true);
-          routing = await this.initializeHostedDiagnostic(definition, assessment);
-        }
-        const classId = await this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId);
+        const [assessment, classId, { attemptNumber, attemptId }] = await Promise.all([
+          this.loadAssessment(definition.qtiTestIdentifier),
+          this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
+        definition = await this.requireDiagnosticDefinition(definition.id, context2.integration.id, db2, true);
+        const routing = await this.initializeHostedDiagnostic(definition, assessment);
         const lineItemId = await this.ensureLineItem({
           classId,
           integration: context2.integration,
@@ -104071,19 +104056,13 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             routingRevision: routing.routingRevision
           }
         });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
         const timestamp6 = new Date().toISOString();
         const metadata2 = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
           activityId: input.activityId,
           purpose: "diagnostic",
           courseId: context2.integration.courseId,
+          courseName: context2.enrollment.course.title,
           integrationId: context2.integration.id,
           enrollmentId: context2.enrollment.id,
           selectedTest: {
@@ -104103,7 +104082,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             testName: assessment.title,
             routingRevision: routing.routingRevision,
             ledger: [],
-            routingSnapshots: [],
             state: routing.state
           }
         };
@@ -104121,8 +104099,13 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-        return this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, routing.state);
+        const [snapshot] = await Promise.all([
+          this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, {
+            state: routing.state
+          }),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
+        return snapshot;
       });
     }
     async startReview({
@@ -104132,7 +104115,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }) {
       const preparationStartedAt = Date.now();
       const requestFingerprint = reviewRequestFingerprint(input, DEFAULT_REVIEW_SELECTION_POLICY);
-      const pendingSupersessions = new Set;
       const normalizedRequest = normalizeReviewRequest(input);
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
@@ -104142,7 +104124,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -104155,40 +104137,22 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2),
           this.listAttempts(attemptScope)
         ]);
-        const attempts = listing.attempts;
-        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, attempts, listing.reviewChildren, context2));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
-        }
-        let decision = initialResolution.decision;
-        if (tests.length === 0 || !decision) {
-          throw AssessmentRuntimeError.from(assessmentNoEligibleTests(input.purpose));
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
         }
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
         if (tests.length > 1) {
           throw new ValidationError("Standards review requires exactly one live review-bank assessment.");
         }
         const manifestStartedAt = Date.now();
-        let catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
+        const catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
         this.recordReviewPreparationPhase("manifest_load", manifestStartedAt, {
           candidateCount: catalog.bank.items.length
         });
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, refreshed, refreshedListing.reviewChildren, context2));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        const refreshedDecision = refreshedResolution.decision;
-        if (!refreshedDecision || refreshedDecision.kind !== "start") {
-          throw AssessmentRuntimeError.from(assessmentNoEligibleTests(input.purpose));
-        }
-        decision = refreshedDecision;
-        if (catalog.test.identifier !== decision.test.qtiTestIdentifier) {
-          catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
-        }
-        const exposures = this.reviewExposures(refreshedListing.reviewChildren.values(), {
+        const exposures = assessmentReviewTranscriptExposures({
+          attempts: listing.attempts.values(),
+          children: listing.reviewChildren.values(),
           bankRevision: catalog.bank.bankRevision
         });
         const selected = selectReviewItems({
@@ -104209,24 +104173,27 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
         const assessment = projectReviewAssessment(source.assessment, source.bank, selected.selections);
         const provisioningStartedAt = Date.now();
-        const parentLineItemId = await this.ensureReviewBankLineItem({
-          integration: context2.integration,
-          activityId: input.activityId,
-          source
-        });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
+        const [parentLineItemId, { attemptNumber, attemptId }] = await Promise.all([
+          this.ensureReviewBankLineItem({
+            integration: context2.integration,
+            activityId: input.activityId,
+            source
+          }),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
         const timestamp6 = new Date().toISOString();
         const metadata2 = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
           activityId: input.activityId,
           purpose: input.purpose,
           courseId: context2.integration.courseId,
+          courseName: context2.enrollment.course.title,
           integrationId: context2.integration.id,
           enrollmentId: context2.enrollment.id,
           selectedTest: {
@@ -104263,18 +104230,27 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
+        const [snapshot] = await Promise.all([
+          this.snapshot(result, metadata2, assessment, context2.integration),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
         this.recordReviewPreparationPhase("provisioning", provisioningStartedAt);
         this.recordReviewPreparationPhase("total", preparationStartedAt, {
           candidateCount: catalog.bank.items.length,
           selectedCount: selected.selections.length
         });
-        return this.snapshot(result, metadata2, assessment, context2.integration);
+        return snapshot;
       });
     }
     async get(params) {
+      return this.resume({ ...params, input: {} });
+    }
+    async resume({
+      input,
+      ...params
+    }) {
       const attempt = await this.authorizeAttemptRead(params);
-      return this.snapshotForResult(attempt.result, attempt.metadata, attempt.integration);
+      return this.snapshotForResult(attempt.result, attempt.metadata, attempt.integration, input.transcript);
     }
     async latest({
       gameId,
@@ -104336,496 +104312,104 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
     async save({ input, ...params }) {
       await this.deps.validateDeveloperAccess(params.user, params.gameId);
-      try {
-        const warmup = await this.peekAttempt(params);
-        if (this.isOpen(warmup.result) && !this.isPlatformRoutedDiagnosticMetadata(warmup.metadata)) {
-          await this.loadAttemptAssessment(warmup.metadata);
-        }
-      } catch (error88) {
-        addEvent("assessment.save_warmup_failed", {
-          "app.assessment.attempt_id": params.attemptId,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-      }
       return this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-        const attempt = await this.authorizeAttempt(params, {
+        const { attempt } = await this.resolveAttemptAuthorization(params, {
           db: db2,
-          developerAccessValidated: true
+          developerAccessValidated: true,
+          includeEnrollment: false
         });
-        if (this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-          throw AssessmentRuntimeError.from(assessmentFlowViolation("Platform-routed diagnostics do not accept draft saves.", { flow: "platform-routed-item-submit" }));
-        }
-        this.assertInProgress(attempt.result);
-        this.assertResponseVersion(attempt.metadata, input.expectedResponseVersion);
-        const assessment = await this.loadAttemptAssessment(attempt.metadata);
-        const flowFailure = assessmentResponseUpdateFlowFailure(attempt.metadata.purpose, attempt.metadata.itemSubmissions, input.responses);
-        if (flowFailure) {
-          throw AssessmentRuntimeError.from(flowFailure);
-        }
-        validateAssessmentResponseUpdate(assessment, input.responses);
-        const responses = applyAssessmentResponseUpdate(attempt.metadata.responses, input.responses);
-        validateAssessmentDraftResponses(assessment, responses);
-        const metadata2 = {
-          ...attempt.metadata,
-          responses,
-          responseVersion: attempt.metadata.responseVersion + 1,
-          updatedAt: new Date().toISOString()
-        };
-        await this.putResultMetadata(attempt.result, metadata2);
+        requireAssessmentTranscriptCheckpoint(attempt.result, attempt.integration.status, input);
+        const graded = await this.gradeTranscript({
+          attemptId: params.attemptId,
+          metadata: attempt.metadata
+        }, input.transcript, false, db2);
+        await this.requireClient().api.oneroster.assessmentResults.upsert(params.attemptId, buildAssessmentResultCheckpoint({
+          result: attempt.result,
+          metadata: attempt.metadata,
+          transcript: graded.transcript,
+          timestamp: graded.metadata.updatedAt
+        }));
+        this.reconcileTranscriptChildren(this.tokenContext(attempt), graded).catch((error88) => this.recordTranscriptFailure("checkpoint_projection", params.attemptId, error88));
         return {
-          attemptId: attempt.result.sourcedId,
-          responseVersion: metadata2.responseVersion,
+          attemptId: params.attemptId,
+          responseVersion: graded.metadata.responseVersion,
           status: "in_progress",
-          responses
+          responses: graded.metadata.responses,
+          transcript: graded.transcript
         };
       });
     }
-    async submitItem({
+    async recordProgress({
       input,
       ...params
     }) {
       await this.deps.validateDeveloperAccess(params.user, params.gameId);
-      if (input.routingNodeKey !== undefined) {
-        const identity = await this.peekAttempt(params);
-        if (this.isPlatformRoutedDiagnosticMetadata(identity.metadata)) {
-          return this.submitDiagnosticItem(params, input);
-        }
-        throw AssessmentRuntimeError.from(assessmentFlowViolation("routingNodeKey is not accepted by the hosted conventional item-submit flow.", { routingNodeKey: input.routingNodeKey }));
-      }
-      let preview = await this.prepareItemSubmission(params, input);
-      let preparationAttempts = 1;
-      while (true) {
-        const committed = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-          const { attempt, enrollment } = await this.resolveAttemptAuthorization(params, {
-            db: db2,
-            developerAccessValidated: true
-          });
-          if (this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-            this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-            throw AssessmentRuntimeError.from(assessmentFlowViolation("Platform-routed diagnostic submissions require routingNodeKey.", { flow: "platform-routed-item-submit" }));
-          }
-          const replay = resolveAssessmentItemReplay(attempt.metadata, input);
-          if (replay.action === "conflict") {
-            this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-            throw AssessmentRuntimeError.from(replay.failure);
-          }
-          if (replay.action === "replay") {
-            const prior = replay.submission;
-            const child2 = attempt.metadata.purpose === "review" ? await this.prepareReviewAssessmentChildResult({
-              attempt,
-              metadata: attempt.metadata,
-              submission: prior
-            }) : null;
-            return {
-              action: "complete",
-              response: buildAssessmentItemReplayResult(attempt.result.sourcedId, attempt.metadata, prior),
-              checkpoint: child2,
-              projection: attempt.metadata.purpose === "review" ? {
-                result: attempt.result,
-                metadata: attempt.metadata,
-                itemIdentifier: input.itemIdentifier,
-                integration: attempt.integration
-              } : null
-            };
-          }
-          this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-          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) {
-              throw assessmentPreparationContentionError(input.expectedResponseVersion, attempt.metadata.responseVersion, "assessment");
-            }
-            return { action: "prepare" };
-          }
-          const transition = prepareAssessmentItemSubmission({
-            purpose: attempt.metadata.purpose,
-            responseVersion: attempt.metadata.responseVersion,
-            responses: attempt.metadata.responses,
-            itemSubmissions: attempt.metadata.itemSubmissions,
-            assessment: preview.assessment
-          }, input);
-          if (transition.action === "reject") {
-            throw AssessmentRuntimeError.from(transition.failure);
-          }
-          if (transition.action === "replay") {
-            const child2 = attempt.metadata.purpose === "review" ? await this.prepareReviewAssessmentChildResult({
-              attempt,
-              metadata: attempt.metadata,
-              submission: transition.submission
-            }) : null;
-            return {
-              action: "complete",
-              response: {
-                attemptId: attempt.result.sourcedId,
-                responseVersion: transition.responseVersion,
-                status: "in_progress",
-                responses: transition.responses,
-                itemSubmissions: attempt.metadata.itemSubmissions,
-                submission: transition.submission
-              },
-              checkpoint: child2,
-              projection: attempt.metadata.purpose === "review" ? {
-                result: attempt.result,
-                metadata: attempt.metadata,
-                itemIdentifier: input.itemIdentifier,
-                integration: attempt.integration
-              } : null
-            };
-          }
-          if (!preview.scoring) {
-            throw new Error("Prepared item submission is missing its score");
-          }
-          const submittedAt = new Date().toISOString();
-          const completed = completeAssessmentItemSubmission(attempt.metadata, input, transition, preview.scoring, submittedAt);
-          const metadata2 = {
-            ...attempt.metadata,
-            responses: completed.responses,
-            responseVersion: completed.responseVersion,
-            itemSubmissions: completed.itemSubmissions,
-            updatedAt: submittedAt
-          };
-          const child = metadata2.purpose === "review" ? await this.prepareReviewAssessmentChildResult({
-            attempt,
-            metadata: metadata2,
-            submission: completed.submission
-          }) : null;
-          await this.putResultMetadata(attempt.result, metadata2);
-          return {
-            action: "complete",
-            response: {
-              attemptId: attempt.result.sourcedId,
-              responseVersion: completed.responseVersion,
-              status: "in_progress",
-              responses: completed.responses,
-              itemSubmissions: completed.itemSubmissions,
-              submission: completed.submission
-            },
-            checkpoint: child,
-            projection: metadata2.purpose === "review" ? {
-              result: attempt.result,
-              metadata: metadata2,
-              itemIdentifier: input.itemIdentifier,
-              integration: attempt.integration
-            } : null
-          };
-        });
-        if (committed.action === "prepare") {
-          preparationAttempts += 1;
-          preview = await this.scoreItemSubmission(params, input);
-        } else {
-          if (committed.projection) {
-            this.projectReviewItemResponse(params, committed.projection, committed.checkpoint);
-          }
-          return committed.response;
-        }
-      }
-    }
-    async submitDiagnosticItem(params, input) {
-      let preview = await this.prepareDiagnosticItemSubmission(params, input);
-      let preparationAttempts = 1;
-      while (true) {
-        const committed = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-          const { attempt, enrollment } = await this.resolveAttemptAuthorization(params, { db: db2, developerAccessValidated: true });
-          if (!this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-            this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-            throw AssessmentRuntimeError.from(assessmentFlowViolation("routingNodeKey is accepted only for a platform-routed diagnostic.", { routingNodeKey: input.routingNodeKey }));
-          }
-          const metadata2 = attempt.metadata;
-          const replay = resolveDiagnosticItemReplay(metadata2, input);
-          if (replay.action === "conflict") {
-            this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-            throw AssessmentRuntimeError.from(replay.failure);
-          }
-          if (replay.action === "replay") {
-            const { submission: prior, ledgerEntry, priorIndex } = replay;
-            let routing = replay.routing;
-            if (!routing) {
-              const assessment = preview?.assessment ?? await this.loadAttemptAssessment(metadata2);
-              const loaded2 = await this.loadAttemptDiagnosticRouting(metadata2, assessment, db2);
-              const replayed = replayDiagnosticRouting(loaded2.manifest, metadata2.diagnostic.ledger.slice(0, priorIndex + 1));
-              if (!replayed.ok) {
-                throw AssessmentRuntimeError.from(assessmentFlowViolation("The committed diagnostic routing state cannot be replayed.", { failure: replayed.failure }));
-              }
-              routing = this.diagnosticRoutingSnapshot(metadata2, replayed.state);
-            }
-            const child2 = await this.prepareDiagnosticAssessmentChildResult({
-              attempt,
-              metadata: metadata2,
-              submission: prior,
-              transition: ledgerEntry
-            });
-            return {
-              action: "complete",
-              response: buildDiagnosticItemReplayResult(attempt.result.sourcedId, prior, ledgerEntry, routing),
-              checkpoint: child2,
-              projection: {
-                result: attempt.result,
-                metadata: metadata2,
-                ledgerEntry,
-                integration: attempt.integration
-              }
-            };
-          }
-          this.requireActiveAttempt({ attempt, enrollment }, params.attemptId);
-          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) {
-              throw assessmentPreparationContentionError(input.expectedResponseVersion, metadata2.responseVersion, "diagnostic");
-            }
-            return { action: "prepare" };
-          }
-          this.assertResponseVersion(metadata2, input.expectedResponseVersion);
-          const loaded = await this.loadAttemptDiagnosticRouting(metadata2, preview.assessment, db2);
-          const expected = loaded.state.next;
-          if (loaded.state.status !== "in-progress" || !expected || expected.nodeKey !== input.routingNodeKey || expected.itemIdentifier !== input.itemIdentifier) {
-            throw AssessmentRuntimeError.from(assessmentFlowViolation(expected ? "Submitted diagnostic item is not the canonical next item." : "Diagnostic routing is already ready to complete.", {
-              expectedRoutingNodeKey: expected?.nodeKey ?? null,
-              routingNodeKey: input.routingNodeKey,
-              expectedItemIdentifier: expected?.itemIdentifier ?? null,
-              itemIdentifier: input.itemIdentifier
-            }));
-          }
-          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 }));
-          }
-          const advanced = advanceDiagnosticRouting(loaded.manifest, metadata2.diagnostic.ledger, {
-            routingNodeKey: input.routingNodeKey,
-            itemIdentifier: input.itemIdentifier,
-            isCorrect: scoring.isCorrect
-          });
-          if (!advanced.ok) {
-            throw AssessmentRuntimeError.from(assessmentFlowViolation("The diagnostic routing transition was rejected.", { failure: advanced.failure }));
-          }
-          const submittedAt = new Date().toISOString();
-          const responseVersion = metadata2.responseVersion + 1;
-          const routingSnapshot = this.diagnosticRoutingSnapshot(metadata2, advanced.state);
-          const routingSnapshots = metadata2.diagnostic.routingSnapshots ? [...metadata2.diagnostic.routingSnapshots, routingSnapshot] : undefined;
-          const submission = {
-            submissionId: input.submissionId,
-            itemIdentifier: input.itemIdentifier,
-            submittedAt,
-            responseVersion,
-            answered: Object.keys(responses[input.itemIdentifier] ?? {}).length > 0,
-            score: scoring.score,
-            isCorrect: scoring.isCorrect,
-            grading: scoring.grading
-          };
-          const nextMetadata = {
-            ...metadata2,
-            responses,
-            responseVersion,
-            itemSubmissions: [...metadata2.itemSubmissions, submission],
-            updatedAt: submittedAt,
-            diagnostic: {
-              ...metadata2.diagnostic,
-              ledger: [...metadata2.diagnostic.ledger, advanced.ledgerEntry],
-              ...routingSnapshots ? { routingSnapshots } : {},
-              state: advanced.state
-            }
-          };
-          const child = await this.prepareDiagnosticAssessmentChildResult({
-            attempt,
-            metadata: nextMetadata,
-            submission,
-            transition: advanced.ledgerEntry
-          });
-          await this.putResultMetadata(attempt.result, nextMetadata);
-          return {
-            action: "complete",
-            response: {
-              attemptId: attempt.result.sourcedId,
-              responseVersion,
-              status: "in_progress",
-              routing: routingSnapshot,
-              submission: diagnosticReceipt(submission, advanced.ledgerEntry)
-            },
-            checkpoint: child,
-            projection: {
-              result: attempt.result,
-              metadata: nextMetadata,
-              ledgerEntry: advanced.ledgerEntry,
-              integration: attempt.integration
-            }
-          };
-        });
-        if (committed.action === "prepare") {
-          preparationAttempts += 1;
-          preview = await this.scoreDiagnosticItemSubmission(params, input);
-        } else {
-          this.projectDiagnosticItemResponse(committed.projection, preview?.assessment, committed.checkpoint);
-          return committed.response;
-        }
-      }
+      const { context: context2, transcript, submissionId } = prepareAssessmentProgress(await this.deps.verifyAssessmentToken(input.assessmentToken), params, input);
+      const graded = await this.gradeTranscript(context2, transcript);
+      await this.reconcileTranscriptChildren(context2, graded, new Set([submissionId]));
+      return { attemptId: params.attemptId };
     }
-    async prepareDiagnosticItemSubmission(params, input) {
+    async submitItem({
+      input,
+      ...params
+    }) {
+      await this.deps.validateDeveloperAccess(params.user, params.gameId);
+      const context2 = requireAssessmentFeedbackContext(await this.deps.verifyAssessmentToken(input.assessmentToken), params);
+      const transcript = parseAssessmentTranscript(input.transcript);
+      const assessment = await this.loadAttemptAssessment(context2.metadata);
+      const appended = prepareAssessmentItemTranscript(assessment, { ...input, transcript });
+      const graded = await this.gradeTranscript(context2, appended.transcript);
+      const submission = graded.metadata.itemSubmissions[appended.index];
+      this.reconcileTranscriptChildren(context2, graded, new Set([submission.submissionId])).catch((error88) => this.recordTranscriptFailure("child_projection", params.attemptId, error88));
+      return buildAssessmentTranscriptFeedback(params.attemptId, graded, appended.index);
+    }
+    async gradeTranscript(context2, transcript, terminal = false, db2 = this.deps.db) {
+      const startedAt = Date.now();
       try {
-        return await this.scoreDiagnosticItemSubmission(params, input);
-      } catch (error88) {
-        addEvent("assessment.diagnostic_item_submission_preview_failed", {
-          "app.assessment.attempt_id": params.attemptId,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-        return null;
-      }
-    }
-    async scoreDiagnosticItemSubmission(params, input) {
-      const attempt = await this.peekAttempt(params);
-      if (!this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-        return null;
-      }
-      const prior = attempt.metadata.itemSubmissions.find((submission) => submission.submissionId === input.submissionId);
-      if (prior || !this.isOpen(attempt.result)) {
-        return null;
-      }
-      const assessment = await this.loadAttemptAssessment(attempt.metadata);
-      const artifactIdentity = assessmentArtifactIdentityFromAttempt(attempt.metadata);
-      const scoringArtifact = await this.artifactLoader.loadMatchedScoring(assessment, artifactIdentity);
-      const loaded = await this.loadAttemptDiagnosticRouting(attempt.metadata, assessment, this.deps.db, scoringArtifact);
-      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 = prepareDiagnosticAssessmentResponses(assessment, attempt.metadata.responses, input);
-        scoring = await this.scoreItem({
+        const assessment = await this.loadAttemptAssessment(context2.metadata);
+        const prepared = prepareAttemptAssessmentTranscript(context2, assessment, transcript, terminal);
+        const artifactIdentity = assessmentArtifactIdentityFromAttempt(context2.metadata);
+        const artifact = await this.artifactLoader.loadMatchedScoring(assessment, artifactIdentity);
+        const [itemResults, routing] = await Promise.all([
+          scoreCachedAssessmentItems({
+            assessment,
+            responses: prepared.responses,
+            artifactIdentity,
+            purpose: context2.metadata.purpose,
+            itemIdentifiers: new Set(prepared.transcript.administrations.map((entry) => entry.itemIdentifier)),
+            artifact,
+            cache: this.itemScoreCache,
+            processResponse: (identifier, request) => this.requireClient().qtiApi.assessmentItems.processResponse(identifier, request),
+            onEvent: addEvent
+          }),
+          this.isPlatformRoutedDiagnosticMetadata(context2.metadata) ? this.loadAttemptDiagnosticRouting(context2.metadata, assessment, db2, artifact) : undefined
+        ]);
+        const graded = buildGradedAssessmentTranscript({
+          context: context2,
           assessment,
-          responses,
-          itemIdentifier: input.itemIdentifier,
-          artifactIdentity,
-          purpose: attempt.metadata.purpose,
-          preparedArtifact: scoringArtifact
+          prepared,
+          itemResults,
+          submittedAt: new Date().toISOString(),
+          manifest: routing?.manifest,
+          terminal
+        });
+        addEvent("assessment.transcript_validated", {
+          "app.assessment.attempt_id": context2.attemptId,
+          "app.assessment.administration_count": graded.metadata.responseVersion,
+          "app.assessment.duration_ms": Date.now() - startedAt
         });
-      }
-      return {
-        responseVersion: attempt.metadata.responseVersion,
-        submissionId: input.submissionId,
-        routingNodeKey: input.routingNodeKey,
-        itemIdentifier: input.itemIdentifier,
-        assessment,
-        scoring
-      };
-    }
-    async scoreItems({
-      preparedArtifact,
-      ...input
-    }) {
-      const artifact = preparedArtifact === undefined ? await this.artifactLoader.loadMatchedScoring(input.assessment, input.artifactIdentity) : preparedArtifact;
-      return scoreAssessmentItems({
-        ...input,
-        artifact,
-        processResponse: (identifier, request) => this.requireClient().qtiApi.assessmentItems.processResponse(identifier, request),
-        onEvent: addEvent
-      });
-    }
-    async scoreItem(input) {
-      const [scoring] = await this.scoreItems({
-        assessment: input.assessment,
-        responses: input.responses,
-        artifactIdentity: input.artifactIdentity,
-        purpose: input.purpose,
-        itemIdentifiers: new Set([input.itemIdentifier]),
-        preparedArtifact: input.preparedArtifact
-      });
-      return scoring;
-    }
-    async prepareItemSubmission(params, input) {
-      try {
-        return await this.scoreItemSubmission(params, input);
+        return graded;
       } catch (error88) {
-        addEvent("assessment.item_submission_preview_failed", {
-          "app.assessment.attempt_id": params.attemptId,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-        return null;
+        throw assessmentTranscriptRuntimeError(error88);
       }
     }
-    async scoreItemSubmission(params, input) {
-      const attempt = await this.peekAttempt(params);
-      const prior = attempt.metadata.itemSubmissions.find((submission) => submission.submissionId === input.submissionId);
-      if (prior || !this.isOpen(attempt.result)) {
-        return null;
-      }
-      const assessment = await this.loadAttemptAssessment(attempt.metadata);
-      const transition = prepareAssessmentItemSubmission({
-        purpose: attempt.metadata.purpose,
-        responseVersion: attempt.metadata.responseVersion,
-        responses: attempt.metadata.responses,
-        itemSubmissions: attempt.metadata.itemSubmissions,
-        assessment
-      }, input);
-      const scoring = transition.action === "commit" ? await this.scoreItem({
-        assessment,
-        responses: transition.responses,
-        itemIdentifier: input.itemIdentifier,
-        artifactIdentity: assessmentArtifactIdentityFromAttempt(attempt.metadata),
-        purpose: attempt.metadata.purpose
-      }) : null;
-      return {
-        responseVersion: attempt.metadata.responseVersion,
-        submissionId: input.submissionId,
-        itemIdentifier: input.itemIdentifier,
-        assessment,
-        scoring
-      };
-    }
-    async scoreSubmission(attempt) {
-      const assessment = await this.loadAttemptAssessment(attempt.metadata);
-      validateAssessmentResponses(assessment, attempt.metadata.responses);
-      const itemResults = attempt.metadata.purpose === "review" ? committedReviewItemResults(attempt.metadata, assessment) : await this.scoreItems({
-        assessment,
-        responses: attempt.metadata.responses,
-        artifactIdentity: assessmentArtifactIdentityFromAttempt(attempt.metadata),
-        purpose: attempt.metadata.purpose
-      });
-      return {
-        responseVersion: attempt.metadata.responseVersion,
-        assessment,
-        itemResults,
-        score: aggregateAssessmentScore(itemResults.map((result) => result.score.earned), itemResults.reduce((total, result) => total + result.score.possible, 0)),
-        correctQuestions: countCorrectQuestions(itemResults.map((result) => result.isCorrect))
-      };
-    }
-    async peekAttempt({
-      studentId,
-      attemptId
-    }) {
-      const result = await this.requireClient().api.oneroster.assessmentResults.get(attemptId).catch((error88) => {
-        if (isApiError(error88) && error88.statusCode === 404) {
-          throw this.unauthorizedAttempt(attemptId);
-        }
-        throw error88;
+    recordTranscriptFailure(operation, attemptId, error88) {
+      addEvent("assessment.transcript_operation_failed", {
+        "app.assessment.operation": operation,
+        "app.assessment.attempt_id": attemptId,
+        "exception.type": errorType(error88),
+        "app.error.message": errorMessage(error88)
       });
-      const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
-      if (!metadata2 || result.student.sourcedId !== studentId || result.status !== ONEROSTER_STATUS2.active) {
-        throw this.unauthorizedAttempt(attemptId);
-      }
-      return { result, metadata: metadata2 };
-    }
-    async prepareSubmission(params, input) {
-      try {
-        const attempt = await this.peekAttempt(params);
-        const disposition = classifyAssessmentSubmission({
-          inProgress: attempt.result.inProgress ?? "",
-          scoreStatus: attempt.result.scoreStatus,
-          submissionId: attempt.metadata.submissionId
-        }, input.submissionId);
-        if (disposition !== "submit") {
-          return null;
-        }
-        if (this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-          return null;
-        }
-        return await this.scoreSubmission(attempt);
-      } catch (error88) {
-        addEvent("assessment.submission_preview_failed", {
-          "app.assessment.attempt_id": params.attemptId,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-        return null;
-      }
     }
     async submit({
       input,
@@ -104833,121 +104417,83 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       ...params
     }) {
       await this.deps.validateDeveloperAccess(params.user, params.gameId);
-      const preview = await this.prepareSubmission(params, input);
-      const submission = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-        const { attempt: identity, enrollment } = await this.resolveAttemptAuthorization(params, { db: db2, developerAccessValidated: true });
-        const submissionDisposition = classifyAssessmentSubmission({
-          inProgress: identity.result.inProgress ?? "",
-          scoreStatus: identity.result.scoreStatus,
-          submissionId: identity.metadata.submissionId
-        }, input.submissionId);
-        if (submissionDisposition === "replay") {
+      const transcript = parseAssessmentTranscript(input.transcript);
+      const request = { ...input, transcript };
+      const requestHash = await assessmentTranscriptRequestHash(request);
+      const accepted = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
+        const { attempt } = await this.resolveAttemptAuthorization(params, {
+          db: db2,
+          developerAccessValidated: true,
+          includeEnrollment: false
+        });
+        const disposition = resolveAssessmentTranscriptSubmission(attempt.result, attempt.metadata, attempt.integration.status, request, requestHash);
+        if (disposition === "replay") {
           return {
-            response: this.submittedResult(identity.result, identity.metadata),
-            emission: this.replayCompletion(identity, input.submissionId, params, game2)
+            response: this.submittedResult(attempt.result, attempt.metadata),
+            emission: this.replayCompletion(attempt, input.submissionId, params, game2)
           };
         }
-        const attempt = this.requireActiveAttempt({ attempt: identity, enrollment }, params.attemptId);
-        if (submissionDisposition === "reject") {
-          throw AssessmentRuntimeError.from(assessmentAlreadySubmitted(attempt.result.sourcedId));
-        }
-        if (input.session && input.session.runId !== attempt.result.sourcedId) {
-          throw new ValidationError("Assessment session runId must match the attemptId.");
-        }
-        this.assertResponseVersion(attempt.metadata, input.expectedResponseVersion);
-        if (this.isPlatformRoutedDiagnosticMetadata(attempt.metadata)) {
-          return this.finalizeDiagnosticSubmission({
-            attempt: { ...attempt, metadata: attempt.metadata },
-            input,
-            params,
-            game: game2,
-            db: db2
-          });
-        }
-        if (assessmentFlowForPurpose(attempt.metadata.purpose) === "item-submit") {
-          const assessment2 = await this.loadAttemptAssessment(attempt.metadata);
-          const flowFailure = assessmentCompletionFlowFailure(attempt.metadata.purpose, attempt.metadata.itemSubmissions, assessment2.items.length);
-          if (flowFailure) {
-            throw AssessmentRuntimeError.from(flowFailure);
-          }
-        }
-        const scored = preview && preview.responseVersion === attempt.metadata.responseVersion ? preview : await this.scoreSubmission(attempt);
-        const { assessment, itemResults, score, correctQuestions } = scored;
-        const client2 = this.requireClient();
+        const graded = await this.gradeTranscript({
+          attemptId: params.attemptId,
+          metadata: attempt.metadata
+        }, transcript, true, db2);
+        const diagnostic = this.isPlatformRoutedDiagnosticMetadata(graded.metadata) ? summarizeDiagnosticSubmission(graded.metadata, graded.manifest) : null;
+        const itemOutcomes = graded.metadata.purpose === "review" ? assessmentReviewTranscriptOutcomes({
+          metadata: graded.metadata,
+          itemResults: graded.itemResults
+        }) : undefined;
+        const courseName = attempt.metadata.courseName ?? "Game Course";
         const timestamp6 = new Date().toISOString();
-        const reviewOutcomes = attempt.metadata.purpose === "review" ? this.reviewItemOutcomes({
-          metadata: attempt.metadata,
-          itemResults
-        }) : null;
         const finalization = buildAssessmentResultSubmission({
           result: attempt.result,
-          metadata: attempt.metadata,
-          score,
+          metadata: graded.metadata,
+          score: graded.score,
           submissionId: input.submissionId,
           timestamp: timestamp6,
-          testName: assessment.title,
-          courseName: attempt.enrollment.course.title,
-          totalQuestions: itemResults.length,
-          correctQuestions,
+          testName: graded.assessment.title,
+          courseName,
+          totalQuestions: graded.itemResults.length,
+          correctQuestions: graded.correctQuestions,
           ...input.session ? { session: input.session } : {},
-          ...reviewOutcomes ? { itemOutcomes: reviewOutcomes } : {}
+          ...itemOutcomes ? { itemOutcomes } : {},
+          ...diagnostic ? { diagnosticTracks: diagnostic.tracks } : {}
         });
-        const metadata2 = finalization.metadata;
-        const submitted = await client2.api.oneroster.assessmentResults.upsert(attempt.result.sourcedId, finalization.resultUpdate);
-        const submittedForEmission = {
-          ...submitted,
-          score: score.normalized * 100,
-          scoreDate: timestamp6,
-          ...ASSESSMENT_ATTEMPT_AWAITING_AWARD,
-          metadata: finalization.resultUpdate.metadata
+        const metadata2 = {
+          ...finalization.metadata,
+          completion: { ...finalization.metadata.completion, requestHash }
+        };
+        const resultUpdate = {
+          ...finalization.resultUpdate,
+          metadata: mergeAssessmentRuntimeMetadata(attempt.result.metadata, metadata2)
+        };
+        await this.requireClient().api.oneroster.assessmentResults.upsert(params.attemptId, resultUpdate);
+        const result = { ...attempt.result, ...resultUpdate };
+        const emission = {
+          attempt: { ...attempt, result, metadata: metadata2 },
+          testIdentifier: graded.assessment.identifier,
+          testName: graded.assessment.title,
+          score: graded.score,
+          totalQuestions: graded.itemResults.length,
+          correctQuestions: graded.correctQuestions,
+          submissionId: input.submissionId,
+          gameId: params.gameId,
+          studentId: params.studentId,
+          courseName,
+          game: game2
         };
-        addEvent("assessment.awaiting_award_created", {
-          "app.assessment.attempt_id": submittedForEmission.sourcedId,
-          "app.assessment.submission_id": input.submissionId,
-          "app.assessment.purpose": metadata2.purpose,
-          "app.assessment.response_version": metadata2.responseVersion
-        });
         return {
-          response: {
-            attemptId: submittedForEmission.sourcedId,
-            submissionId: input.submissionId,
-            responseVersion: metadata2.responseVersion,
-            status: "awaiting_award",
-            responses: metadata2.responses,
-            score,
-            ...metadata2.purpose === "review" ? {
-              purpose: metadata2.purpose,
-              itemOutcomes: reviewOutcomes
-            } : { purpose: metadata2.purpose }
-          },
-          emission: {
-            attempt: { ...attempt, result: submittedForEmission, metadata: metadata2 },
-            testIdentifier: assessment.identifier,
-            testName: assessment.title,
-            score,
-            totalQuestions: itemResults.length,
-            correctQuestions,
-            submissionId: input.submissionId,
-            gameId: params.gameId,
-            studentId: params.studentId,
-            courseName: attempt.enrollment.course.title,
-            game: game2
-          }
+          response: this.submittedResult(result, metadata2),
+          emission,
+          repair: { context: this.tokenContext(attempt), graded }
         };
       });
-      if (submission.emission) {
-        const diagnosticCompletion = this.isPlatformRoutedDiagnosticMetadata(submission.emission.attempt.metadata) ? {
-          ...submission.emission.attempt,
-          metadata: submission.emission.attempt.metadata
-        } : null;
-        const { result, metadata: metadata2 } = submission.emission.attempt;
-        await Promise.allSettled([
-          this.emitSessionBestEffort(submission.emission),
-          ...diagnosticCompletion ? [this.restoreDiagnosticChildResults(diagnosticCompletion)] : [],
-          ...metadata2.purpose === "review" ? [this.restoreAllCompletedReviewChildResponses(result, metadata2)] : []
-        ]);
+      if (accepted.repair) {
+        this.reconcileTranscriptChildren(accepted.repair.context, accepted.repair.graded).catch((error88) => this.recordTranscriptFailure("completion_repair", params.attemptId, error88));
+      }
+      if (accepted.emission) {
+        this.emitSessionBestEffort(accepted.emission);
       }
-      return submission.response;
+      return accepted.response;
     }
     async finalize({
       input,
@@ -105091,58 +104637,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async finalizeDiagnosticSubmission(input) {
-      const { attempt } = input;
-      const routing = await this.loadAttemptDiagnosticManifest(attempt.metadata, input.db);
-      const { tracks, score, correctQuestions } = summarizeDiagnosticSubmission(attempt.metadata, routing.manifest);
-      const timestamp6 = new Date().toISOString();
-      const finalization = buildAssessmentResultSubmission({
-        result: attempt.result,
-        metadata: attempt.metadata,
-        score,
-        submissionId: input.input.submissionId,
-        timestamp: timestamp6,
-        testName: attempt.metadata.diagnostic.testName,
-        courseName: attempt.enrollment.course.title,
-        totalQuestions: attempt.metadata.itemSubmissions.length,
-        correctQuestions,
-        ...input.input.session ? { session: input.input.session } : {},
-        diagnosticTracks: tracks
-      });
-      const metadata2 = finalization.metadata;
-      const submitted = await this.requireClient().api.oneroster.assessmentResults.upsert(attempt.result.sourcedId, finalization.resultUpdate);
-      const submittedForEmission = {
-        ...submitted,
-        score: score.normalized * 100,
-        scoreDate: timestamp6,
-        ...ASSESSMENT_ATTEMPT_AWAITING_AWARD,
-        metadata: finalization.resultUpdate.metadata
-      };
-      return {
-        response: {
-          purpose: "diagnostic",
-          attemptId: submittedForEmission.sourcedId,
-          submissionId: input.input.submissionId,
-          diagnosticKey: metadata2.diagnostic.diagnosticKey,
-          responseVersion: metadata2.responseVersion,
-          status: "awaiting_award",
-          tracks
-        },
-        emission: {
-          attempt: { ...attempt, result: submittedForEmission, metadata: metadata2 },
-          testIdentifier: attempt.metadata.selectedTest.identifier,
-          testName: attempt.metadata.diagnostic.testName,
-          score,
-          totalQuestions: attempt.metadata.itemSubmissions.length,
-          correctQuestions,
-          submissionId: input.input.submissionId,
-          gameId: input.params.gameId,
-          studentId: input.params.studentId,
-          courseName: attempt.enrollment.course.title,
-          game: input.game
-        }
-      };
-    }
     async exportFixture({
       gameId,
       user
@@ -105263,28 +104757,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         liveTestIntegrationIds: integrationIdsWithLiveTests
       };
     }
-    async selectIntegration(candidates, studentId, input, results) {
-      const {
-        rows: candidateRows,
-        enrollmentByCourse,
-        liveTestIntegrationIds: integrationIdsWithLiveTests
-      } = candidates;
-      const needsOpenAnnotation = candidateRows.length > 1 || candidateRows.some((row) => !integrationIdsWithLiveTests.has(row.id));
-      const openAttemptScope = {
-        studentId,
-        activityId: input.activityId,
-        purpose: input.purpose,
-        enrollmentIdByCourse: new Map(candidateRows.map((row) => [row.courseId, enrollmentByCourse.get(row.courseId).id])),
-        requestFingerprint: this.startRequestFingerprint(input)
-      };
-      let openAttemptCourseIds = new Set;
-      if (needsOpenAnnotation) {
-        openAttemptCourseIds = results ? this.openAttemptCourseIdsFromResults(results, openAttemptScope) : await this.openAttemptCourseIds(openAttemptScope);
-      }
+    async selectIntegration(candidates, input) {
+      const { rows: candidateRows, enrollmentByCourse, liveTestIntegrationIds } = candidates;
       const annotated = candidateRows.map((row) => ({
         ...row,
-        hasLiveTests: integrationIdsWithLiveTests.has(row.id),
-        hasOpenAttempt: openAttemptCourseIds.has(row.courseId)
+        hasLiveTests: liveTestIntegrationIds.has(row.id)
       }));
       const selection = selectAssessmentCourseCandidate(annotated, Boolean(input.subject));
       if (selection.outcome === "none") {
@@ -105313,9 +104790,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         standard: assessmentStandardForRow(row)
       })).filter((test) => !matchesMasteryStandard || matchesMasteryStandard(test.standard));
     }
-    async openAttemptCourseIds(scope) {
-      return this.openAttemptCourseIdsFromResults(await this.studentAssessmentResults(scope.studentId), scope);
-    }
     async studentAssessmentResults(studentId) {
       const stream = this.requireClient().api.oneroster.assessmentResults.stream({
         where: {
@@ -105329,29 +104803,37 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return results;
     }
-    openAttemptCourseIdsFromResults(results, scope) {
-      const courseIds = new Set;
-      for (const result of results) {
-        const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
-        if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && this.attemptMatchesRequestFingerprint(metadata2, scope.requestFingerprint) && result.student.sourcedId === scope.studentId && metadata2.enrollmentId === scope.enrollmentIdByCourse.get(metadata2.courseId) && (this.isOpen(result) || this.isAwaitingAward(result))) {
-          courseIds.add(metadata2.courseId);
-        }
-      }
-      return courseIds;
-    }
     async listAttempts(scope) {
       return this.attemptListing(await this.studentAssessmentResults(scope.studentId), scope);
     }
-    attemptListing(results, scope) {
+    async attemptListing(results, scope) {
       const attempts = new Map;
       const reviewChildren = new Map;
       for (const result of results) {
         const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
-        const childMetadata = scope.purpose === "review" ? playcademyAssessmentItemResultMetadata(result.metadata) : null;
-        if (childMetadata && childMetadata.activityId === scope.activityId && childMetadata.integrationId === scope.integrationId && childMetadata.enrollmentId === scope.enrollmentId && result.student.sourcedId === scope.studentId) {
-          reviewChildren.set(result.sourcedId, result);
+        if (scope.purpose === "review") {
+          const verified = await verifyAssessmentChildResultCommand(result.metadata);
+          if (verified.ok && verified.command.payload.context.kind === "review") {
+            const { command } = verified;
+            const { attempt, administration } = command.payload;
+            const parent = await reviewQuestionLineItemId(await deterministicUUID([
+              "playcademy:review-bank-line-item:v1",
+              scope.integrationId,
+              scope.activityId,
+              attempt.selectedTest.identifier,
+              verified.command.payload.context.bankRevision
+            ].join("\x00")), administration.itemIdentifier);
+            const projection = await classifyAssessmentChildResult({
+              result,
+              command,
+              childLineItemId: parent
+            });
+            if (attempt.activityId === scope.activityId && attempt.integrationId === scope.integrationId && attempt.enrollmentId === scope.enrollmentId && attempt.courseId === scope.courseId && attempt.studentId === scope.studentId && result.sourcedId === await assessmentChildResultId(attempt.attemptId, administration.submissionId) && projection.outcome === "replay") {
+              reviewChildren.set(result.sourcedId, command);
+            }
+          }
         }
-        if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && metadata2.courseId === scope.courseId && metadata2.integrationId === scope.integrationId && result.student.sourcedId === scope.studentId) {
+        if (metadata2 && this.attemptInScope(result, metadata2, scope)) {
           const selectedAssessmentKey = metadata2.selectedTest.assessmentKey ?? assessmentKeyFromManagedQtiIdentifier(metadata2.selectedTest.identifier);
           if (selectedAssessmentKey) {
             attempts.set(result.sourcedId, {
@@ -105360,12 +104842,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               selection: {
                 attemptId: result.sourcedId,
                 selectedAssessmentKey,
-                selectedTestIdentifier: metadata2.selectedTest.identifier,
                 inProgress: result.inProgress ?? "",
                 scoreStatus: result.scoreStatus,
-                scoreDate: result.scoreDate,
-                updatedAt: result.dateLastModified ?? metadata2.updatedAt,
-                resumable: metadata2.enrollmentId === scope.enrollmentId
+                scoreDate: result.scoreDate
               }
             });
           }
@@ -105373,147 +104852,61 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return { attempts, reviewChildren };
     }
-    attemptsMatchingRequest(attempts, requestFingerprint) {
-      if (requestFingerprint === undefined) {
-        return attempts;
-      }
-      return new Map([...attempts].filter(([, attempt]) => this.attemptMatchesRequestFingerprint(attempt.metadata, requestFingerprint)));
-    }
-    startRequestFingerprint(input) {
-      if (input.purpose === "review") {
-        return reviewRequestFingerprint(input, DEFAULT_REVIEW_SELECTION_POLICY);
-      }
-      if (input.purpose === "mastery") {
-        return masteryRequestFingerprint(input);
-      }
-      return input.purpose === "diagnostic" ? input.diagnosticKey : undefined;
-    }
-    attemptMatchesRequestFingerprint(metadata2, requestFingerprint) {
-      if (metadata2.purpose === "review") {
-        return metadata2.review.requestFingerprint === requestFingerprint;
-      }
-      if (metadata2.purpose === "mastery") {
-        return metadata2.mastery.requestFingerprint === requestFingerprint;
-      }
-      if (metadata2.purpose === "diagnostic" && requestFingerprint !== undefined) {
-        return this.isPlatformRoutedDiagnosticMetadata(metadata2) && metadata2.diagnostic.diagnosticKey === requestFingerprint;
-      }
-      return true;
-    }
-    reviewExposures(results, scope) {
-      const exposures = [];
-      for (const result of results) {
-        const metadata2 = playcademyAssessmentItemResultMetadata(result.metadata);
-        if (metadata2?.bankRevision === scope.bankRevision) {
-          exposures.push({
-            itemIdentifier: metadata2.itemIdentifier,
-            deliveredAt: metadata2.deliveredAt
-          });
-        }
-      }
-      return exposures;
-    }
-    requireDecision(decision, purpose) {
+    selectFreshStart(tests, listing, purpose) {
+      const decision = selectRuntimeAssessment(tests, [...listing.attempts.values()].map((entry) => entry.selection));
       if (!decision) {
         throw AssessmentRuntimeError.from(assessmentNoEligibleTests(purpose));
       }
       return decision;
     }
-    resumeSnapshot(decision, attempts, integration) {
-      if (decision.additionalResumableAttemptIds.length > 0) {
-        addEvent("assessment.multiple_resumable_attempts", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.additional_attempt_ids": decision.additionalResumableAttemptIds.join(",")
-        });
-      }
-      const resumed = attempts.get(decision.attempt.attemptId);
-      return this.snapshotForResult(resumed.result, resumed.metadata, integration);
+    pendingAwardAttempt(listing, enrollmentId) {
+      const pending = [...listing.attempts.values()].filter((attempt) => attempt.metadata.enrollmentId === enrollmentId && this.isAwaitingAward(attempt.result));
+      return pending.toSorted((left, right) => compareNewestCompletedAssessmentAttempt(left.selection, right.selection))[0] ?? null;
     }
-    async resumeDiagnosticSnapshot(decision, attempts, integration, db2 = this.deps.db) {
-      if (decision.additionalResumableAttemptIds.length > 0) {
-        addEvent("assessment.multiple_resumable_attempts", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.additional_attempt_ids": decision.additionalResumableAttemptIds.join(",")
-        });
-      }
-      const resumed = attempts.get(decision.attempt.attemptId);
-      if (this.isSettled(resumed.result)) {
-        return this.snapshotForResult(resumed.result, resumed.metadata, integration);
-      }
-      if (!this.isPlatformRoutedDiagnosticMetadata(resumed.metadata)) {
-        throw new Error("A keyed diagnostic request selected a legacy fixed attempt");
+    async pendingAwardSnapshot(listing, context2) {
+      const pending = this.pendingAwardAttempt(listing, context2.enrollment.id);
+      if (!pending) {
+        return null;
       }
-      const assessment = await this.loadAttemptAssessment(resumed.metadata);
-      const routing = await this.loadAttemptDiagnosticRouting(resumed.metadata, assessment, db2);
-      await this.restoreDiagnosticChildResults({
-        result: resumed.result,
-        metadata: resumed.metadata,
-        integration,
-        assessment
+      addEvent("assessment.pending_award_returned", {
+        "app.assessment.attempt_id": pending.result.sourcedId
       });
-      return this.diagnosticSnapshot(resumed.result, resumed.metadata, assessment, integration, routing.state);
-    }
-    async resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, resume) {
-      const select3 = () => selectRuntimeAssessment(tests, [...this.attemptsMatchingRequest(attempts, requestFingerprint).values()].map((entry) => entry.selection));
-      return resolveAvailableAssessmentAttempt(select3(), select3, (decision) => this.resumeSnapshotOrStageSupersession(decision, attempts, pendingSupersessions, () => resume(decision)));
+      return this.snapshotForResult(pending.result, pending.metadata, context2.integration);
     }
-    async resumeSnapshotOrStageSupersession(decision, attempts, pendingSupersessions, resume) {
-      try {
-        return await resume();
-      } catch (error88) {
-        if (!(error88 instanceof AssessmentRuntimeError) || error88.runtimeCode !== "SELECTED_TEST_VERSION_UNAVAILABLE") {
-          throw error88;
+    replacedAttemptIds(attempts, enrollmentId) {
+      const replaced = new Set;
+      for (const attempt of attempts.values()) {
+        if (attempt.metadata.enrollmentId === enrollmentId && this.isOpen(attempt.result)) {
+          replaced.add(attempt.result.sourcedId);
         }
-        if (shouldConfirmAssessmentVersionUnavailable(error88.details)) {
-          await sleep(TimebackAssessmentRuntimeService.ASSESSMENT_VERSION_CONFIRMATION_DELAY_MS);
-          try {
-            return await resume();
-          } catch (confirmationError) {
-            if (!(confirmationError instanceof AssessmentRuntimeError) || confirmationError.runtimeCode !== "SELECTED_TEST_VERSION_UNAVAILABLE") {
-              throw confirmationError;
-            }
-          }
-        }
-        const staged = attempts.get(decision.attempt.attemptId);
-        pendingSupersessions.add(staged.result.sourcedId);
-        stageAssessmentAttemptSupersession(staged);
-        addEvent("assessment.attempt_supersession_staged", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.reason": "selected_test_version_unavailable"
-        });
-        return null;
       }
+      return replaced;
+    }
+    supersedeReplacedAttempts(db2, attempts, enrollmentId) {
+      return this.supersedeAttemptsBestEffort(db2, this.replacedAttemptIds(attempts, enrollmentId));
     }
-    async persistPendingSupersessions(db2, attemptIds) {
+    async supersedeAttempts(db2, attemptIds) {
       for (const attemptId of [...attemptIds].toSorted()) {
         await this.deps.assessmentRuntimeLock(db2, [assessmentRuntimeAttemptLockKey(attemptId)], async () => {
-          let result;
-          try {
-            result = await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
-          } catch (error88) {
-            if (isApiError(error88) && error88.statusCode === 404) {
-              return;
-            }
-            throw error88;
-          }
-          const update2 = buildAssessmentAttemptSupersessionUpdate(result);
+          const result = await this.findAttemptResult(attemptId);
+          const update2 = result && buildAssessmentAttemptSupersessionUpdate(result);
           if (!update2) {
             return;
           }
           await this.requireClient().api.oneroster.assessmentResults.upsert(attemptId, update2);
           addEvent("assessment.attempt_superseded", {
             "app.assessment.attempt_id": attemptId,
-            "app.assessment.reason": "selected_test_version_unavailable"
+            "app.assessment.reason": "replaced_by_fresh_start"
           });
         });
       }
     }
-    async persistPendingSupersessionsBestEffort(db2, attemptIds) {
+    async supersedeAttemptsBestEffort(db2, attemptIds) {
       if (attemptIds.size === 0) {
         return;
       }
       try {
-        await this.persistPendingSupersessions(db2, attemptIds);
+        await this.supersedeAttempts(db2, attemptIds);
       } catch (error88) {
         addEvent("assessment.attempt_supersession_persist_failed", {
           "app.assessment.attempt_ids": [...attemptIds].toSorted().join(","),
@@ -105522,43 +104915,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async resumeReviewSnapshot(decision, attempts, existingChildResults, context2) {
-      if (decision.additionalResumableAttemptIds.length > 0) {
-        addEvent("assessment.multiple_resumable_attempts", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.additional_attempt_ids": decision.additionalResumableAttemptIds.join(",")
-        });
-      }
-      const resumed = attempts.get(decision.attempt.attemptId);
-      if (resumed.metadata.purpose !== "review") {
-        throw new Error("A standards-review request selected a non-review attempt");
-      }
-      const reviewMetadata = resumed.metadata;
-      let assessment;
-      const current = await reconcileReviewChildResults({
-        initial: resumed,
-        writeOpen: async () => {
-          const source = await this.loadPinnedReviewBankSource(reviewMetadata);
-          assessment = projectReviewAssessment(source.assessment, source.bank, reviewMetadata.review.selections);
-          await this.ensureReviewChildResults({
-            result: resumed.result,
-            metadata: reviewMetadata,
-            integration: context2.integration,
-            source,
-            assessment,
-            existingChildResults,
-            lookupMissingResults: true
-          });
-        },
-        crossBarrier: () => crossAssessmentAttemptLockBarrier(this.deps.assessmentRuntimeLock, this.deps.db, resumed.result.sourcedId),
-        readLatest: () => this.peekAttempt({
-          studentId: resumed.result.student.sourcedId,
-          attemptId: resumed.result.sourcedId
-        }),
-        restoreTerminal: (latest) => this.restoreAllCompletedReviewChildResponses(latest.result, latest.metadata)
-      });
-      return assessmentChildProjectionIsTerminal(current.result) ? this.snapshotForResult(current.result, current.metadata, context2.integration) : this.snapshot(current.result, current.metadata, assessment, context2.integration);
-    }
     recordReviewPreparationPhase(phase, startedAt, counts = {}) {
       addEvent("assessment.review_preparation_phase", {
         "app.assessment.review_phase": phase,
@@ -105909,12 +105265,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           }
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        addEvent("assessment.line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
+        await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
       }
       return lineItemId;
     }
@@ -105956,144 +105307,99 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           }
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        addEvent("assessment.review_bank_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
+        await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.review_bank_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
       }
       return lineItemId;
     }
-    assessmentChildAttempt(attempt) {
-      const { metadata: metadata2 } = attempt;
-      const assessmentKey = metadata2.selectedTest.assessmentKey ?? assessmentKeyFromManagedQtiIdentifier(metadata2.selectedTest.identifier);
-      if (!assessmentKey) {
-        addEvent("assessment.child_result_legacy_attempt_skipped", {
-          "app.assessment.attempt_id": attempt.result.sourcedId
-        });
-        return null;
+    async confirmLineItemAfterRefusedCreate(lineItemId, createError, event, read) {
+      let stored;
+      try {
+        stored = await read();
+      } catch (readError) {
+        if (isApiError(readError) && readError.statusCode === 404) {
+          throw createError;
+        }
+        throw readError;
       }
+      addEvent(event, {
+        "app.assessment.line_item_id": lineItemId,
+        ...isApiError(createError) ? { "app.timeback.status": createError.statusCode } : {}
+      });
+      return stored;
+    }
+    tokenContext(attempt) {
       return {
-        attemptId: attempt.result.sourcedId,
+        version: 1,
         gameId: attempt.integration.gameId,
         studentId: attempt.result.student.sourcedId,
-        activityId: metadata2.activityId,
-        courseId: metadata2.courseId,
-        integrationId: metadata2.integrationId,
-        enrollmentId: metadata2.enrollmentId,
-        selectedTest: {
-          assessmentKey,
-          identifier: metadata2.selectedTest.identifier,
-          contentRevision: metadata2.selectedTest.contentRevision
-        }
-      };
-    }
-    reviewChildResultContext(metadata2, submission) {
-      const selection = metadata2.review.selections.find((candidate) => candidate.itemIdentifier === submission.itemIdentifier);
-      if (!selection) {
-        throw new Error(`Committed review item ${submission.itemIdentifier} is not in its pinned selection`);
-      }
-      return {
-        kind: "review",
-        bankRevision: metadata2.review.bankRevision,
-        standard: selection.standard
+        attemptId: attempt.result.sourcedId,
+        parentLineItemId: attempt.result.assessmentLineItem.sourcedId,
+        metadata: assessmentTokenMetadata(attempt.metadata)
       };
     }
-    prepareReviewAssessmentChildResult(input) {
-      return this.prepareAssessmentChildResult({
-        attempt: input.attempt,
-        metadata: input.metadata,
-        submission: input.submission,
-        context: () => this.reviewChildResultContext(input.metadata, input.submission)
+    async ensureTranscriptLineItems(context2, assessment) {
+      await runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (item) => {
+        const id = await assessmentTranscriptChildLineItemId(context2, item.identifier);
+        if (this.childLineItemCache.get(id)) {
+          return;
+        }
+        const metadata2 = context2.metadata;
+        const common2 = {
+          parentLineItemId: context2.parentLineItemId,
+          integration: { courseId: metadata2.courseId },
+          item
+        };
+        if (metadata2.purpose === "review") {
+          const standard = metadata2.review.selections.find((selection) => selection.itemIdentifier === item.identifier)?.standard;
+          if (!standard) {
+            throw new Error("Review candidate is not in the pinned selection");
+          }
+          await this.ensureReviewQuestionLineItem({
+            ...common2,
+            bankRevision: metadata2.review.bankRevision,
+            standards: [standard]
+          });
+        } else if (this.isPlatformRoutedDiagnosticMetadata(metadata2)) {
+          await this.ensureDiagnosticQuestionLineItem({ ...common2, metadata: metadata2 });
+        } else {
+          const expected = {
+            status: "active",
+            parentAssessmentLineItem: { sourcedId: context2.parentLineItemId },
+            course: { sourcedId: metadata2.courseId },
+            resultValueMin: 0,
+            resultValueMax: item.maxScore,
+            metadata: {
+              playcademyAssessmentQuestionDefinition: {
+                version: 1,
+                itemIdentifier: item.identifier,
+                contentRevision: metadata2.selectedTest.contentRevision
+              }
+            }
+          };
+          const store = this.requireClient().api.oneroster.assessmentLineItems;
+          try {
+            await store.create({ sourcedId: id, title: item.title, ...expected });
+          } catch (error88) {
+            this.assertAssessmentChildLineItem(id, await this.confirmLineItemAfterRefusedCreate(id, error88, "assessment.question_line_item_create_conflict", () => store.get(id)), expected);
+          }
+        }
+        this.childLineItemCache.set(id, true);
       });
     }
-    prepareDiagnosticAssessmentChildResult(input) {
-      return this.prepareAssessmentChildResult({
-        attempt: input.attempt,
-        metadata: input.metadata,
-        submission: input.submission,
-        context: () => ({
-          kind: "platform-routed-diagnostic",
-          definitionId: input.metadata.diagnostic.definitionId,
-          diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-          routingRevision: input.metadata.diagnostic.routingRevision,
-          transition: input.transition
+    async reconcileTranscriptChildren(context2, graded, only) {
+      return reconcileAssessmentTranscriptChildren({
+        context: context2,
+        graded,
+        only,
+        assessmentResults: this.requireClient().api.oneroster.assessmentResults,
+        ensureLineItems: (assessment) => this.ensureTranscriptLineItems(context2, assessment),
+        onPersisted: (submissionId) => addEvent("assessment.child_result_persisted", {
+          "app.assessment.attempt_id": context2.attemptId,
+          "app.assessment.submission_id": submissionId,
+          "app.assessment.child_result_outcome": "upserted"
         })
       });
     }
-    async prepareAssessmentChildResult(input) {
-      try {
-        const attemptContext = this.assessmentChildAttempt({
-          ...input.attempt,
-          metadata: input.metadata
-        });
-        if (!attemptContext) {
-          return null;
-        }
-        const parentLineItemId = input.attempt.result.assessmentLineItem.sourcedId;
-        const { itemIdentifier } = input.submission;
-        const context2 = input.context();
-        const [command, childLineItemId] = await Promise.all([
-          buildSubmissionChildResultCommand({
-            attempt: attemptContext,
-            submission: input.submission,
-            responses: input.metadata.responses[itemIdentifier],
-            grading: input.submission.grading ?? QTI_CHILD_GRADING,
-            context: context2
-          }),
-          context2.kind === "review" ? reviewQuestionLineItemId(parentLineItemId, itemIdentifier) : diagnosticQuestionLineItemId(parentLineItemId, itemIdentifier)
-        ]);
-        return { command, childLineItemId };
-      } catch (error88) {
-        addEvent("assessment.child_result_prepare_failed", {
-          "app.assessment.attempt_id": input.attempt.result.sourcedId,
-          "app.assessment.submission_id": input.submission.submissionId,
-          "app.assessment.qti_item_identifier": input.submission.itemIdentifier,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-        return null;
-      }
-    }
-    async projectPreparedAssessmentChildResult(prepared) {
-      if (!prepared) {
-        return;
-      }
-      const startedAt = Date.now();
-      const identity = {
-        "app.assessment.attempt_id": prepared.command.payload.attempt.attemptId,
-        "app.assessment.submission_id": prepared.command.payload.administration.submissionId
-      };
-      try {
-        const disposition = await persistAssessmentChildResult({
-          assessmentResults: this.requireClient().api.oneroster.assessmentResults,
-          command: prepared.command,
-          childLineItemId: prepared.childLineItemId
-        });
-        if (disposition.outcome === "conflict") {
-          addEvent("assessment.child_result_conflict", {
-            ...identity,
-            "app.assessment.child_result_id": disposition.resultId,
-            "app.assessment.child_result_conflict_reason": disposition.reason
-          });
-          return;
-        }
-        addEvent("assessment.child_result_persisted", {
-          ...identity,
-          "app.assessment.child_result_id": disposition.resultId,
-          "app.assessment.child_result_outcome": disposition.outcome,
-          "app.assessment.duration_ms": Date.now() - startedAt
-        });
-      } catch (error88) {
-        addEvent("assessment.child_result_persist_failed", {
-          ...identity,
-          "app.assessment.duration_ms": Date.now() - startedAt,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-      }
-    }
     assertAssessmentChildLineItem(lineItemId, stored, expected) {
       if (assessmentChildLineItemMatches(stored, expected)) {
         return;
@@ -106140,102 +105446,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...expected
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.diagnostic_question_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
         this.assertAssessmentChildLineItem(lineItemId, stored, expected);
-        addEvent("assessment.diagnostic_question_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
       }
       return lineItemId;
     }
-    async projectDiagnosticItemResponse(projection, assessment, checkpoint = null) {
-      try {
-        const loadedAssessment = assessment ?? await this.loadAttemptAssessment(projection.metadata);
-        const item = loadedAssessment.items.find((candidate) => candidate.identifier === projection.ledgerEntry.itemIdentifier);
-        if (!item) {
-          throw new Error(`Diagnostic assessment is missing item ${projection.ledgerEntry.itemIdentifier}`);
-        }
-        const childLineItemId = await this.ensureDiagnosticQuestionLineItem({
-          parentLineItemId: projection.result.assessmentLineItem.sourcedId,
-          integration: projection.integration,
-          metadata: projection.metadata,
-          item
-        });
-        if (checkpoint && checkpoint.childLineItemId !== childLineItemId) {
-          throw new Error("Prepared diagnostic checkpoint resolved a different line item");
-        }
-        const childResultId = await diagnosticQuestionResultId(projection.result.sourcedId, childLineItemId);
-        const finalized = buildFinalizedDiagnosticChildResult({
-          childLineItemId,
-          student: projection.result.student,
-          parentAttemptId: projection.result.sourcedId,
-          metadata: projection.metadata,
-          ledgerEntry: projection.ledgerEntry
-        });
-        await Promise.all([
-          this.projectPreparedAssessmentChildResult(checkpoint),
-          this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, finalized.resultUpdate)
-        ]);
-      } catch (error88) {
-        addEvent("assessment.diagnostic_child_projection_failed", {
-          "app.assessment.attempt_id": projection.result.sourcedId,
-          "app.assessment.qti_item_identifier": projection.ledgerEntry.itemIdentifier,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-      }
-    }
-    async restoreDiagnosticChildResults(attempt) {
-      const assessment = attempt.assessment ?? await this.loadAttemptAssessment(attempt.metadata);
-      await runWithConcurrency(attempt.metadata.diagnostic.ledger, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (ledgerEntry) => {
-        try {
-          const childLineItemId = await diagnosticQuestionLineItemId(attempt.result.assessmentLineItem.sourcedId, ledgerEntry.itemIdentifier);
-          const childResultId = await diagnosticQuestionResultId(attempt.result.sourcedId, childLineItemId);
-          let childResult;
-          try {
-            childResult = await this.requireClient().api.oneroster.assessmentResults.get(childResultId);
-          } catch (error88) {
-            if (!isApiError(error88) || error88.statusCode !== 404) {
-              throw error88;
-            }
-          }
-          const resolution = resolveDiagnosticChildResult({
-            childResult,
-            childLineItemId,
-            parentResult: attempt.result,
-            parentMetadata: attempt.metadata,
-            ledgerEntry
-          });
-          if (resolution.action === "reuse") {
-            return;
-          }
-          if (resolution.action === "restore") {
-            addEvent("assessment.diagnostic_child_result_restore", {
-              "app.assessment.diagnostic_child_restore_reason": resolution.reason,
-              "app.assessment.attempt_id": attempt.result.sourcedId,
-              "app.assessment.child_result_id": childResultId,
-              "app.assessment.qti_item_identifier": ledgerEntry.itemIdentifier
-            });
-          }
-          await this.projectDiagnosticItemResponse({
-            result: attempt.result,
-            metadata: attempt.metadata,
-            ledgerEntry,
-            integration: attempt.integration
-          }, assessment);
-        } catch (error88) {
-          addEvent("assessment.diagnostic_child_reconciliation_failed", {
-            "app.assessment.attempt_id": attempt.result.sourcedId,
-            "app.assessment.qti_item_identifier": ledgerEntry.itemIdentifier,
-            "exception.type": errorType(error88),
-            "app.error.message": errorMessage(error88)
-          });
-        }
-      });
-    }
     async ensureReviewQuestionLineItem(input) {
       const client2 = this.requireClient();
       const lineItemId = await reviewQuestionLineItemId(input.parentLineItemId, input.item.identifier);
@@ -106271,231 +105486,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...expected
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.review_question_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
         this.assertAssessmentChildLineItem(lineItemId, stored, expected);
-        addEvent("assessment.review_question_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
       }
       return lineItemId;
     }
-    async putOpenReviewChildResult(input) {
-      const metadata2 = buildReviewItemResultMetadata({
-        metadata: input.parentMetadata,
-        selection: input.selection,
-        parentAttemptId: input.parentResult.sourcedId
-      });
-      await this.requireClient().api.oneroster.assessmentResults.upsert(input.childResultId, buildOpenReviewChildResult({
-        childLineItemId: input.childLineItemId,
-        student: input.parentResult.student,
-        metadata: metadata2
-      }));
-    }
-    async ensureReviewChildResults(input) {
-      const itemByIdentifier = new Map(input.assessment.items.map((item) => [item.identifier, item]));
-      const bankItemByIdentifier = new Map(input.source.bank.items.map((item) => [item.itemIdentifier, item]));
-      const physicalItems = new Set(input.metadata.review.selections.map((selection) => selection.itemIdentifier));
-      if (physicalItems.size !== input.metadata.review.selections.length) {
-        throw new Error("MVP review selection must use each physical item at most once");
-      }
-      const administeredItems = administeredItemIdentifiers(input.metadata.itemSubmissions);
-      await runWithConcurrency(input.metadata.review.selections, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (selection) => {
-        const item = itemByIdentifier.get(selection.itemIdentifier);
-        const indexed = bankItemByIdentifier.get(selection.itemIdentifier);
-        if (!item || !indexed) {
-          throw new Error(`Review assessment or bank is missing selected item ${selection.itemIdentifier}`);
-        }
-        const childLineItemId = await this.ensureReviewQuestionLineItem({
-          parentLineItemId: input.result.assessmentLineItem.sourcedId,
-          integration: input.integration,
-          bankRevision: input.metadata.review.bankRevision,
-          standards: [...indexed.standards],
-          item
-        });
-        if (!administeredItems.has(selection.itemIdentifier)) {
-          return;
-        }
-        const childResultId = await reviewQuestionResultId(input.result.sourcedId, childLineItemId);
-        const streamedChildResult = input.existingChildResults.get(childResultId);
-        let childResult = streamedChildResult;
-        if (!childResult && input.lookupMissingResults) {
-          try {
-            childResult = await this.requireClient().api.oneroster.assessmentResults.get(childResultId);
-          } catch (error88) {
-            if (!isApiError(error88) || error88.statusCode !== 404) {
-              throw error88;
-            }
-          }
-        }
-        const resolution = resolveReviewChildResult({
-          childResult,
-          childLineItemId,
-          parentResult: input.result,
-          parentMetadata: input.metadata,
-          selection
-        });
-        if (resolution.action === "reuse") {
-          return;
-        }
-        if (resolution.action === "restore") {
-          addEvent("assessment.review_child_result_restore", {
-            "app.assessment.review_child_restore_reason": resolution.reason,
-            "app.assessment.attempt_id": input.result.sourcedId,
-            "app.assessment.child_result_id": childResultId,
-            "app.assessment.qti_item_identifier": selection.itemIdentifier
-          });
-        }
-        await this.putOpenReviewChildResult({
-          childResultId,
-          childLineItemId,
-          parentResult: input.result,
-          parentMetadata: input.metadata,
-          selection
-        });
-      });
-    }
-    async putReviewChildResponse(projection, checkpoint) {
-      const { result, metadata: metadata2, itemIdentifier, integration } = projection;
-      const selection = metadata2.review.selections.find((candidate) => candidate.itemIdentifier === itemIdentifier);
-      if (!selection) {
-        return;
-      }
-      try {
-        const source = await this.loadPinnedReviewBankSource(metadata2);
-        const item = source.assessment.items.find((candidate) => candidate.identifier === selection.itemIdentifier);
-        const indexed = source.bank.items.find((candidate) => candidate.itemIdentifier === selection.itemIdentifier);
-        if (!item || !indexed) {
-          throw new Error(`Review assessment or bank is missing selected item ${selection.itemIdentifier}`);
-        }
-        const childLineItemId = await this.ensureReviewQuestionLineItem({
-          parentLineItemId: result.assessmentLineItem.sourcedId,
-          integration,
-          bankRevision: metadata2.review.bankRevision,
-          standards: [...indexed.standards],
-          item
-        });
-        if (checkpoint && checkpoint.childLineItemId !== childLineItemId) {
-          throw new Error("Prepared review checkpoint resolved a different line item");
-        }
-        const childResultId = await reviewQuestionResultId(result.sourcedId, childLineItemId);
-        const childMetadata = buildReviewItemResultMetadata({
-          metadata: metadata2,
-          selection,
-          parentAttemptId: result.sourcedId
-        });
-        await Promise.all([
-          this.projectPreparedAssessmentChildResult(checkpoint),
-          this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, buildOpenReviewChildResult({
-            childLineItemId,
-            student: result.student,
-            metadata: childMetadata
-          }))
-        ]);
-      } catch (error88) {
-        addEvent("assessment.review_child_response_projection_failed", {
-          "app.assessment.attempt_id": result.sourcedId,
-          "app.assessment.qti_item_identifier": selection.itemIdentifier,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-      }
-    }
-    async projectReviewItemResponse(params, projection, checkpoint) {
-      const terminal = assessmentChildProjectionIsTerminal(projection.result);
-      try {
-        await reconcileReviewChildResults({
-          initial: projection,
-          writeOpen: () => this.putReviewChildResponse(projection, checkpoint),
-          crossBarrier: () => crossAssessmentAttemptLockBarrier(this.deps.assessmentRuntimeLock, this.deps.db, params.attemptId),
-          readLatest: () => this.peekAttempt(params),
-          restoreTerminal: async (latest) => {
-            const repair = this.restoreCompletedReviewChildResponses(latest.result, latest.metadata, new Set([projection.itemIdentifier]));
-            if (terminal) {
-              await Promise.allSettled([
-                this.projectPreparedAssessmentChildResult(checkpoint),
-                repair
-              ]);
-            } else {
-              await repair;
-            }
-          }
-        });
-      } catch (error88) {
-        addEvent("assessment.review_child_projection_barrier_failed", {
-          "app.assessment.attempt_id": params.attemptId,
-          "app.assessment.qti_item_identifier": projection.itemIdentifier,
-          "exception.type": errorType(error88),
-          "app.error.message": errorMessage(error88)
-        });
-      }
-    }
-    restoreAllCompletedReviewChildResponses(result, metadata2) {
-      return this.restoreCompletedReviewChildResponses(result, metadata2, new Set(metadata2.itemSubmissions.map((item) => item.itemIdentifier)));
-    }
-    async restoreCompletedReviewChildResponses(result, metadata2, changedItemIdentifiers) {
-      const outcomes = metadata2.completion?.itemOutcomes;
-      const submissionId = metadata2.submissionId;
-      if (!submissionId || !outcomes) {
-        addEvent("assessment.review_child_terminal_restore_unavailable", {
-          "app.assessment.attempt_id": result.sourcedId
-        });
-        return;
-      }
-      const outcomeByItem = new Map(outcomes.map((outcome) => [outcome.itemIdentifier, outcome]));
-      await runWithConcurrency(metadata2.review.selections.filter((selection) => changedItemIdentifiers.has(selection.itemIdentifier)), TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (selection) => {
-        try {
-          const outcome = outcomeByItem.get(selection.itemIdentifier);
-          if (!outcome) {
-            throw new Error(`Completed review omitted item ${selection.itemIdentifier}`);
-          }
-          const childLineItemId = await reviewQuestionLineItemId(result.assessmentLineItem.sourcedId, selection.itemIdentifier);
-          const childResultId = await reviewQuestionResultId(result.sourcedId, childLineItemId);
-          const finalized = buildFinalizedReviewChildResult({
-            childLineItemId,
-            student: result.student,
-            parentAttemptId: result.sourcedId,
-            metadata: metadata2,
-            selection,
-            itemResult: {
-              itemIdentifier: outcome.itemIdentifier,
-              score: outcome.score,
-              isCorrect: outcome.isCorrect
-            },
-            submissionId,
-            timestamp: result.scoreDate
-          });
-          await this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, finalized.resultUpdate);
-        } catch (error88) {
-          addEvent("assessment.review_child_terminal_restore_failed", {
-            "app.assessment.attempt_id": result.sourcedId,
-            "app.assessment.qti_item_identifier": selection.itemIdentifier,
-            "exception.type": errorType(error88),
-            "app.error.message": errorMessage(error88)
-          });
-        }
-      });
-    }
-    reviewItemOutcomes(input) {
-      const resultByItem = new Map(input.itemResults.map((itemResult) => [itemResult.itemIdentifier, itemResult]));
-      const administeredItems = administeredItemIdentifiers(input.metadata.itemSubmissions);
-      return input.metadata.review.selections.filter((selection) => administeredItems.has(selection.itemIdentifier)).map((selection) => {
-        const itemResult = resultByItem.get(selection.itemIdentifier);
-        const submission = itemAdministration(input.metadata.itemSubmissions, selection.itemIdentifier);
-        if (!itemResult || !submission) {
-          throw new Error(`Scoring omitted selected review item ${selection.itemIdentifier}`);
-        }
-        return {
-          itemIdentifier: selection.itemIdentifier,
-          standard: selection.standard,
-          answered: submission.answered,
-          score: itemResult.score,
-          isCorrect: itemResult.isCorrect
-        };
-      });
-    }
     async resolveAttemptAuthorization({ gameId, studentId, attemptId, user }, options = {}) {
       if (!options.developerAccessValidated) {
         await this.deps.validateDeveloperAccess(user, gameId);
@@ -106524,14 +105519,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const enrollment = enrollments.find((candidate) => candidate.id === metadata2.enrollmentId && candidate.course.id === integration.courseId);
       return { attempt: { result, metadata: metadata2, integration }, enrollment };
     }
-    async authorizeAttempt(params, options = {}) {
-      const authorization = await this.resolveAttemptAuthorization(params, options);
-      return this.requireActiveAttempt(authorization, params.attemptId);
-    }
-    requireActiveAttempt(authorization, attemptId) {
-      const enrollment = requireAssessmentMutationAccess(attemptId, authorization.attempt.integration.status, authorization.enrollment);
-      return { ...authorization.attempt, enrollment };
-    }
     async authorizeAttemptRead(params) {
       const { attempt, enrollment } = await this.resolveAttemptAuthorization(params);
       if ((!enrollment || attempt.integration.status === "deactivated") && !this.isSettled(attempt.result)) {
@@ -106542,7 +105529,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     unauthorizedAttempt(attemptId) {
       return AssessmentRuntimeError.from(assessmentAttemptUnauthorized(attemptId));
     }
-    async snapshotForResult(result, metadata2, integration) {
+    async snapshotForResult(result, metadata2, integration, suppliedTranscript) {
       if (isAssessmentAttemptSuperseded({
         inProgress: result.inProgress ?? "",
         scoreStatus: result.scoreStatus
@@ -106578,38 +105565,59 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           result: buildCompletedAssessmentSubmitResult({ result, metadata: metadata2 })
         };
       }
-      const assessment = await this.loadAttemptAssessment(metadata2);
-      if (this.isPlatformRoutedDiagnosticMetadata(metadata2)) {
-        const routing = await this.loadAttemptDiagnosticRouting(metadata2, assessment);
-        await this.restoreDiagnosticChildResults({
-          result,
-          metadata: metadata2,
-          integration,
-          assessment
-        });
-        return this.diagnosticSnapshot(result, metadata2, assessment, integration, routing.state);
-      }
-      return this.snapshot(result, metadata2, assessment, integration);
-    }
-    diagnosticSnapshot(result, metadata2, assessment, integration, state) {
-      return buildDiagnosticAssessmentSnapshot({
-        attemptId: result.sourcedId,
-        metadata: metadata2,
-        assessment,
-        state,
-        activityData: this.activityData(metadata2, assessment, integration)
+      const context2 = this.tokenContext({ result, metadata: metadata2, integration });
+      const graded = await resumeAssessmentTranscript({
+        suppliedTranscript,
+        checkpointTranscript: metadata2.transcript,
+        recover: async () => recoverAssessmentTranscript(context2, await this.studentAssessmentResults(context2.studentId)),
+        grade: (transcript) => this.gradeTranscript(context2, transcript)
       });
+      const session2 = await this.assessmentSession(context2, graded.transcript);
+      const common2 = {
+        attemptId: result.sourcedId,
+        assessment: graded.assessment,
+        activityData: this.activityData(metadata2, graded.assessment, integration)
+      };
+      return this.isPlatformRoutedDiagnosticMetadata(graded.metadata) ? {
+        ...buildDiagnosticAssessmentSnapshot({
+          ...common2,
+          metadata: graded.metadata,
+          state: graded.metadata.diagnostic.state
+        }),
+        ...session2
+      } : {
+        ...buildConventionalAssessmentSnapshot({ ...common2, metadata: graded.metadata }),
+        ...session2
+      };
+    }
+    async assessmentSession(context2, transcript = emptyAssessmentTranscript(context2.attemptId, context2.metadata.selectedTest.contentRevision)) {
+      return { transcript, assessmentToken: await this.deps.mintAssessmentToken(context2) };
+    }
+    async diagnosticSnapshot(result, metadata2, assessment, integration, options) {
+      return {
+        ...buildDiagnosticAssessmentSnapshot({
+          attemptId: result.sourcedId,
+          metadata: metadata2,
+          assessment,
+          state: options.state,
+          activityData: this.activityData(metadata2, assessment, integration)
+        }),
+        ...await this.assessmentSession(this.tokenContext({ result, metadata: metadata2, integration }))
+      };
     }
     diagnosticRoutingSnapshot(metadata2, state) {
       return projectDiagnosticRoutingSnapshot(metadata2.diagnostic.routingRevision, state);
     }
-    snapshot(result, metadata2, assessment, integration) {
-      return buildConventionalAssessmentSnapshot({
-        attemptId: result.sourcedId,
-        metadata: metadata2,
-        assessment,
-        activityData: this.activityData(metadata2, assessment, integration)
-      });
+    async snapshot(result, metadata2, assessment, integration) {
+      return {
+        ...buildConventionalAssessmentSnapshot({
+          attemptId: result.sourcedId,
+          metadata: metadata2,
+          assessment,
+          activityData: this.activityData(metadata2, assessment, integration)
+        }),
+        ...await this.assessmentSession(this.tokenContext({ result, metadata: metadata2, integration }))
+      };
     }
     activityData(metadata2, assessment, integration) {
       const course = this.trackableCourse(integration, "assessment.activity_tracking_invalid_course_metadata");
@@ -106670,16 +105678,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     isSettled(result) {
       return this.isAwaitingAward(result) || this.isCompleted(result);
     }
-    assertInProgress(result) {
-      if (!this.isOpen(result)) {
-        throw AssessmentRuntimeError.from(assessmentAttemptNotOpen(result.sourcedId));
-      }
-    }
-    assertResponseVersion(metadata2, expectedResponseVersion) {
-      if (metadata2.responseVersion !== expectedResponseVersion) {
-        throw AssessmentRuntimeError.from(assessmentResponseVersionConflict(expectedResponseVersion, metadata2.responseVersion));
-      }
-    }
     scoreFromResult(result, possible, metadata2) {
       return metadata2.score ?? assessmentScoreFromPercentage(result.score, possible);
     }
@@ -106730,7 +105728,22 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return projectReviewAssessment(playable, preparedReviewBankIndex(plan), plan.review.selections);
     }
-    async createPreparedAttempt(plan, assessment, integration) {
+    async claimPreparedAttempt(db2, plan, assessment, integration) {
+      const occupant = await this.findAttemptResult(plan.attemptId);
+      if (occupant) {
+        const metadata3 = playcademyAssessmentResultMetadata(occupant.metadata);
+        if (occupant.status !== ONEROSTER_STATUS2.active || !metadata3 || !this.attemptInScope(occupant, metadata3, plan) || metadata3.enrollmentId !== plan.enrollmentId || !this.isOpen(occupant) || !this.attemptMatchesPlan(metadata3, plan)) {
+          return null;
+        }
+        addEvent("assessment.prepared_attempt_recovered", {
+          "app.assessment.attempt_id": plan.attemptId
+        });
+        const [snapshot2] = await Promise.all([
+          this.snapshotForResult(occupant, metadata3, integration),
+          this.supersedeAttemptsBestEffort(db2, new Set(plan.supersedes))
+        ]);
+        return snapshot2;
+      }
       const timestamp6 = new Date().toISOString();
       const metadata2 = buildPreparedAssessmentMetadata(plan, timestamp6, assessment.title);
       const result = await this.requireClient().api.oneroster.assessmentResults.upsert(plan.attemptId, {
@@ -106747,7 +105760,42 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           grade: integration.grade
         })
       });
-      return this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, metadata2.diagnostic.state) : this.snapshot(result, metadata2, assessment, integration);
+      const [snapshot] = await Promise.all([
+        this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, {
+          state: metadata2.diagnostic.state
+        }) : this.snapshot(result, metadata2, assessment, integration),
+        this.supersedeAttemptsBestEffort(db2, new Set(plan.supersedes))
+      ]);
+      return snapshot;
+    }
+    attemptMatchesPlan(metadata2, plan) {
+      const planned = buildPreparedAssessmentMetadata(plan, metadata2.startedAt, "");
+      if (metadata2.selectedTest.assessmentKey !== planned.selectedTest.assessmentKey || metadata2.selectedTest.identifier !== planned.selectedTest.identifier || metadata2.selectedTest.contentRevision !== planned.selectedTest.contentRevision) {
+        return false;
+      }
+      if (metadata2.purpose === "review" && planned.purpose === "review") {
+        return metadata2.review.requestFingerprint === planned.review.requestFingerprint && metadata2.review.bankRevision === planned.review.bankRevision && metadata2.review.selections.length === planned.review.selections.length && metadata2.review.selections.every((selection, index2) => selection.itemIdentifier === planned.review.selections[index2].itemIdentifier);
+      }
+      if (metadata2.purpose === "mastery" && planned.purpose === "mastery") {
+        return metadata2.mastery.requestFingerprint === planned.mastery.requestFingerprint;
+      }
+      if (metadata2.purpose === "diagnostic" && plan.purpose === "diagnostic") {
+        return this.isPlatformRoutedDiagnosticMetadata(metadata2) && metadata2.diagnostic.definitionId === plan.diagnostic.definitionId && metadata2.diagnostic.routingRevision === plan.diagnostic.routingRevision;
+      }
+      return metadata2.purpose === planned.purpose;
+    }
+    async findAttemptResult(attemptId) {
+      try {
+        return await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
+      } catch (error88) {
+        if (isApiError(error88) && error88.statusCode === 404) {
+          return null;
+        }
+        throw error88;
+      }
+    }
+    attemptInScope(result, metadata2, scope) {
+      return metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && metadata2.courseId === scope.courseId && metadata2.integrationId === scope.integrationId && result.student.sourcedId === scope.studentId;
     }
     async claimAttemptId(scope, from) {
       for (let attemptNumber = from;attemptNumber < from + 20; attemptNumber += 1) {
@@ -106763,15 +105811,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       throw new Error(`Assessment attempt numbers ${from} through ${from + 19} are all occupied by records this code cannot read; refusing to overwrite them.`);
     }
     async attemptIdOccupied(attemptId) {
-      try {
-        await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
-      } catch (error88) {
-        if (isApiError(error88) && error88.statusCode === 404) {
-          return false;
-        }
-        throw error88;
-      }
-      return true;
+      return await this.findAttemptResult(attemptId) !== null;
     }
     replayCompletion(attempt, submissionId, params, game2) {
       const { score, completion } = attempt.metadata;
@@ -106792,18 +105832,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         game: game2
       };
     }
-    async putResultMetadata(result, metadata2) {
-      await this.requireClient().api.oneroster.assessmentResults.upsert(result.sourcedId, {
-        status: ONEROSTER_STATUS2.active,
-        assessmentLineItem: result.assessmentLineItem,
-        student: result.student,
-        score: result.score ?? 0,
-        scoreDate: result.scoreDate,
-        scoreStatus: result.scoreStatus,
-        ...result.inProgress === undefined || result.inProgress === null ? {} : { inProgress: result.inProgress },
-        metadata: mergeAssessmentRuntimeMetadata(result.metadata, metadata2)
-      });
-    }
     async emitCompletionBestEffort(input) {
       const { attempt } = input;
       const integration = attempt.integration;
@@ -110392,6 +109420,8 @@ function createPlatformServices(deps) {
     mintPlatformServiceToken,
     mintAssessmentPreparationReceipt,
     verifyAssessmentPreparationReceipt,
+    mintAssessmentToken,
+    verifyAssessmentToken,
     validateDeveloperAccessBySlug,
     validateDeveloperAccess,
     validateGameManagementAccess
@@ -110466,7 +109496,9 @@ function createPlatformServices(deps) {
     validateDeveloperAccess,
     assessmentRuntimeLock,
     mintAssessmentPreparationReceipt,
-    verifyAssessmentPreparationReceipt
+    verifyAssessmentPreparationReceipt,
+    mintAssessmentToken,
+    verifyAssessmentToken
   });
   return {
     assessmentAssets,
@@ -111216,6 +110248,8 @@ function createServices(ctx) {
     mintPlatformServiceToken: auth2.mintPlatformServiceToken.bind(auth2),
     mintAssessmentPreparationReceipt: auth2.mintAssessmentPreparationReceipt.bind(auth2),
     verifyAssessmentPreparationReceipt: auth2.verifyAssessmentPreparationReceipt.bind(auth2),
+    mintAssessmentToken: auth2.mintAssessmentToken.bind(auth2),
+    verifyAssessmentToken: auth2.verifyAssessmentToken.bind(auth2),
     ...gaming.validators
   });
   const standalone = createStandaloneServices({ db: db2, auth: auth2, timeback: timeback2 });
@@ -111744,6 +110778,15 @@ function createSandboxAuthProvider() {
       });
       return { receipt, expiresAt: new Date(expiresAt).toISOString() };
     },
+    async mintAssessmentToken(context2) {
+      const token = `sandbox_assessment_${crypto.randomUUID()}`;
+      sandboxAssessmentTokens.set(token, structuredClone(context2));
+      return token;
+    },
+    async verifyAssessmentToken(token) {
+      const context2 = sandboxAssessmentTokens.get(token);
+      return context2 ? structuredClone(context2) : null;
+    },
     async verifyAssessmentPreparationReceipt(receipt) {
       const prepared = sandboxAssessmentPreparationReceipts.get(receipt);
       if (!prepared) {
@@ -111796,13 +110839,18 @@ function createSandboxAuthProvider() {
     }
   };
 }
-var sandboxApiKeys, sandboxAssessmentPreparationReceipts, ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS;
-var init_auth_provider = __esm(() => {
+var sandboxApiKeys, sandboxAssessmentPreparationReceipts, ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS, sandboxAssessmentTokens;
+var init_auth_provider = __esm(async () => {
   init_src6();
   init_constants();
+  await init_dist5();
   sandboxApiKeys = new Map;
   sandboxAssessmentPreparationReceipts = new Map;
   ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS = 5 * 60 * 1000;
+  sandboxAssessmentTokens = new TimebackCache({
+    defaultTTL: 2 * 60 * 60 * 1000,
+    maxSize: 1000
+  });
 });
 
 // src/infrastructure/api/providers/cache.provider.ts
@@ -111963,10 +111011,10 @@ var init_storage_provider = __esm(() => {
 });
 
 // src/infrastructure/api/providers/index.ts
-var init_providers = __esm(() => {
-  init_auth_provider();
+var init_providers = __esm(async () => {
   init_cache_provider();
   init_storage_provider();
+  await init_auth_provider();
 });
 
 // src/infrastructure/api/context.ts
@@ -112036,10 +111084,10 @@ var init_context = __esm(async () => {
   init_config2();
   init_utils7();
   init_src6();
-  init_providers();
   await __promiseAll([
     init_factory(),
-    init_clients()
+    init_clients(),
+    init_providers()
   ]);
 });
 
@@ -168435,7 +167483,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, prepareRuntimeAssessment, 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, 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, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -168737,6 +167785,20 @@ var init_timeback_controller = __esm(() => {
       user: ctx.user
     });
   });
+  resumeRuntimeAssessment = requireDeveloper(async (ctx) => {
+    const attemptId = ctx.params.attemptId;
+    const body2 = await parseRequestBody(ctx.request, ResumeRuntimeAssessmentRequestSchema);
+    if (!attemptId) {
+      throw ApiError.badRequest("Missing attemptId");
+    }
+    return ctx.services.timebackAssessmentRuntime.resume({
+      gameId: body2.gameId,
+      studentId: body2.studentId,
+      attemptId,
+      input: { transcript: body2.transcript },
+      user: ctx.user
+    });
+  });
   saveRuntimeAssessment = requireDeveloper(async (ctx) => {
     const attemptId = ctx.params.attemptId;
     const body2 = await parseRequestBody(ctx.request, SaveRuntimeAssessmentRequestSchema);
@@ -168749,7 +167811,26 @@ var init_timeback_controller = __esm(() => {
       attemptId,
       input: {
         expectedResponseVersion: body2.expectedResponseVersion,
-        responses: body2.responses
+        transcript: body2.transcript
+      },
+      user: ctx.user
+    });
+  });
+  recordRuntimeAssessmentProgress = requireDeveloper(async (ctx) => {
+    const attemptId = ctx.params.attemptId;
+    const body2 = await parseRequestBody(ctx.request, RecordRuntimeAssessmentProgressRequestSchema);
+    if (!attemptId) {
+      throw ApiError.badRequest("Missing attemptId");
+    }
+    return ctx.services.timebackAssessmentRuntime.recordProgress({
+      gameId: body2.gameId,
+      studentId: body2.studentId,
+      attemptId,
+      input: {
+        assessmentToken: body2.assessmentToken,
+        transcript: body2.transcript,
+        expectedResponseVersion: body2.expectedResponseVersion,
+        itemIdentifier: body2.itemIdentifier
       },
       user: ctx.user
     });
@@ -168765,6 +167846,8 @@ var init_timeback_controller = __esm(() => {
       studentId: body2.studentId,
       attemptId,
       input: {
+        assessmentToken: body2.assessmentToken,
+        transcript: body2.transcript,
         expectedResponseVersion: body2.expectedResponseVersion,
         submissionId: body2.submissionId,
         itemIdentifier: body2.itemIdentifier,
@@ -168787,6 +167870,7 @@ var init_timeback_controller = __esm(() => {
       input: {
         expectedResponseVersion: body2.expectedResponseVersion,
         submissionId: body2.submissionId,
+        transcript: body2.transcript,
         ...body2.session ? { session: body2.session } : {}
       },
       game: {
@@ -169264,6 +168348,8 @@ var init_timeback_controller = __esm(() => {
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
     saveRuntimeAssessment,
+    resumeRuntimeAssessment,
+    recordRuntimeAssessmentProgress,
     submitRuntimeAssessmentItem,
     submitRuntimeAssessment,
     finalizeRuntimeAssessment,
@@ -170256,6 +169342,8 @@ var init_timeback8 = __esm(async () => {
   timebackRouter.post("/assessments/start", handle2(timeback2.startRuntimeAssessment));
   timebackRouter.get("/assessments/latest", handle2(timeback2.getLatestRuntimeAssessment));
   timebackRouter.get("/assessments/:attemptId", handle2(timeback2.getRuntimeAssessment));
+  timebackRouter.post("/assessments/:attemptId/resume", handle2(timeback2.resumeRuntimeAssessment));
+  timebackRouter.post("/assessments/:attemptId/progress", handle2(timeback2.recordRuntimeAssessmentProgress));
   timebackRouter.post("/assessments/:attemptId/save", handle2(timeback2.saveRuntimeAssessment));
   timebackRouter.post("/assessments/:attemptId/submit-item", handle2(timeback2.submitRuntimeAssessmentItem));
   timebackRouter.post("/assessments/:attemptId/submit", handle2(timeback2.submitRuntimeAssessment));
@@ -170664,13 +169752,13 @@ var init_server = __esm(async () => {
   init_port();
   init_package();
   init_config();
-  init_providers();
   init_app();
   init_database2();
   init_options();
   await __promiseAll([
     init_api3(),
-    init_context()
+    init_context(),
+    init_providers()
   ]);
   version5 = package_default.version;
 });