@playcademy/vite-plugin 1.3.2-beta.3 → 1.3.2-beta.4

package/dist/index.js

@@ -24317,7 +24317,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.3.2-beta.3",
+  version: "1.3.2-beta.4",
   type: "module",
   exports: {
     ".": {
@@ -25058,7 +25058,6 @@ var TIMEBACK_GRADES;
 var TIMEBACK_SUBJECTS;
 var ASSESSMENT_PURPOSES;
 var PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION = 1;
-var PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION = 1;
 var PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION = 1;
 var PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY = "playcademyAssessment";
 var PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY = "playcademyAssessmentItem";
@@ -25934,7 +25933,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.8.0",
+    version: "0.8.1-beta.6",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -34175,25 +34174,6 @@ var init_v3 = __esm(() => {
 var init_esm = __esm(() => {
   init_v3();
 });
-var PLAYABLE_ASSESSMENT_SHAPES;
-var init_assessment_runtime = __esm(() => {
-  PLAYABLE_ASSESSMENT_SHAPES = ["circle", "ellipse", "rect", "poly", "default"];
-});
-var DIAGNOSTIC_ROUTING_MANIFEST_VERSION = 1;
-var DIAGNOSTIC_ROUTING_STATE_VERSION = 1;
-var DIAGNOSTIC_TRACK_OUTCOMES;
-var init_diagnostic_routing = __esm(() => {
-  DIAGNOSTIC_TRACK_OUTCOMES = [
-    "provisional",
-    "unresolved",
-    "route-to-instruction",
-    "not-assessed"
-  ];
-});
-var init_timeback4 = __esm(() => {
-  init_assessment_runtime();
-  init_diagnostic_routing();
-});
 function isValidUUID(value) {
   if (!value || typeof value !== "string") {
     return false;
@@ -34215,6 +34195,25 @@ 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}$/;
 });
+var PLAYABLE_ASSESSMENT_SHAPES;
+var init_assessment_runtime = __esm(() => {
+  PLAYABLE_ASSESSMENT_SHAPES = ["circle", "ellipse", "rect", "poly", "default"];
+});
+var DIAGNOSTIC_ROUTING_MANIFEST_VERSION = 1;
+var DIAGNOSTIC_ROUTING_STATE_VERSION = 1;
+var DIAGNOSTIC_TRACK_OUTCOMES;
+var init_diagnostic_routing = __esm(() => {
+  DIAGNOSTIC_TRACK_OUTCOMES = [
+    "provisional",
+    "unresolved",
+    "route-to-instruction",
+    "not-assessed"
+  ];
+});
+var init_timeback4 = __esm(() => {
+  init_assessment_runtime();
+  init_diagnostic_routing();
+});
 function qtiDirectedPairValidationIssue(values, contract) {
   const sourceCounts = new Map;
   const targetCounts = new Map;
@@ -34492,6 +34491,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((entry2) => typeof entry2 === "string" && entry2.length > 0 && entry2.length <= TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH);
+}
 function compareCodeUnits(left, right) {
   if (left < right) {
     return -1;
@@ -35345,48 +35363,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((entry2) => typeof entry2 === "string" && entry2.length > 0 && entry2.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)) {
@@ -35548,147 +35524,154 @@ function interactionResponseValidationMessage(itemIdentifier, interaction, respo
   }
   return null;
 }
-function invalidResponse(message) {
-  return { code: "INVALID_RESPONSE", message };
+function emptyAssessmentTranscript(attemptId, contentRevision) {
+  return { version: 1, attemptId, contentRevision, administrations: [] };
 }
-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 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((entry2) => entry2.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 entry2 = {
+    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(entry2)) {
     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, entry2] } : 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, entry2] of transcript.administrations.entries()) {
+    const itemIndex = input.assessment.items.findIndex((item) => item.identifier === entry2.itemIdentifier);
+    if (submissions.has(entry2.submissionId) || items.has(entry2.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 !== (entry2.routingNodeKey !== undefined)) {
+      throw new AssessmentTranscriptError("Transcript routing identity does not match the assessment flow", index);
+    }
+    const itemResponses = { [entry2.itemIdentifier]: entry2.responses };
+    const validate2 = input.routed || input.allowIncomplete ? assessmentDraftResponseValidationMessage : assessmentResponseValidationMessage;
+    const invalid = Object.keys(entry2.responses).length === 0 ? null : validate2(input.assessment, itemResponses);
+    if (invalid) {
+      throw new AssessmentTranscriptError(invalid, index, "INVALID_RESPONSE");
+    }
+    submissions.add(entry2.submissionId);
+    items.add(entry2.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, entry2] of input.transcript.administrations.entries()) {
+    const scoring = scores.get(entry2.itemIdentifier);
+    if (!scoring) {
+      throw new AssessmentTranscriptError("Transcript item has no trusted grade", index);
+    }
+    if (input.manifest) {
+      if (typeof scoring.isCorrect !== "boolean" || !entry2.routingNodeKey) {
+        throw new AssessmentTranscriptError("Diagnostic grading must be determinate", index);
+      }
+      const advanced = advanceDiagnosticRouting(input.manifest, ledger, {
+        routingNodeKey: entry2.routingNodeKey,
+        itemIdentifier: entry2.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: entry2.submissionId,
+      itemIdentifier: entry2.itemIdentifier,
+      responseVersion: index + 1,
+      submittedAt: input.submittedAt,
+      answered: Object.keys(entry2.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) {
@@ -36021,9 +36004,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 entry2 of questions.questions) {
@@ -36583,11 +36563,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;
@@ -36641,19 +36618,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)) {
@@ -36673,12 +36638,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) ? {
@@ -36686,12 +36645,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 },
@@ -36701,6 +36658,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((entry2) => isRecord(entry2) ? { ...entry2, responses: entry2.responses ?? {} } : entry2) : transcript.administrations ?? []
+      }
+    };
+  }
   if (isRecord(review) && isRecord(review.fulfillment) && review.fulfillment.status === "complete" && review.fulfillment.shortages === undefined) {
     normalized = {
       ...normalized,
@@ -36715,28 +36682,6 @@ 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;
 var DATA_RASTER_IMAGE_PATTERN;
 var QTI_MATHML_ALLOWED_TAGS;
@@ -36794,6 +36739,7 @@ var ASSESSMENT_ATTEMPT_COMPLETED;
 var ASSESSMENT_ATTEMPT_AWAITING_AWARD;
 var ASSESSMENT_ATTEMPT_SUPERSEDED;
 var ASSESSMENT_RUNTIME_ERROR_STATUS;
+var GRADE_VALUES;
 var ROUTING_KEY_MAX_LENGTH = 128;
 var ROUTING_RESULT_KEY_MAX_LENGTH = 256;
 var ROUTING_STAGE_LIMIT = 32;
@@ -36809,8 +36755,10 @@ var DiagnosticTrackOutcomeSchema;
 var DiagnosticActivationPredicateSchema;
 var DiagnosticRoutingTransitionSchema;
 var DiagnosticRoutingManifestV1Schema;
-var GRADE_VALUES;
 var POINT_RESPONSE_PATTERN;
+var Identity;
+var AssessmentTranscriptSchema;
+var AssessmentTranscriptError;
 var ZERO_WIDTH_CHARACTERS;
 var CURLY_SINGLE_QUOTES;
 var CURLY_DOUBLE_QUOTES;
@@ -36836,9 +36784,11 @@ var AssessmentChildResultAttemptV1Schema;
 var AssessmentChildResultAdministrationV1Schema;
 var AssessmentChildResultGradingV1Schema;
 var ReviewChildResultContextV1Schema;
+var FixedChildResultContextV1Schema;
 var DiagnosticChildResultContextV1Schema;
 var CommonPayloadShape;
 var ReviewChildResultPayloadV1Schema;
+var FixedChildResultPayloadV1Schema;
 var DiagnosticChildResultPayloadV1Schema;
 var AssessmentChildResultPayloadV1Schema;
 var AssessmentChildResultCommandV1Schema;
@@ -36857,12 +36807,16 @@ var StartAssessmentBodySchema;
 var AssessmentPreparationReceiptSchema;
 var StartAssessmentRequestBodySchema;
 var SaveAssessmentBodySchema;
+var RecordAssessmentProgressBodySchema;
+var ResumeAssessmentBodySchema;
+var ResumeRuntimeAssessmentRequestSchema;
 var SubmitAssessmentItemBodySchema;
 var SubmitAssessmentBodySchema;
 var FinalizeAssessmentBodySchema;
 var PrepareRuntimeAssessmentRequestSchema;
 var StartRuntimeAssessmentRequestSchema;
 var SaveRuntimeAssessmentRequestSchema;
+var RecordRuntimeAssessmentProgressRequestSchema;
 var SubmitAssessmentItemRuntimeRequestSchema;
 var SubmitRuntimeAssessmentRequestSchema;
 var FinalizeRuntimeAssessmentRequestSchema;
@@ -36875,13 +36829,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();
@@ -37177,6 +37132,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);
@@ -37234,8 +37190,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 AssessmentTranscriptError2 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;
@@ -37327,6 +37306,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,
@@ -37346,6 +37329,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(),
@@ -37361,7 +37349,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),
@@ -37438,9 +37427,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,
@@ -37448,6 +37447,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, {
@@ -37466,6 +37466,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),
@@ -126102,22 +126103,6 @@ var init_locks = __esm(() => {
     }
   };
 });
-async function crossAssessmentAttemptLockBarrier(lock, db2, attemptId) {
-  const maxAttempts = 5;
-  for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
-    try {
-      await lock(db2, [assessmentRuntimeAttemptLockKey(attemptId)], async () => {
-        return;
-      });
-      return;
-    } catch (error88) {
-      if (!(error88 instanceof ServiceUnavailableError) || attempt === maxAttempts) {
-        throw error88;
-      }
-      await sleep(25);
-    }
-  }
-}
 function normalizeKeys(keys) {
   return [...new Set(keys)].toSorted();
 }
@@ -126191,17 +126176,6 @@ var init_assessment_runtime_lock_util = __esm(() => {
     }
   };
 });
-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;
@@ -126267,7 +126241,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
   };
@@ -126317,151 +126291,9 @@ async function resolveAvailableAssessmentAttempt(initialDecision, select3, resum
   }
   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((entry2) => entry2.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;
@@ -126847,32 +126679,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,
@@ -126912,6 +126724,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,
@@ -128316,6 +128143,184 @@ var init_timeback_assessment_artifacts_util = __esm(() => {
   init_timeback_assessment_runtime_util();
   init_timeback_review_mapping_util();
 });
+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": errorMessage2(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;
+var PLATFORM_QTI_ADAPTER_CHILD_GRADING;
+var PLATFORM_CHILD_GRADING;
+var 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}`
+  };
+});
 async function buildSubmissionChildResultCommand(input) {
   const { submission, context: context2 } = input;
   const { isCorrect } = submission;
@@ -128330,12 +128335,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");
@@ -128356,11 +128358,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) {
@@ -128418,19 +128416,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);
@@ -128439,38 +128432,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();
 });
 
 class AssessmentPreparationFlights {
@@ -128574,6 +128656,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,
@@ -128604,7 +128687,6 @@ function buildPreparedAssessmentMetadata(plan, timestamp6, testName) {
         testName,
         routingRevision: plan.diagnostic.routingRevision,
         ledger: [],
-        routingSnapshots: [],
         state: plan.diagnostic.initialState
       }
     };
@@ -128900,123 +128982,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");
 });
-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();
-});
-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();
-});
 function diagnosticRoutingFallbackReason(artifact, routingRevision) {
   if (!artifact) {
     return "artifact-unavailable";
@@ -129162,156 +129127,252 @@ function validateUniqueAssessmentIdentifiers(testIdentifiers) {
 var init_timeback_assessment_rules_util = __esm(() => {
   init_errors2();
 });
-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 };
+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 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);
+    if (metadata2.purpose === "review" && (metadata2.transcript !== undefined || settled)) {
+      authoritative.add(result.sourcedId);
+      if (metadata2.review.bankRevision === input.bankRevision) {
+        const accepted = settled ? metadata2.itemSubmissions.map((submission) => ({
+          itemIdentifier: submission.itemIdentifier,
+          deliveredAt: submission.submittedAt
+        })) : metadata2.transcript.administrations.map((entry2) => ({
+          itemIdentifier: entry2.itemIdentifier,
+          deliveredAt: metadata2.updatedAt
+        }));
+        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": errorMessage2(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;
-var PLATFORM_QTI_ADAPTER_CHILD_GRADING;
-var PLATFORM_CHILD_GRADING;
-var 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}`
-  };
 });
 function qtiItemHref(client2, itemIdentifier) {
   return `${client2.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
@@ -129395,20 +129456,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 AssessmentPreparationPrerequisiteError2 extends Error {
     original;
@@ -129423,7 +129483,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 = 900000;
@@ -129441,6 +129500,14 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       maxSize: TimebackAssessmentRuntimeService2.ASSESSMENT_CACHE_LIMIT
     });
     artifactLoader;
+    itemScoreCache = new TimebackCache({
+      defaultTTL: 300000,
+      maxSize: 512
+    });
+    childLineItemCache = new TimebackCache({
+      defaultTTL: 300000,
+      maxSize: 512
+    });
     preparations = new AssessmentPreparationFlights(TimebackAssessmentRuntimeService2.PREPARATION_IN_FLIGHT_LIMIT);
     constructor(deps) {
       this.deps = deps;
@@ -129567,6 +129634,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           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: {
@@ -129623,7 +129691,7 @@ 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 listing = await this.attemptListing(results, attemptScope);
       const decision = selectRuntimeAssessment(tests, [
         ...this.attemptsMatchingRequest(listing.attempts, this.startRequestFingerprint(params.input)).values()
       ].map((entry2) => entry2.selection));
@@ -129646,6 +129714,18 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       let prepared;
       try {
         prepared = await this.buildPreparationPlan(params, requestHash, preparation);
+        const assessment = await this.loadPreparedPlanAssessment(prepared.plan);
+        if (!assessment) {
+          throw new Error("Prepared assessment artifact is unavailable");
+        }
+        await this.provisionPreparationPrerequisites(() => this.ensureTranscriptLineItems({
+          version: 1,
+          gameId: prepared.plan.gameId,
+          studentId: prepared.plan.studentId,
+          attemptId: prepared.plan.attemptId,
+          parentLineItemId: prepared.plan.parentLineItemId,
+          metadata: buildPreparedAssessmentMetadata(prepared.plan, new Date().toISOString(), assessment.title)
+        }, assessment));
       } catch (error88) {
         if (error88 instanceof ValidationError || error88 instanceof AssessmentRuntimeError) {
           throw error88;
@@ -129731,6 +129811,7 @@ 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,
         selectedTest: {
@@ -129771,7 +129852,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
         })
       });
@@ -129820,6 +129903,7 @@ 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,
         selectedTest: {
@@ -129971,6 +130055,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           activityId: input.activityId,
           purpose: "diagnostic",
           courseId: context2.integration.courseId,
+          courseName: context2.enrollment.course.title,
           integrationId: context2.integration.id,
           enrollmentId: context2.enrollment.id,
           selectedTest: {
@@ -129990,7 +130075,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             testName: assessment.title,
             routingRevision: routing.routingRevision,
             ledger: [],
-            routingSnapshots: [],
             state: routing.state
           }
         };
@@ -130009,7 +130093,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           })
         });
         await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-        return this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, routing.state);
+        return this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, {
+          state: routing.state
+        });
       });
     }
     async startReview({
@@ -130043,7 +130129,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.listAttempts(attemptScope)
         ]);
         const attempts = listing.attempts;
-        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, attempts, listing.reviewChildren, context2));
+        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, attempts, context2));
         if (initialResolution.kind === "resumed") {
           await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
           return initialResolution.snapshot;
@@ -130062,7 +130148,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
         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));
+        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, refreshed, context2));
         if (refreshedResolution.kind === "resumed") {
           await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
           return refreshedResolution.snapshot;
@@ -130075,7 +130161,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         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: refreshedListing.attempts.values(),
+          children: refreshedListing.reviewChildren.values(),
           bankRevision: catalog.bank.bankRevision
         });
         const selected = selectReviewItems({
@@ -130114,6 +130202,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           activityId: input.activityId,
           purpose: input.purpose,
           courseId: context2.integration.courseId,
+          courseName: context2.enrollment.course.title,
           integrationId: context2.integration.id,
           enrollmentId: context2.enrollment.id,
           selectedTest: {
@@ -130160,8 +130249,14 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       });
     }
     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,
@@ -130223,496 +130318,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": errorMessage2(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 >= TimebackAssessmentRuntimeService2.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 >= TimebackAssessmentRuntimeService2.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": errorMessage2(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((entry2) => entry2.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": errorMessage2(error88)
-        });
-        return null;
-      }
-    }
-    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;
+        throw assessmentTranscriptRuntimeError(error88);
       }
-      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": errorMessage2(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": errorMessage2(error88)
-        });
-        return null;
-      }
     }
     async submit({
       input,
@@ -130720,121 +130423,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,
@@ -130978,58 +130643,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
@@ -131229,14 +130842,32 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     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) {
           const selectedAssessmentKey = metadata2.selectedTest.assessmentKey ?? assessmentKeyFromManagedQtiIdentifier(metadata2.selectedTest.identifier);
@@ -131287,19 +130918,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       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) {
       if (!decision) {
         throw AssessmentRuntimeError.from(assessmentNoEligibleTests(purpose));
@@ -131316,29 +130934,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const resumed = attempts.get(decision.attempt.attemptId);
       return this.snapshotForResult(resumed.result, resumed.metadata, integration);
     }
-    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(",")
-        });
-      }
+    async resumeDiagnosticSnapshot(decision, attempts, integration, _db = this.deps.db) {
       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");
-      }
-      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
-      });
-      return this.diagnosticSnapshot(resumed.result, resumed.metadata, assessment, integration, routing.state);
+      return this.snapshotForResult(resumed.result, resumed.metadata, integration);
     }
     async resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, resume) {
       const select3 = () => selectRuntimeAssessment(tests, [...this.attemptsMatchingRequest(attempts, requestFingerprint).values()].map((entry2) => entry2.selection));
@@ -131409,42 +131007,9 @@ 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(",")
-        });
-      }
+    async resumeReviewSnapshot(decision, attempts, context2) {
       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);
+      return this.snapshotForResult(resumed.result, resumed.metadata, context2.integration);
     }
     recordReviewPreparationPhase(phase, startedAt, counts = {}) {
       addEvent("assessment.review_preparation_phase", {
@@ -131852,135 +131417,82 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       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;
-      }
+    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, TimebackAssessmentRuntimeService2.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) {
+            if (!isApiError(error88) || error88.statusCode !== 409) {
+              throw error88;
+            }
+            this.assertAssessmentChildLineItem(id, await 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": errorMessage2(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": errorMessage2(error88)
-        });
-      }
-    }
     assertAssessmentChildLineItem(lineItemId, stored, expected) {
       if (assessmentChildLineItemMatches(stored, expected)) {
         return;
@@ -132038,91 +131550,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       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": errorMessage2(error88)
-        });
-      }
-    }
-    async restoreDiagnosticChildResults(attempt) {
-      const assessment = attempt.assessment ?? await this.loadAttemptAssessment(attempt.metadata);
-      await runWithConcurrency(attempt.metadata.diagnostic.ledger, TimebackAssessmentRuntimeService2.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": errorMessage2(error88)
-          });
-        }
-      });
-    }
     async ensureReviewQuestionLineItem(input) {
       const client2 = this.requireClient();
       const lineItemId = await reviewQuestionLineItemId(input.parentLineItemId, input.item.identifier);
@@ -132169,220 +131596,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       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, TimebackAssessmentRuntimeService2.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": errorMessage2(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": errorMessage2(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)), TimebackAssessmentRuntimeService2.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": errorMessage2(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);
@@ -132411,14 +131624,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)) {
@@ -132429,7 +131634,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
@@ -132465,38 +131670,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");
@@ -132557,16 +131783,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);
     }
@@ -132634,7 +131850,9 @@ 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);
+      return this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, {
+        state: metadata2.diagnostic.state
+      }) : this.snapshot(result, metadata2, assessment, integration);
     }
     async claimAttemptId(scope, from) {
       for (let attemptNumber = from;attemptNumber < from + 20; attemptNumber += 1) {
@@ -132679,18 +131897,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;
@@ -136251,6 +135457,8 @@ function createPlatformServices(deps) {
     mintPlatformServiceToken,
     mintAssessmentPreparationReceipt,
     verifyAssessmentPreparationReceipt,
+    mintAssessmentToken,
+    verifyAssessmentToken,
     validateDeveloperAccessBySlug,
     validateDeveloperAccess,
     validateGameManagementAccess
@@ -136325,7 +135533,9 @@ function createPlatformServices(deps) {
     validateDeveloperAccess,
     assessmentRuntimeLock,
     mintAssessmentPreparationReceipt,
-    verifyAssessmentPreparationReceipt
+    verifyAssessmentPreparationReceipt,
+    mintAssessmentToken,
+    verifyAssessmentToken
   });
   return {
     assessmentAssets,
@@ -137060,6 +136270,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 });
@@ -137562,6 +136774,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) {
@@ -137617,12 +136838,18 @@ function createSandboxAuthProvider() {
 var sandboxApiKeys;
 var sandboxAssessmentPreparationReceipts;
 var ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS;
-var init_auth_provider = __esm(() => {
+var 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 = 300000;
+  sandboxAssessmentTokens = new TimebackCache({
+    defaultTTL: 7200000,
+    maxSize: 1000
+  });
 });
 function createSandboxCacheProvider() {
   return {
@@ -137775,10 +137002,10 @@ var init_storage_provider = __esm(() => {
   init_src6();
   storage = new Map;
 });
-var init_providers = __esm(() => {
-  init_auth_provider();
+var init_providers = __esm(async () => {
   init_cache_provider();
   init_storage_provider();
+  await init_auth_provider();
 });
 function buildConfig(options) {
   const baseUrl = `http://localhost:${options.port ?? 3000}`;
@@ -137847,10 +137074,10 @@ var init_context = __esm(async () => {
   init_config2();
   init_utils7();
   init_src6();
-  init_providers();
   await __promiseAll([
     init_factory(),
-    init_clients()
+    init_clients(),
+    init_providers()
   ]);
 });
 function resolveUser(c) {
@@ -196925,7 +196152,9 @@ var prepareRuntimeAssessment;
 var startRuntimeAssessment;
 var getRuntimeAssessment;
 var getLatestRuntimeAssessment;
+var resumeRuntimeAssessment;
 var saveRuntimeAssessment;
+var recordRuntimeAssessmentProgress;
 var submitRuntimeAssessmentItem;
 var submitRuntimeAssessment;
 var finalizeRuntimeAssessment;
@@ -197266,6 +196495,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);
@@ -197278,7 +196521,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
     });
@@ -197294,6 +196556,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,
@@ -197316,6 +196580,7 @@ var init_timeback_controller = __esm(() => {
       input: {
         expectedResponseVersion: body2.expectedResponseVersion,
         submissionId: body2.submissionId,
+        transcript: body2.transcript,
         ...body2.session ? { session: body2.session } : {}
       },
       game: {
@@ -197793,6 +197058,8 @@ var init_timeback_controller = __esm(() => {
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
     saveRuntimeAssessment,
+    resumeRuntimeAssessment,
+    recordRuntimeAssessmentProgress,
     submitRuntimeAssessmentItem,
     submitRuntimeAssessment,
     finalizeRuntimeAssessment,
@@ -198746,6 +198013,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));
@@ -199147,13 +198416,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_default2.version;
 });