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

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.1",
+  version: "1.3.2-beta.3",
   type: "module",
   exports: {
     ".": {
@@ -25934,7 +25934,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.8.1-beta.4",
+    version: "0.8.0",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -34232,7 +34232,18 @@ function qtiDirectedPairValidationIssue(values, contract) {
   }
   return null;
 }
-function isRecord2(value) {
+function validNumericMatchValue(value, baseType) {
+  const syntax = baseType === "integer" ? /^[+-]?\d+$/ : /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+  if (!syntax.test(value.trim())) {
+    return false;
+  }
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && (baseType === "float" || Number.isSafeInteger(numeric));
+}
+function sameScore(left, right) {
+  return Number.isFinite(left) && Number.isFinite(right) && Math.abs(left - right) <= Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function stringField(value) {
@@ -34327,13 +34338,13 @@ function dedupeStandards(standards) {
   return [...deduped.values()];
 }
 function qtiAlignmentStandardsFromMetadata(metadata2) {
-  if (!isRecord2(metadata2)) {
+  if (!isRecord3(metadata2)) {
     return [];
   }
   const standards = [];
   const alignmentGroups = Array.isArray(metadata2.alignment) ? metadata2.alignment : [];
   for (const group of alignmentGroups) {
-    if (isRecord2(group)) {
+    if (isRecord3(group)) {
       const source = stringField(group.curriculum) || "QTI";
       const domains2 = Array.isArray(group.domains) ? group.domains : [];
       if (!domains2.length) {
@@ -34351,11 +34362,11 @@ function qtiAlignmentStandardsFromMetadata(metadata2) {
         }
       } else {
         for (const domain of domains2) {
-          if (isRecord2(domain)) {
+          if (isRecord3(domain)) {
             const domainName = stringField(domain.name) || undefined;
             const domainStandards = Array.isArray(domain.standards) ? domain.standards : [];
             for (const standard of domainStandards) {
-              if (isRecord2(standard)) {
+              if (isRecord3(standard)) {
                 const identifier = stringField(standard.identifier).trim();
                 const id = stringField(standard.id).trim() || identifier;
                 if (id) {
@@ -34406,12 +34417,9 @@ function isAssessmentAttemptSuperseded(attempt) {
   return attempt.inProgress === ASSESSMENT_ATTEMPT_SUPERSEDED.inProgress && attempt.scoreStatus === ASSESSMENT_ATTEMPT_SUPERSEDED.scoreStatus;
 }
 function classifyAssessmentSubmission(attempt, submissionId) {
-  if (isAssessmentAttemptAwaitingAward(attempt)) {
+  if (isAssessmentAttemptAwaitingAward(attempt) || isAssessmentAttemptCompleted(attempt)) {
     return attempt.submissionId === submissionId ? "replay" : "reject";
   }
-  if (isAssessmentAttemptCompleted(attempt)) {
-    return "reject";
-  }
   return isAssessmentAttemptOpen(attempt) ? "submit" : "reject";
 }
 function isSameAssessmentAward(recorded, input) {
@@ -34503,10 +34511,13 @@ function canonicalJson(value) {
   const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== undefined).toSorted(([left], [right]) => compareCodeUnits(left, right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${canonicalJson(entryValue)}`);
   return `{${entries.join(",")}}`;
 }
-async function diagnosticRoutingRevision(manifest) {
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonicalJson(manifest)));
+async function canonicalJsonSha256(value) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonicalJson(value)));
   return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
+function diagnosticRoutingRevision(manifest) {
+  return canonicalJsonSha256(manifest);
+}
 function issue(severity, code, message, path3, details) {
   return { severity, code, message, ...path3 ? { path: path3 } : {}, ...details ? { details } : {} };
 }
@@ -35563,11 +35574,11 @@ function itemResponsesEqual(left, right) {
 function itemResponseUpdateMatches(current, update) {
   return itemResponsesEqual(current, applyAssessmentItemResponseUpdate(current, update));
 }
-function prepareAssessmentItemSubmission(state, input) {
+function resolveAssessmentItemReplay(state, input) {
   const flow = assessmentFlowForPurpose(state.purpose);
   if (flow !== "item-submit") {
     return {
-      action: "reject",
+      action: "conflict",
       failure: assessmentFlowViolation("Items cannot be submitted individually in this flow.", { flow })
     };
   }
@@ -35576,7 +35587,7 @@ function prepareAssessmentItemSubmission(state, input) {
     const sameRequest = priorSubmission.itemIdentifier === input.itemIdentifier && itemResponseUpdateMatches(state.responses[input.itemIdentifier], input.responses);
     if (!sameRequest) {
       return {
-        action: "reject",
+        action: "conflict",
         failure: assessmentFlowViolation("This item submission ID was already used for a different request.", {
           submissionId: input.submissionId,
           itemIdentifier: input.itemIdentifier,
@@ -35592,6 +35603,16 @@ function prepareAssessmentItemSubmission(state, input) {
       submission: priorSubmission
     };
   }
+  return { action: "missing" };
+}
+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) {
     return {
       action: "reject",
@@ -35607,7 +35628,7 @@ function prepareAssessmentItemSubmission(state, input) {
       failure: assessmentFlowViolation("Items must be submitted once and in candidate order.", {
         itemIdentifier: input.itemIdentifier,
         previousItemIdentifier: previousItemIdentifier ?? null,
-        flow
+        flow: assessmentFlowForPurpose(state.purpose)
       })
     };
   }
@@ -35637,7 +35658,8 @@ function completeAssessmentItemSubmission(state, input, prepared, scoring, submi
     responseVersion: prepared.responseVersion,
     answered: prepared.answered,
     score: scoring.score,
-    isCorrect: scoring.isCorrect
+    isCorrect: scoring.isCorrect,
+    ...scoring.grading ? { grading: scoring.grading } : {}
   };
   return {
     responseVersion: prepared.responseVersion,
@@ -35792,6 +35814,145 @@ function assessmentPresentationForAttempt(assessment, attemptId) {
   });
   return { ...assessment, items };
 }
+function normalizedMatchText(value, baseType) {
+  const normalized = value.replace(ZERO_WIDTH_CHARACTERS, "").replace(CURLY_SINGLE_QUOTES, "'").replace(CURLY_DOUBLE_QUOTES, '"').replace(UNICODE_DASHES, "-");
+  return baseType === "directedPair" ? normalized : normalized.replace(/[\s\u00A0]+/g, " ").trim();
+}
+function normalizedArithmeticText(value) {
+  return value.replace(THOUSANDS_GROUP, (number) => number.replaceAll(",", "")).replace(ARITHMETIC_OPERATOR_SPACING, "$1").replaceAll("÷", "/").replace(/[\u00D7\u00B7]/g, "*");
+}
+function parsedMatchValue(value, baseType) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = normalizedMatchText(value, baseType);
+  if (baseType === "identifier" && !IDENTIFIER_VALUE.test(normalized)) {
+    return null;
+  }
+  if (baseType === "directedPair" && !DIRECTED_PAIR_VALUE.test(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function matchValuesEqual(left, right, baseType) {
+  return left === right || baseType !== "identifier" && baseType !== "directedPair" && normalizedArithmeticText(left) === normalizedArithmeticText(right);
+}
+function parsedMatchValues(values, baseType) {
+  const parsed = values.map((value) => parsedMatchValue(value, baseType));
+  return parsed.every((value) => value !== null) ? parsed : null;
+}
+function responseValues2(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  return Array.isArray(value) ? value : null;
+}
+function unorderedMatch(responses, correct, baseType) {
+  if (responses.length !== correct.length) {
+    return false;
+  }
+  const matched = new Set;
+  for (const response of responses) {
+    const match = correct.findIndex((candidate, index) => !matched.has(index) && matchValuesEqual(response, candidate, baseType));
+    if (match === -1) {
+      return false;
+    }
+    matched.add(match);
+  }
+  return true;
+}
+function matchComparisonCorrect(rule, values) {
+  if (rule.comparison.kind !== "match" || rule.comparison.correctValues.length === 0) {
+    return false;
+  }
+  const responses = parsedMatchValues(values, rule.baseType);
+  const correct = parsedMatchValues(rule.comparison.correctValues, rule.baseType);
+  if (!responses || !correct) {
+    return false;
+  }
+  if (rule.cardinality === "single") {
+    if (responses.length !== 1) {
+      return false;
+    }
+    if (rule.baseType === "string") {
+      return correct.some((candidate) => matchValuesEqual(responses[0], candidate, rule.baseType));
+    }
+    return correct.length === 1 && matchValuesEqual(responses[0], correct[0], rule.baseType);
+  }
+  if (responses.length !== correct.length) {
+    return false;
+  }
+  if (rule.cardinality === "ordered") {
+    return responses.every((value, index) => matchValuesEqual(value, correct[index], rule.baseType));
+  }
+  return unorderedMatch(responses, correct, rule.baseType);
+}
+function roundedNumericValue(value, roundingMode, figures) {
+  if (!Number.isFinite(value) || !Number.isSafeInteger(figures) || (roundingMode === "decimalPlaces" ? figures < 0 : figures <= 0)) {
+    return null;
+  }
+  if (roundingMode === "decimalPlaces") {
+    const multiplier2 = 10 ** figures;
+    const rounded2 = Math.round(value * multiplier2) / multiplier2;
+    return Number.isFinite(rounded2) ? rounded2 : null;
+  }
+  if (value === 0) {
+    return 0;
+  }
+  const magnitude = Math.floor(Math.log10(Math.abs(value)));
+  const multiplier = 10 ** (figures - magnitude - 1);
+  const rounded = Math.round(value * multiplier) / multiplier;
+  return Number.isFinite(rounded) ? rounded : null;
+}
+function numericResponseValue(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function numericComparisonCorrect(rule, values) {
+  if (values.length !== 1 || rule.cardinality !== "single" || rule.baseType !== "integer" && rule.baseType !== "float" || rule.comparison.kind === "match") {
+    return false;
+  }
+  const response = numericResponseValue(values[0]);
+  const correct = rule.comparison.correctValue;
+  if (response === null || !Number.isFinite(correct) || rule.baseType === "integer" && !Number.isSafeInteger(correct)) {
+    return false;
+  }
+  if (rule.comparison.kind === "numeric-equal") {
+    return response === correct;
+  }
+  const { roundingMode, figures } = rule.comparison;
+  const roundedResponse = roundedNumericValue(response, roundingMode, figures);
+  const roundedCorrect = roundedNumericValue(correct, roundingMode, figures);
+  return roundedResponse !== null && roundedCorrect !== null && roundedResponse === roundedCorrect;
+}
+function ruleCorrect(rule, responses) {
+  const response = responses?.[rule.responseIdentifier];
+  if (response === undefined) {
+    return false;
+  }
+  const values = responseValues2(response);
+  if (!values) {
+    return false;
+  }
+  return rule.comparison.kind === "match" ? matchComparisonCorrect(rule, values) : numericComparisonCorrect(rule, values);
+}
+function scorePlatformAssessmentItem(item, responses) {
+  const verdicts = item.rules.map((rule) => ruleCorrect(rule, responses));
+  const rawEarned = item.rules.reduce((total, rule, index) => total + (verdicts[index] ? rule.points : 0), 0);
+  const earned = Math.min(item.maxScore, Math.max(0, rawEarned));
+  return {
+    itemIdentifier: item.itemIdentifier,
+    score: {
+      earned,
+      possible: item.maxScore,
+      normalized: item.maxScore <= 0 ? 0 : Math.min(1, Math.max(0, earned / item.maxScore))
+    },
+    isCorrect: verdicts.length > 0 && verdicts.every(Boolean)
+  };
+}
 function reviewStandardFieldsWithinLimits(input) {
   return input.framework.trim().length <= TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength && input.identifier.trim().length <= TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength;
 }
@@ -36278,6 +36439,64 @@ function assessmentItemEarnedScore(interactionPoints, maxScore) {
   const earned = interactionPoints.reduce((sum, points) => sum + Math.max(0, points), 0);
   return Math.min(earned, maxScore);
 }
+async function assessmentChildResultPayloadHash(payload) {
+  return canonicalJsonSha256({
+    kind: ASSESSMENT_CHILD_RESULT_KIND,
+    version: ASSESSMENT_CHILD_RESULT_VERSION,
+    payload
+  });
+}
+async function buildAssessmentChildResultCommand(payload, recordedAt) {
+  const parsedPayload = AssessmentChildResultPayloadV1Schema.parse(payload);
+  const command = {
+    kind: ASSESSMENT_CHILD_RESULT_KIND,
+    version: ASSESSMENT_CHILD_RESULT_VERSION,
+    recordedAt,
+    payloadHash: await assessmentChildResultPayloadHash(parsedPayload),
+    payload: parsedPayload
+  };
+  return AssessmentChildResultCommandV1Schema.parse(command);
+}
+function normalizeOmittedResponses(value) {
+  if (!isRecord(value) || !isRecord(value.payload) || value.payload.responses !== undefined) {
+    return value;
+  }
+  return {
+    ...value,
+    payload: {
+      ...value.payload,
+      responses: {}
+    }
+  };
+}
+function parseAssessmentChildResultCommand(value) {
+  const direct = AssessmentChildResultCommandV1Schema.safeParse(normalizeOmittedResponses(value));
+  if (direct.success) {
+    return direct.data;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  const nested = AssessmentChildResultCommandV1Schema.safeParse(normalizeOmittedResponses(value[PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]));
+  return nested.success ? nested.data : null;
+}
+async function verifyAssessmentChildResultCommand(metadataOrCommand) {
+  const command = parseAssessmentChildResultCommand(metadataOrCommand);
+  if (!command) {
+    return { ok: false, reason: "malformed" };
+  }
+  if (await assessmentChildResultPayloadHash(command.payload) !== command.payloadHash) {
+    return { ok: false, reason: "payload_hash_mismatch" };
+  }
+  return { ok: true, command };
+}
+function assessmentChildResultId(attemptId, submissionId) {
+  return deterministicUUID([
+    ASSESSMENT_CHILD_RESULT_ID_NAMESPACE,
+    IdentitySchema.parse(attemptId),
+    IdentitySchema.parse(submissionId)
+  ].join("\x00"));
+}
 function normalizeMasteryStandard(input) {
   const standard = canonicalReviewStandardRef(input);
   if (!standard) {
@@ -36318,7 +36537,19 @@ function isReviewItemOutcome(value) {
   return isRecord(value) && typeof value.itemIdentifier === "string" && value.itemIdentifier.length > 0 && isAssessmentStandardRef(value.standard) && typeof value.answered === "boolean" && isAssessmentScore(value.score) && (value.isCorrect === null || typeof value.isCorrect === "boolean");
 }
 function isAssessmentItemSubmission(value) {
-  return isRecord(value) && typeof value.submissionId === "string" && value.submissionId.length > 0 && typeof value.itemIdentifier === "string" && value.itemIdentifier.length > 0 && typeof value.submittedAt === "string" && Number.isInteger(value.responseVersion) && typeof value.answered === "boolean" && isAssessmentScore(value.score) && (value.isCorrect === null || typeof value.isCorrect === "boolean");
+  return isRecord(value) && typeof value.submissionId === "string" && value.submissionId.length > 0 && typeof value.itemIdentifier === "string" && value.itemIdentifier.length > 0 && typeof value.submittedAt === "string" && Number.isInteger(value.responseVersion) && typeof value.answered === "boolean" && isAssessmentScore(value.score) && (value.isCorrect === null || typeof value.isCorrect === "boolean") && (value.grading === undefined || isAssessmentItemGrading(value.grading));
+}
+function isAssessmentItemGrading(value) {
+  if (!isRecord(value) || !isNonEmptyString(value.graderVersion)) {
+    return false;
+  }
+  if (value.source === "timeback-qti") {
+    return true;
+  }
+  if (value.source === "platform-qti-adapter") {
+    return isNonEmptyString(value.qtiGraderVersion);
+  }
+  return value.source === "platform-artifact" && isNonEmptyString(value.artifactVersion);
 }
 function isDiagnosticTrackResult(value) {
   return isRecord(value) && isNonEmptyString(value.trackKey) && (value.groupKey === undefined || isNonEmptyString(value.groupKey)) && DIAGNOSTIC_TRACK_OUTCOMES.some((outcome) => outcome === value.outcome) && isNonEmptyString(value.resultKey);
@@ -36352,8 +36583,11 @@ 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) || !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) || 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) {
     return false;
   }
   const itemIdentifiers = new Set;
@@ -36439,6 +36673,12 @@ 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) ? {
@@ -36446,10 +36686,12 @@ 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 },
@@ -36526,6 +36768,20 @@ var RESPONSE_CARDINALITIES;
 var RESPONSE_BASE_TYPES;
 var POINT_INTERACTION_TYPES;
 var INDEPENDENT_PROCESSING_TAGS;
+var PRIVATE_PLAYABLE_KEYS;
+var trimmedNonEmptyString;
+var finiteNumber2;
+var positiveFiniteNumber;
+var IDENTIFIER_VALUE;
+var DIRECTED_PAIR_VALUE;
+var scoringMatchComparisonSchema;
+var scoringNumericEqualComparisonSchema;
+var scoringNumericEqualRoundedComparisonSchema;
+var scoringRuleSchema;
+var scoringRulesSchema;
+var scoringItemSchema;
+var assessmentScoringArtifactItemsSchema;
+var assessmentScoringArtifactSchema;
 var SUPPORTED_BASE_TYPES;
 var SUPPORTED_CARDINALITIES;
 var MATCH_CORRECT_TEMPLATES;
@@ -36555,19 +36811,45 @@ var DiagnosticRoutingTransitionSchema;
 var DiagnosticRoutingManifestV1Schema;
 var GRADE_VALUES;
 var POINT_RESPONSE_PATTERN;
+var ZERO_WIDTH_CHARACTERS;
+var CURLY_SINGLE_QUOTES;
+var CURLY_DOUBLE_QUOTES;
+var UNICODE_DASHES;
+var ARITHMETIC_OPERATOR_SPACING;
+var THOUSANDS_GROUP;
 var REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1";
 var PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank";
 var PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1;
 var DEFAULT_REVIEW_SELECTION_POLICY;
 var ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 8;
+var ASSESSMENT_CHILD_RESULT_KIND = "assessment-child-result";
+var ASSESSMENT_CHILD_RESULT_VERSION = 1;
+var ASSESSMENT_CHILD_RESULT_ID_NAMESPACE = "playcademy:assessment-child-result:v1";
+var IdentitySchema;
+var RecordedAtSchema;
+var ResponseKeySchema;
+var AssessmentResponseValueSchema;
+var AssessmentScoreSchema;
+var AssessmentStandardRefSchema;
+var DiagnosticRoutingLedgerEntryV1Schema;
+var AssessmentChildResultAttemptV1Schema;
+var AssessmentChildResultAdministrationV1Schema;
+var AssessmentChildResultGradingV1Schema;
+var ReviewChildResultContextV1Schema;
+var DiagnosticChildResultContextV1Schema;
+var CommonPayloadShape;
+var ReviewChildResultPayloadV1Schema;
+var DiagnosticChildResultPayloadV1Schema;
+var AssessmentChildResultPayloadV1Schema;
+var AssessmentChildResultCommandV1Schema;
 var RuntimeSubjectSchema;
 var RuntimeGradeSchema;
 var OptionalQueryGradeSchema;
-var AssessmentResponseValueSchema;
+var AssessmentResponseValueSchema2;
 var AssessmentRuntimeIdentitySchema;
-var ResponseKeySchema;
+var ResponseKeySchema2;
 var StartAssessmentBaseSchema;
-var AssessmentStandardRefSchema;
+var AssessmentStandardRefSchema2;
 var LatestAssessmentFilterBaseSchema;
 var LatestAssessmentFiltersSchema;
 var LatestRuntimeAssessmentQuerySchema;
@@ -36592,6 +36874,7 @@ var init_assessment_runtime2 = __esm(() => {
   init_timeback3();
   init_timeback3();
   init_esm();
+  init_esm();
   init_timeback4();
   init_src();
   init_timeback3();
@@ -36599,6 +36882,9 @@ var init_assessment_runtime2 = __esm(() => {
   init_uuid();
   init_src();
   init_uuid();
+  init_esm();
+  init_src();
+  init_uuid();
   init_src();
   init_timeback4();
   init_esm();
@@ -36737,6 +37023,93 @@ var init_assessment_runtime2 = __esm(() => {
     "qti-sum",
     "qti-base-value"
   ]);
+  PRIVATE_PLAYABLE_KEYS = new Set([
+    "answer",
+    "answerkey",
+    "correctanswer",
+    "correctresponse",
+    "correctresponses",
+    "correct",
+    "correctvalue",
+    "correctvalues",
+    "iscorrect",
+    "responseprocessing",
+    "rule",
+    "rules",
+    "scoring",
+    "scoringrules",
+    "solution",
+    "expected",
+    "expectedanswer",
+    "expectedvalue",
+    "expectedvalues"
+  ]);
+  trimmedNonEmptyString = exports_external.string().min(1).refine((value) => value === value.trim());
+  finiteNumber2 = exports_external.number().finite();
+  positiveFiniteNumber = finiteNumber2.positive();
+  IDENTIFIER_VALUE = /^[A-Za-z_][\w.-]*$/;
+  DIRECTED_PAIR_VALUE = /^[A-Za-z_][\w.-]* [A-Za-z_][\w.-]*$/;
+  scoringMatchComparisonSchema = exports_external.object({
+    kind: exports_external.literal("match"),
+    correctValues: exports_external.array(trimmedNonEmptyString).min(1).refine((values) => new Set(values).size === values.length)
+  }).strict();
+  scoringNumericEqualComparisonSchema = exports_external.object({ kind: exports_external.literal("numeric-equal"), correctValue: finiteNumber2 }).strict();
+  scoringNumericEqualRoundedComparisonSchema = exports_external.object({
+    kind: exports_external.literal("numeric-equal-rounded"),
+    correctValue: finiteNumber2,
+    roundingMode: exports_external.enum(["decimalPlaces", "significantFigures"]),
+    figures: exports_external.number().int().safe().nonnegative()
+  }).strict();
+  scoringRuleSchema = exports_external.object({
+    responseIdentifier: trimmedNonEmptyString,
+    cardinality: exports_external.enum(["single", "multiple", "ordered"]),
+    baseType: exports_external.enum(["string", "identifier", "integer", "float", "directedPair"]),
+    points: positiveFiniteNumber,
+    comparison: exports_external.discriminatedUnion("kind", [
+      scoringMatchComparisonSchema,
+      scoringNumericEqualComparisonSchema,
+      scoringNumericEqualRoundedComparisonSchema
+    ])
+  }).strict().refine((rule) => rule.comparison.kind === "match" || rule.cardinality === "single" && (rule.baseType === "integer" || rule.baseType === "float")).refine((rule) => rule.baseType !== "directedPair" || rule.cardinality === "multiple" && rule.comparison.kind === "match").refine((rule) => rule.comparison.kind !== "match" || rule.cardinality !== "single" || rule.baseType === "string" || rule.comparison.correctValues.length === 1).refine((rule) => rule.comparison.kind !== "numeric-equal-rounded" || rule.comparison.roundingMode === "decimalPlaces" || rule.comparison.figures > 0).refine((rule) => {
+    if (rule.comparison.kind !== "match") {
+      return rule.baseType !== "integer" || Number.isSafeInteger(rule.comparison.correctValue);
+    }
+    if (rule.baseType === "integer" || rule.baseType === "float") {
+      return rule.comparison.correctValues.every((value) => validNumericMatchValue(value, rule.baseType));
+    }
+    if (rule.baseType === "identifier") {
+      return rule.comparison.correctValues.every((value) => IDENTIFIER_VALUE.test(value));
+    }
+    return rule.baseType !== "directedPair" || rule.comparison.correctValues.every((value) => DIRECTED_PAIR_VALUE.test(value));
+  });
+  scoringRulesSchema = exports_external.array(scoringRuleSchema).min(1).refine((rules) => new Set(rules.map((rule) => rule.responseIdentifier)).size === rules.length);
+  scoringItemSchema = exports_external.discriminatedUnion("strategy", [
+    exports_external.object({
+      strategy: exports_external.literal("qti"),
+      itemIdentifier: trimmedNonEmptyString,
+      maxScore: positiveFiniteNumber,
+      reason: exports_external.enum([
+        "response-mapping",
+        "area-mapping",
+        "unsupported-base-type",
+        "unsupported-cardinality",
+        "invalid-correct-response",
+        "no-scorable-response",
+        "unsupported-processing-template",
+        "unsupported-response-processing",
+        "cross-response-processing",
+        "inconsistent-max-score"
+      ])
+    }).strict(),
+    exports_external.object({
+      strategy: exports_external.literal("platform"),
+      itemIdentifier: trimmedNonEmptyString,
+      maxScore: positiveFiniteNumber,
+      rules: scoringRulesSchema
+    }).strict()
+  ]).refine((item) => item.strategy === "qti" || sameScore(item.rules.reduce((total, rule) => total + rule.points, 0), item.maxScore));
+  assessmentScoringArtifactItemsSchema = exports_external.array(scoringItemSchema).refine((items) => new Set(items.map((item) => item.itemIdentifier)).size === items.length);
+  assessmentScoringArtifactSchema = exports_external.object({ items: assessmentScoringArtifactItemsSchema }).strict();
   SUPPORTED_BASE_TYPES = new Set([
     "string",
     "identifier",
@@ -36863,9 +37236,140 @@ var init_assessment_runtime2 = __esm(() => {
   }).strict();
   GRADE_VALUES = TIMEBACK_GRADES;
   POINT_RESPONSE_PATTERN = /^-?\d+(?:\.\d+)? -?\d+(?:\.\d+)?$/;
+  ZERO_WIDTH_CHARACTERS = /[\u200B\uFEFF\u200C\u200D]/g;
+  CURLY_SINGLE_QUOTES = /[\u2018\u2019\u201A\u201B]/g;
+  CURLY_DOUBLE_QUOTES = /[\u201C\u201D\u201E\u201F]/g;
+  UNICODE_DASHES = /[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g;
+  ARITHMETIC_OPERATOR_SPACING = /\s*([()+\-*/xX\u00D7\u00F7\u00B7])\s*/g;
+  THOUSANDS_GROUP = /\b\d{1,3}(?:,\d{3})+(?:\.\d+)?\b/g;
   DEFAULT_REVIEW_SELECTION_POLICY = {
     version: REVIEW_SELECTION_POLICY_VERSION
   };
+  IdentitySchema = exports_external.string().min(1).refine((value) => value.trim() === value, {
+    message: "Identifiers must not contain surrounding whitespace"
+  });
+  RecordedAtSchema = exports_external.string().datetime().refine((value) => new Date(value).toISOString() === value, {
+    message: "recordedAt must be a canonical UTC timestamp"
+  });
+  ResponseKeySchema = IdentitySchema;
+  AssessmentResponseValueSchema = exports_external.custom(isAssessmentResponseValue, {
+    message: `Response values are non-empty text, at most ${TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH} characters each`
+  });
+  AssessmentScoreSchema = exports_external.object({
+    earned: exports_external.number().finite().nonnegative(),
+    possible: exports_external.number().finite().nonnegative(),
+    normalized: exports_external.number().finite().min(0).max(1)
+  }).strict().superRefine((score, context) => {
+    const expectedNormalized = score.possible === 0 ? 0 : score.earned / score.possible;
+    if (score.earned > score.possible) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "Earned score must not exceed possible score",
+        path: ["earned"]
+      });
+    }
+    if (score.normalized !== expectedNormalized) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "Normalized score must equal earned divided by possible",
+        path: ["normalized"]
+      });
+    }
+  });
+  AssessmentStandardRefSchema = exports_external.object({
+    framework: IdentitySchema,
+    identifier: IdentitySchema
+  }).strict();
+  DiagnosticRoutingLedgerEntryV1Schema = exports_external.object({
+    stageKey: IdentitySchema,
+    trackKey: IdentitySchema,
+    routingNodeKey: IdentitySchema,
+    itemIdentifier: IdentitySchema,
+    isCorrect: exports_external.boolean()
+  }).strict();
+  AssessmentChildResultAttemptV1Schema = exports_external.object({
+    attemptId: IdentitySchema,
+    gameId: IdentitySchema,
+    studentId: IdentitySchema,
+    activityId: IdentitySchema,
+    courseId: IdentitySchema,
+    integrationId: IdentitySchema,
+    enrollmentId: IdentitySchema,
+    selectedTest: exports_external.object({
+      assessmentKey: IdentitySchema,
+      identifier: IdentitySchema,
+      contentRevision: IdentitySchema
+    }).strict()
+  }).strict();
+  AssessmentChildResultAdministrationV1Schema = exports_external.object({
+    submissionId: IdentitySchema,
+    responseVersion: exports_external.number().int().positive(),
+    itemIdentifier: IdentitySchema
+  }).strict();
+  AssessmentChildResultGradingV1Schema = exports_external.discriminatedUnion("source", [
+    exports_external.object({
+      source: exports_external.literal("timeback-qti"),
+      graderVersion: IdentitySchema
+    }).strict(),
+    exports_external.object({
+      source: exports_external.literal("platform-qti-adapter"),
+      graderVersion: IdentitySchema,
+      qtiGraderVersion: IdentitySchema
+    }).strict(),
+    exports_external.object({
+      source: exports_external.literal("platform-artifact"),
+      artifactVersion: IdentitySchema,
+      graderVersion: IdentitySchema
+    }).strict()
+  ]);
+  ReviewChildResultContextV1Schema = exports_external.object({
+    kind: exports_external.literal("review"),
+    bankRevision: IdentitySchema,
+    standard: AssessmentStandardRefSchema
+  }).strict();
+  DiagnosticChildResultContextV1Schema = exports_external.object({
+    kind: exports_external.literal("platform-routed-diagnostic"),
+    definitionId: IdentitySchema,
+    diagnosticKey: IdentitySchema,
+    routingRevision: IdentitySchema,
+    transition: DiagnosticRoutingLedgerEntryV1Schema
+  }).strict();
+  CommonPayloadShape = {
+    attempt: AssessmentChildResultAttemptV1Schema,
+    administration: AssessmentChildResultAdministrationV1Schema,
+    responses: exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema),
+    score: AssessmentScoreSchema,
+    grading: AssessmentChildResultGradingV1Schema
+  };
+  ReviewChildResultPayloadV1Schema = exports_external.object({
+    ...CommonPayloadShape,
+    isCorrect: exports_external.boolean().optional(),
+    context: ReviewChildResultContextV1Schema
+  }).strict();
+  DiagnosticChildResultPayloadV1Schema = exports_external.object({
+    ...CommonPayloadShape,
+    isCorrect: exports_external.boolean(),
+    context: DiagnosticChildResultContextV1Schema
+  }).strict().superRefine((payload, context) => {
+    if (payload.context.transition.itemIdentifier !== payload.administration.itemIdentifier || payload.context.transition.isCorrect !== payload.isCorrect) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: "Diagnostic transition must match the administered item and correctness",
+        path: ["context", "transition"]
+      });
+    }
+  });
+  AssessmentChildResultPayloadV1Schema = exports_external.union([
+    ReviewChildResultPayloadV1Schema,
+    DiagnosticChildResultPayloadV1Schema
+  ]);
+  AssessmentChildResultCommandV1Schema = exports_external.object({
+    kind: exports_external.literal(ASSESSMENT_CHILD_RESULT_KIND),
+    version: exports_external.literal(ASSESSMENT_CHILD_RESULT_VERSION),
+    recordedAt: RecordedAtSchema,
+    payloadHash: exports_external.string().regex(/^[a-f0-9]{64}$/),
+    payload: AssessmentChildResultPayloadV1Schema
+  }).strict();
   RuntimeSubjectSchema = exports_external.enum(TIMEBACK_SUBJECTS);
   RuntimeGradeSchema = exports_external.number().refine(isTimebackGrade, {
     message: `Grade must be one of: ${TIMEBACK_GRADES.join(", ")}`
@@ -36876,14 +37380,14 @@ var init_assessment_runtime2 = __esm(() => {
     }
     return typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
   }, RuntimeGradeSchema.optional());
-  AssessmentResponseValueSchema = exports_external.custom(isAssessmentResponseValue, {
+  AssessmentResponseValueSchema2 = exports_external.custom(isAssessmentResponseValue, {
     message: `Response values are non-empty text, at most ${TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH} characters each`
   });
   AssessmentRuntimeIdentitySchema = exports_external.object({
     gameId: exports_external.string().uuid(),
     studentId: exports_external.string().trim().min(1)
   });
-  ResponseKeySchema = exports_external.string().refine((key) => key.length > 0 && key.trim() === key, {
+  ResponseKeySchema2 = exports_external.string().refine((key) => key.length > 0 && key.trim() === key, {
     message: "Response keys must be non-empty without surrounding whitespace"
   });
   StartAssessmentBaseSchema = exports_external.object({
@@ -36891,7 +37395,7 @@ var init_assessment_runtime2 = __esm(() => {
     subject: RuntimeSubjectSchema.optional(),
     grade: RuntimeGradeSchema.optional()
   });
-  AssessmentStandardRefSchema = exports_external.object({
+  AssessmentStandardRefSchema2 = exports_external.object({
     framework: exports_external.string().trim().min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength),
     identifier: exports_external.string().trim().min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength)
   }).refine((standard) => {
@@ -36908,7 +37412,7 @@ var init_assessment_runtime2 = __esm(() => {
     }),
     LatestAssessmentFilterBaseSchema.extend({
       purpose: exports_external.literal("mastery"),
-      standard: AssessmentStandardRefSchema
+      standard: AssessmentStandardRefSchema2
     })
   ]);
   LatestRuntimeAssessmentQuerySchema = exports_external.intersection(AssessmentRuntimeIdentitySchema, LatestAssessmentFiltersSchema);
@@ -36922,26 +37426,26 @@ var init_assessment_runtime2 = __esm(() => {
     }),
     StartAssessmentBaseSchema.extend({
       purpose: exports_external.literal("review"),
-      standards: exports_external.array(AssessmentStandardRefSchema).min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standards),
+      standards: exports_external.array(AssessmentStandardRefSchema2).min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standards),
       candidateItemsPerStandard: exports_external.number().int().positive().max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.candidateItemsPerStandard).optional()
     }),
     StartAssessmentBaseSchema.extend({
       purpose: exports_external.literal("mastery"),
-      standard: AssessmentStandardRefSchema
+      standard: AssessmentStandardRefSchema2
     })
   ]);
   AssessmentPreparationReceiptSchema = exports_external.string().max(32000);
   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(ResponseKeySchema, exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema.nullable()))
+    responses: exports_external.record(ResponseKeySchema2, exports_external.record(ResponseKeySchema2, AssessmentResponseValueSchema2.nullable()))
   });
   SubmitAssessmentItemBodySchema = exports_external.object({
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     submissionId: exports_external.string().trim().min(1),
-    itemIdentifier: ResponseKeySchema,
-    routingNodeKey: ResponseKeySchema.optional(),
-    responses: exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema.nullable())
+    itemIdentifier: ResponseKeySchema2,
+    routingNodeKey: ResponseKeySchema2.optional(),
+    responses: exports_external.record(ResponseKeySchema2, AssessmentResponseValueSchema2.nullable())
   });
   SubmitAssessmentBodySchema = exports_external.object({
     expectedResponseVersion: exports_external.number().int().nonnegative(),
@@ -61433,7 +61937,7 @@ var init_types2 = __esm(() => {
 function kebabToTitleCase(kebabStr) {
   return kebabStr.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-function isRecord5(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function resolveIntegrationSubject(patchSubject, liveSubject, storedSubject) {
@@ -61510,9 +62014,9 @@ function getGeneratedMetricValue(event, type) {
   return Number.isFinite(value) ? value : undefined;
 }
 function getMergedCaliperExtensions(event) {
-  const objectActivityExtensions = isRecord5(event.object.activity?.extensions) ? event.object.activity.extensions : undefined;
-  const generatedExtensions = isRecord5(event.generated?.extensions) ? event.generated.extensions : undefined;
-  const eventExtensions = isRecord5(event.extensions) ? event.extensions : undefined;
+  const objectActivityExtensions = isRecord4(event.object.activity?.extensions) ? event.object.activity.extensions : undefined;
+  const generatedExtensions = isRecord4(event.generated?.extensions) ? event.generated.extensions : undefined;
+  const eventExtensions = isRecord4(event.extensions) ? event.extensions : undefined;
   return {
     ...objectActivityExtensions,
     ...generatedExtensions,
@@ -61521,7 +62025,7 @@ function getMergedCaliperExtensions(event) {
 }
 function getPlaycademyMetadata(event) {
   const extensions = getMergedCaliperExtensions(event);
-  return isRecord5(extensions.playcademy) ? extensions.playcademy : undefined;
+  return isRecord4(extensions.playcademy) ? extensions.playcademy : undefined;
 }
 function getActivityId(event, playcademy) {
   const metadataActivityId = getStringValue(playcademy?.activityId);
@@ -61573,7 +62077,7 @@ function buildResourceMetadata({
 }
 function getDurationSecondsFromExtensions(event) {
   const extensions = getMergedCaliperExtensions(event);
-  const playcademy = isRecord5(extensions.playcademy) ? extensions.playcademy : undefined;
+  const playcademy = isRecord4(extensions.playcademy) ? extensions.playcademy : undefined;
   const rawValue = extensions.durationSeconds ?? playcademy?.durationSeconds;
   const value = typeof rawValue === "number" ? rawValue : Number(rawValue);
   return Number.isFinite(value) ? value : undefined;
@@ -72031,7 +72535,7 @@ var AssessmentKeySchema;
 var DiagnosticKeySchema;
 var DiagnosticRoutingManifestSchema;
 var DiagnosticAssessmentDefinitionInputSchema;
-var AssessmentStandardRefSchema2;
+var AssessmentStandardRefSchema3;
 var CreateAssessmentRequestSchema;
 var UpdateAssessmentRequestSchema;
 var CopyAssessmentRequestSchema;
@@ -72289,7 +72793,7 @@ var init_schemas4 = __esm(() => {
     diagnosticKey: DiagnosticKeySchema,
     routingManifest: DiagnosticRoutingManifestSchema
   });
-  AssessmentStandardRefSchema2 = exports_external.object({
+  AssessmentStandardRefSchema3 = exports_external.object({
     framework: exports_external.string().trim().min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength),
     identifier: exports_external.string().trim().min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength)
   });
@@ -72297,7 +72801,7 @@ var init_schemas4 = __esm(() => {
     assessmentKey: AssessmentKeySchema,
     title: exports_external.string().min(1, "Assessment title is required"),
     purpose: AssessmentPurposeSchema,
-    standard: AssessmentStandardRefSchema2.optional()
+    standard: AssessmentStandardRefSchema3.optional()
   }).superRefine((input, context2) => {
     requireMasteryStandard(input, context2);
     rejectSystemManagedReview(input, context2);
@@ -72305,7 +72809,7 @@ var init_schemas4 = __esm(() => {
   UpdateAssessmentRequestSchema = exports_external.object({
     title: exports_external.string().trim().min(1, "Assessment title is required").optional(),
     purpose: AssessmentPurposeSchema.optional(),
-    standard: AssessmentStandardRefSchema2.optional(),
+    standard: AssessmentStandardRefSchema3.optional(),
     diagnostic: DiagnosticAssessmentDefinitionInputSchema.nullable().optional(),
     status: AssessmentStatusSchema.optional()
   }).refine((input) => input.title !== undefined || input.purpose !== undefined || input.standard !== undefined || input.diagnostic !== undefined || input.status !== undefined, {
@@ -72315,7 +72819,7 @@ var init_schemas4 = __esm(() => {
     assessmentKey: AssessmentKeySchema,
     testIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
     purpose: AssessmentPurposeSchema,
-    standard: AssessmentStandardRefSchema2.optional()
+    standard: AssessmentStandardRefSchema3.optional()
   }).superRefine((input, context2) => {
     requireMasteryStandard(input, context2);
     rejectSystemManagedReview(input, context2);
@@ -72324,7 +72828,7 @@ var init_schemas4 = __esm(() => {
     assessmentKey: AssessmentKeySchema,
     qtiTestIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
     purpose: AssessmentPurposeSchema,
-    standard: AssessmentStandardRefSchema2.optional()
+    standard: AssessmentStandardRefSchema3.optional()
   }).superRefine((input, context2) => {
     requireMasteryStandard(input, context2);
     rejectSystemManagedReview(input, context2);
@@ -120539,16 +121043,16 @@ function qtiResponseMappingMaximum(input) {
     return null;
   }
   const defaultValue = mapping.defaultValue ?? 0;
-  const responseValues2 = input.responseValues ? [...new Set(input.responseValues)].map((value) => mapping.entries[value] ?? defaultValue) : entryValues;
+  const responseValues3 = input.responseValues ? [...new Set(input.responseValues)].map((value) => mapping.entries[value] ?? defaultValue) : entryValues;
   let maximum;
   if (input.cardinality === "single") {
-    maximum = Math.max(0, defaultValue, ...responseValues2);
+    maximum = Math.max(0, defaultValue, ...responseValues3);
   } else {
     if (!input.responseValues && defaultValue > 0) {
       return null;
     }
-    const limit = Math.min(input.maximumResponses ?? responseValues2.length, responseValues2.length);
-    maximum = responseValues2.toSorted((left, right) => right - left).slice(0, limit).reduce((sum, value) => sum + Math.max(0, value), 0);
+    const limit = Math.min(input.maximumResponses ?? responseValues3.length, responseValues3.length);
+    maximum = responseValues3.toSorted((left, right) => right - left).slice(0, limit).reduce((sum, value) => sum + Math.max(0, value), 0);
   }
   if (mapping.lowerBound !== undefined) {
     maximum = Math.max(maximum, mapping.lowerBound);
@@ -121110,16 +121614,16 @@ function authoredMappingContext(interaction, declaration) {
     return {};
   }
   const type = qtiAuthoringInteractionType(interaction);
-  let responseValues2;
+  let responseValues3;
   if (type === "choice" || type === "inline-choice" || type === "order" || type === "hotspot") {
-    responseValues2 = interaction.choices?.map((choice) => String(choice.identifier)) ?? [];
+    responseValues3 = interaction.choices?.map((choice) => String(choice.identifier)) ?? [];
   } else if (type === "hottext") {
-    responseValues2 = (interaction.textSegments ?? []).flatMap((segment) => segment.selectable && segment.identifier ? [segment.identifier] : []);
+    responseValues3 = (interaction.textSegments ?? []).flatMap((segment) => segment.selectable && segment.identifier ? [segment.identifier] : []);
   } else if (type === "match" || type === "graphic-gap-match") {
     const [left = [], right = []] = interaction.choiceSets ?? [];
-    responseValues2 = authoredResponsePairs(left.map((choice) => String(choice.identifier)), right.map((choice) => String(choice.identifier)));
+    responseValues3 = authoredResponsePairs(left.map((choice) => String(choice.identifier)), right.map((choice) => String(choice.identifier)));
   }
-  const capacity = responseValues2?.length ?? Object.keys(declaration.mapping?.entries ?? {}).length;
+  const capacity = responseValues3?.length ?? Object.keys(declaration.mapping?.entries ?? {}).length;
   const limitAttribute = type === "match" || type === "gap-match" || type === "graphic-associate" || type === "graphic-gap-match" ? "max-associations" : "max-choices";
   const rawLimit = interaction.attributes?.[limitAttribute];
   const declaredLimit = rawLimit === undefined ? undefined : Number(rawLimit);
@@ -121138,7 +121642,7 @@ function authoredMappingContext(interaction, declaration) {
     maximumResponses = capacity;
   }
   return {
-    ...responseValues2 ? { responseValues: responseValues2 } : {},
+    ...responseValues3 ? { responseValues: responseValues3 } : {},
     ...maximumResponses > 0 ? { maximumResponses } : {}
   };
 }
@@ -121322,6 +121826,13 @@ function qtiGapContentMatchesGaps(nodes, gaps) {
   const identifiers = gapContentIdentifiers(nodes);
   return identifiers.length === gaps.length && identifiers.every((identifier, index2) => identifier === gaps[index2]);
 }
+function qtiFloatValue(value) {
+  if (value === undefined || !QTI_FLOAT_VALUE.test(value.trim())) {
+    return;
+  }
+  const number7 = Number(value);
+  return Number.isFinite(number7) ? number7 : undefined;
+}
 function normalizedInteractionType(value) {
   if (typeof value !== "string") {
     return;
@@ -121540,24 +122051,24 @@ function interactionResponseSpace(item, declaration) {
     }
     case "match": {
       const [source = [], target = []] = interaction.choiceSets;
-      const responseValues2 = responsePairs(source.map((choice) => choice.identifier), target.map((choice) => choice.identifier));
+      const responseValues3 = responsePairs(source.map((choice) => choice.identifier), target.map((choice) => choice.identifier));
       return {
-        responseValues: responseValues2,
-        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 1, responseValues2.length)
+        responseValues: responseValues3,
+        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 1, responseValues3.length)
       };
     }
     case "hottext": {
-      const responseValues2 = interaction.textSegments.flatMap((segment) => segment.selectable && segment.identifier ? [segment.identifier] : []);
+      const responseValues3 = interaction.textSegments.flatMap((segment) => segment.selectable && segment.identifier ? [segment.identifier] : []);
       return {
-        responseValues: responseValues2,
-        maximumResponses: qtiAttributeMaximum(attributes2, "max-choices", 1, responseValues2.length)
+        responseValues: responseValues3,
+        maximumResponses: qtiAttributeMaximum(attributes2, "max-choices", 1, responseValues3.length)
       };
     }
     case "gap-match": {
-      const responseValues2 = responsePairs(interaction.gapTexts.map((choice) => choice.identifier), interaction.gaps);
+      const responseValues3 = responsePairs(interaction.gapTexts.map((choice) => choice.identifier), interaction.gaps);
       return {
-        responseValues: responseValues2,
-        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 0, responseValues2.length)
+        responseValues: responseValues3,
+        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 0, responseValues3.length)
       };
     }
     case "hotspot": {
@@ -121567,10 +122078,10 @@ function interactionResponseSpace(item, declaration) {
       };
     }
     case "graphic-gap-match": {
-      const responseValues2 = responsePairs(interaction.gapImages.map((choice) => choice.identifier), interaction.hotspots.map((hotspot) => hotspot.identifier));
+      const responseValues3 = responsePairs(interaction.gapImages.map((choice) => choice.identifier), interaction.hotspots.map((hotspot) => hotspot.identifier));
       return {
-        responseValues: responseValues2,
-        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 0, responseValues2.length)
+        responseValues: responseValues3,
+        maximumResponses: qtiAttributeMaximum(attributes2, "max-associations", 0, responseValues3.length)
       };
     }
     case "graphic-associate": {
@@ -121615,8 +122126,8 @@ function responseMappingMaximum(item, declaration, space) {
 function qtiItemScoringValidationMessage(item) {
   for (const declaration of item.responseDeclarations) {
     const space = interactionResponseSpace(item, declaration);
-    const { responseValues: responseValues2, maximumResponses } = space;
-    if (responseValues2 && declaration.correctValues.some((value) => !responseValues2.includes(value))) {
+    const { responseValues: responseValues3, maximumResponses } = space;
+    if (responseValues3 && declaration.correctValues.some((value) => !responseValues3.includes(value))) {
       return `Response ${declaration.identifier} declares a correct value its interaction cannot produce.`;
     }
     const interaction = item.interactions.find((candidate) => candidate.responseIdentifier === declaration.identifier);
@@ -121656,13 +122167,13 @@ function qtiItemScoringValidationMessage(item) {
 }
 function qtiItemMaxScore(item) {
   const maxScore = item.outcomeDeclarations.find((declaration) => declaration.identifier.toUpperCase() === "MAXSCORE");
-  const declaredMaxScore = Number(maxScore?.defaultValues[0]);
-  if (Number.isFinite(declaredMaxScore) && declaredMaxScore > 0) {
+  const declaredMaxScore = qtiFloatValue(maxScore?.defaultValues[0]);
+  if (declaredMaxScore !== undefined && declaredMaxScore > 0) {
     return declaredMaxScore;
   }
   const score = item.outcomeDeclarations.find((declaration) => declaration.identifier.toUpperCase() === "SCORE");
-  const normalMaximum = Number(score?.attributes["normal-maximum"]);
-  if (Number.isFinite(normalMaximum) && normalMaximum > 0) {
+  const normalMaximum = qtiFloatValue(score?.attributes["normal-maximum"]);
+  if (normalMaximum !== undefined && normalMaximum > 0) {
     return normalMaximum;
   }
   const inferredMaximum = item.responseDeclarations.reduce((total, declaration) => {
@@ -121690,7 +122201,7 @@ function scoresResponsesIndependently(item, scoredIdentifiers) {
   if (!processing) {
     return true;
   }
-  if (processing.attributes.template || processing.conditions.length !== scoredIdentifiers.size || !processing.elements.every((element) => INDEPENDENT_PROCESSING_TAGS2.has(element.tagName)) || !processing.baseValues.every((base) => Number.isFinite(Number(base.value)))) {
+  if (processing.attributes.template || processing.conditions.length !== scoredIdentifiers.size || !processing.elements.every((element) => INDEPENDENT_PROCESSING_TAGS2.has(element.tagName)) || !processing.baseValues.every((base) => qtiFloatValue(base.value) !== undefined)) {
     return false;
   }
   const declaredIdentifiers = new Set(item.responseDeclarations.map((declaration) => declaration.identifier));
@@ -121778,6 +122289,40 @@ function supportedQtiQuestionInteractionType(question) {
     return null;
   }
 }
+function validNumericMatchValue2(value, baseType) {
+  const syntax = baseType === "integer" ? /^[+-]?\d+$/ : /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+  if (!syntax.test(value.trim())) {
+    return false;
+  }
+  const numeric3 = Number(value);
+  return Number.isFinite(numeric3) && (baseType === "float" || Number.isSafeInteger(numeric3));
+}
+function sameScore2(left, right) {
+  return Number.isFinite(left) && Number.isFinite(right) && Math.abs(left - right) <= Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function scoringItemMatchesPlayableItem(scoringItem, item) {
+  if (!sameScore2(scoringItem.maxScore, item.maxScore)) {
+    return false;
+  }
+  if (scoringItem.strategy === "qti") {
+    return true;
+  }
+  const playableResponses = new Set(item.interactions.map((interaction) => interaction.responseIdentifier));
+  const scoringResponses = new Set(scoringItem.rules.map((rule) => rule.responseIdentifier));
+  return playableResponses.size === item.interactions.length && scoringResponses.size === scoringItem.rules.length && playableResponses.size === scoringResponses.size && [...playableResponses].every((identifier) => scoringResponses.has(identifier));
+}
+function normalizedKey(key) {
+  return key.replaceAll(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function containsPrivatePlayableAssessmentData(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsPrivatePlayableAssessmentData);
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.entries(value).some(([key, entry2]) => PRIVATE_PLAYABLE_KEYS2.has(normalizedKey(key)) || containsPrivatePlayableAssessmentData(entry2));
+}
 function childElements(node, localName2) {
   return node.children.filter((child) => child.kind === "element" && (!localName2 || child.localName === localName2));
 }
@@ -121819,6 +122364,22 @@ function numericCorrectValue(declaration) {
   }
   return parsedNumericValue(declaration.correctValues[0], declaration.baseType);
 }
+function rawCorrectValues(declaration) {
+  const correctResponses = childElements(declaration, "qti-correct-response");
+  const correctResponse = correctResponses.length === 1 ? correctResponses[0] : undefined;
+  if (!correctResponse || !onlyWhitespaceText(correctResponse.children)) {
+    return null;
+  }
+  const values = childElements(correctResponse);
+  if (values.length === 0 || values.some((value) => value.localName !== "qti-value" || !onlyAttributes(value, []))) {
+    return null;
+  }
+  const rawValues = values.map((value) => {
+    const text3 = directText(value);
+    return text3 === null ? null : decodeXmlEntities(text3).trim();
+  });
+  return rawValues.every((value) => value !== null) ? rawValues : null;
+}
 function declarationResult(raw, normalized) {
   const identifier = raw.attributes.identifier?.trim();
   if (!normalized || !identifier || normalized.identifier !== identifier) {
@@ -121835,16 +122396,23 @@ function declarationResult(raw, normalized) {
   if (baseType === "directedPair" && cardinality !== "multiple") {
     return { reason: "unsupported-cardinality" };
   }
+  const correctValues = rawCorrectValues(raw);
+  if (!correctValues) {
+    return { reason: "invalid-correct-response" };
+  }
   const declaration = {
     identifier,
     cardinality,
     baseType,
-    correctValues: [...normalized.correctValues]
+    correctValues
   };
-  if (declaration.correctValues.length === 0 || declaration.correctValues.some((value) => value.trim() === "") || declaration.cardinality === "single" && declaration.correctValues.length !== 1 && declaration.baseType !== "string") {
+  if (declaration.correctValues.length === 0 || declaration.correctValues.some((value) => value.trim() === "") || new Set(declaration.correctValues).size !== declaration.correctValues.length || declaration.cardinality === "single" && declaration.correctValues.length !== 1 && declaration.baseType !== "string") {
+    return { reason: "invalid-correct-response" };
+  }
+  if (declaration.baseType === "identifier" && declaration.correctValues.some((value) => !IDENTIFIER_VALUE2.test(value))) {
     return { reason: "invalid-correct-response" };
   }
-  if (declaration.baseType === "directedPair" && (declaration.correctValues.some((value) => !DIRECTED_PAIR_VALUE.test(value)) || new Set(declaration.correctValues).size !== declaration.correctValues.length)) {
+  if (declaration.baseType === "directedPair" && declaration.correctValues.some((value) => !DIRECTED_PAIR_VALUE2.test(value))) {
     return { reason: "invalid-correct-response" };
   }
   if ((declaration.baseType === "integer" || declaration.baseType === "float") && declaration.correctValues.some((value) => parsedNumericValue(value, declaration.baseType) === null)) {
@@ -121860,16 +122428,14 @@ function scoringDeclarations(rawDeclarations, normalizedDeclarations) {
   const declarations = new Map;
   for (const [index2, rawDeclaration] of rawDeclarations.entries()) {
     const normalized = normalizedDeclarations[index2];
-    if (normalized?.correctValues.length) {
-      const result = declarationResult(rawDeclaration, normalized);
-      if ("reason" in result) {
-        return result;
-      }
-      if (declarations.has(result.declaration.identifier)) {
-        return { reason: "invalid-correct-response" };
-      }
-      declarations.set(result.declaration.identifier, result.declaration);
+    const result = declarationResult(rawDeclaration, normalized);
+    if ("reason" in result) {
+      return result;
+    }
+    if (declarations.has(result.declaration.identifier)) {
+      return { reason: "invalid-correct-response" };
     }
+    declarations.set(result.declaration.identifier, result.declaration);
   }
   return declarations.size > 0 ? { declarations } : { reason: "no-scorable-response" };
 }
@@ -121879,15 +122445,12 @@ function declarationConstructReason(declarations) {
   }
   return declarations.some((declaration) => childElements(declaration, "qti-area-mapping").length > 0) ? "area-mapping" : null;
 }
-function sameScore(left, right) {
-  return Math.abs(left - right) <= Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right));
-}
 function platformResult(itemIdentifier, parsedMaxScore, rules) {
   const ruleMaximum = rules.reduce((sum, rule) => sum + rule.points, 0);
   if (!Number.isFinite(ruleMaximum) || ruleMaximum <= 0) {
     return fallback(itemIdentifier, parsedMaxScore, "no-scorable-response");
   }
-  if (!sameScore(parsedMaxScore, ruleMaximum)) {
+  if (!sameScore2(parsedMaxScore, ruleMaximum)) {
     return fallback(itemIdentifier, parsedMaxScore, "inconsistent-max-score");
   }
   return {
@@ -121948,9 +122511,8 @@ function comparisonResult(comparison, declaration) {
     return null;
   }
   const roundingMode = comparison.attributes["rounding-mode"];
-  const figures = Number(comparison.attributes.figures);
-  const validFigures = Number.isInteger(figures) && (roundingMode === "decimalPlaces" ? figures >= 0 : figures > 0);
-  if (roundingMode !== "decimalPlaces" && roundingMode !== "significantFigures" || !validFigures) {
+  const figures = parsedNumericValue(comparison.attributes.figures ?? "", "integer");
+  if (roundingMode !== "decimalPlaces" && roundingMode !== "significantFigures" || figures === null || (roundingMode === "decimalPlaces" ? figures < 0 : figures <= 0)) {
     return null;
   }
   return {
@@ -121982,8 +122544,47 @@ function additivePoints(setOutcome) {
     return null;
   }
   const rawPoints = directText(pointValue);
-  const points = rawPoints === null ? Number.NaN : Number(rawPoints);
-  return Number.isFinite(points) && points > 0 ? points : null;
+  const points = rawPoints === null ? null : parsedNumericValue(rawPoints, "float");
+  return points !== null && points > 0 ? points : null;
+}
+function constantOutcomeValue(setOutcome, identifier, baseType) {
+  if (!setOutcome || setOutcome.localName !== "qti-set-outcome-value" || !onlyAttributes(setOutcome, ["identifier"]) || setOutcome.attributes.identifier !== identifier || !onlyWhitespaceText(setOutcome.children)) {
+    return null;
+  }
+  const values = childElements(setOutcome);
+  const value = values.length === 1 ? values[0] : undefined;
+  return value && value.localName === "qti-base-value" && onlyAttributes(value, ["base-type"]) && value.attributes["base-type"] === baseType ? directText(value) : null;
+}
+function feedbackOutcomeIsDeclared(item) {
+  const feedbackOutcomes = childElements(item, "qti-outcome-declaration").filter((outcome) => outcome.attributes.identifier === "FEEDBACK");
+  const feedback = feedbackOutcomes[0];
+  return feedbackOutcomes.length === 1 && feedback !== undefined && onlyAttributes(feedback, ["identifier", "cardinality", "base-type"]) && feedback.attributes.cardinality === "single" && feedback.attributes["base-type"] === "identifier" && childElements(feedback).length === 0 && onlyWhitespaceText(feedback.children);
+}
+function binaryBranchRule(condition, declaration) {
+  if (!onlyAttributes(condition, []) || !onlyWhitespaceText(condition.children)) {
+    return null;
+  }
+  const branches = childElements(condition);
+  const responseIf = branches[0];
+  const responseElse = branches[1];
+  if (branches.length !== 2 || responseIf?.localName !== "qti-response-if" || responseElse?.localName !== "qti-response-else" || !onlyAttributes(responseIf, []) || !onlyAttributes(responseElse, []) || !onlyWhitespaceText(responseIf.children) || !onlyWhitespaceText(responseElse.children)) {
+    return null;
+  }
+  const ifChildren = childElements(responseIf);
+  const elseChildren = childElements(responseElse);
+  const [comparison, ifFeedback, ifScore] = ifChildren;
+  const [elseFeedback, elseScore] = elseChildren;
+  const comparisonPayload = comparison ? comparisonResult(comparison, declaration) : null;
+  if (ifChildren.length !== 3 || elseChildren.length !== 2 || !comparisonPayload || constantOutcomeValue(ifFeedback, "FEEDBACK", "identifier") !== "CORRECT" || constantOutcomeValue(ifScore, "SCORE", "float") !== "1" || constantOutcomeValue(elseFeedback, "FEEDBACK", "identifier") !== "INCORRECT" || constantOutcomeValue(elseScore, "SCORE", "float") !== "0") {
+    return null;
+  }
+  return {
+    responseIdentifier: declaration.identifier,
+    cardinality: declaration.cardinality,
+    baseType: declaration.baseType,
+    points: 1,
+    comparison: comparisonPayload
+  };
 }
 function additiveRule(condition, declarations) {
   const responseIdentifiers = new Set(declarations.keys());
@@ -122061,7 +122662,7 @@ function scoreDefaultIsZero(item) {
   }
   const values = childElements(defaults[0], "qti-value");
   const defaultText = values.length === 1 ? directText(values[0]) : null;
-  return defaultText !== null && defaultText !== "" && Number(defaultText) === 0;
+  return defaultText !== null && parsedNumericValue(defaultText, "float") === 0;
 }
 function compileResponseProcessing(item, itemIdentifier, maxScore, declarations) {
   const processingElements = childElements(item, "qti-response-processing");
@@ -122084,7 +122685,17 @@ function compileResponseProcessing(item, itemIdentifier, maxScore, declarations)
     const response = declarations.get("RESPONSE");
     return response && declarations.size === 1 ? platformResult(itemIdentifier, maxScore, [matchRule(response, 1)]) : fallback(itemIdentifier, maxScore, "unsupported-response-processing");
   }
-  if (!onlyAttributes(processing, []) || !onlyWhitespaceText(processing.children) || processingRules.length === 0 || processingRules.some((rule) => rule.localName !== "qti-response-condition") || !scoreDefaultIsZero(item)) {
+  if (!onlyAttributes(processing, []) || !onlyWhitespaceText(processing.children) || processingRules.length === 0 || processingRules.some((rule) => rule.localName !== "qti-response-condition")) {
+    return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+  }
+  if (processingRules.length === 1 && declarations.size === 1 && scoreDefaultIsZero(item) && feedbackOutcomeIsDeclared(item)) {
+    const declaration = [...declarations.values()][0];
+    const rule = binaryBranchRule(processingRules[0], declaration);
+    if (rule) {
+      return platformResult(itemIdentifier, maxScore, [rule]);
+    }
+  }
+  if (!scoreDefaultIsZero(item)) {
     return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
   }
   const compiled = additiveRules(processingRules, declarations);
@@ -122137,7 +122748,7 @@ function compileQtiScoringArtifact(questions) {
   });
   return { items };
 }
-function isRecord22(value) {
+function isRecord32(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function stringField2(value) {
@@ -122221,13 +122832,13 @@ function dedupeStandards2(standards) {
   return [...deduped.values()];
 }
 function qtiAlignmentStandardsFromMetadata2(metadata2) {
-  if (!isRecord22(metadata2)) {
+  if (!isRecord32(metadata2)) {
     return [];
   }
   const standards = [];
   const alignmentGroups = Array.isArray(metadata2.alignment) ? metadata2.alignment : [];
   for (const group of alignmentGroups) {
-    if (isRecord22(group)) {
+    if (isRecord32(group)) {
       const source = stringField2(group.curriculum) || "QTI";
       const domains2 = Array.isArray(group.domains) ? group.domains : [];
       if (!domains2.length) {
@@ -122245,11 +122856,11 @@ function qtiAlignmentStandardsFromMetadata2(metadata2) {
         }
       } else {
         for (const domain3 of domains2) {
-          if (isRecord22(domain3)) {
+          if (isRecord32(domain3)) {
             const domainName = stringField2(domain3.name) || undefined;
             const domainStandards = Array.isArray(domain3.standards) ? domain3.standards : [];
             for (const standard of domainStandards) {
-              if (isRecord22(standard)) {
+              if (isRecord32(standard)) {
                 const identifier = stringField2(standard.identifier).trim();
                 const id = stringField2(standard.id).trim() || identifier;
                 if (id) {
@@ -122272,13 +122883,13 @@ function qtiAlignmentStandardsFromMetadata2(metadata2) {
   return dedupeStandards2(standards);
 }
 function qtiStandardsFromMetadata(metadata2) {
-  if (!isRecord22(metadata2)) {
+  if (!isRecord32(metadata2)) {
     return [];
   }
   const standards = [];
   const objectiveSets = Array.isArray(metadata2.learningObjectiveSet) ? metadata2.learningObjectiveSet : [];
   for (const set3 of objectiveSets) {
-    if (isRecord22(set3)) {
+    if (isRecord32(set3)) {
       const source = stringField2(set3.source) || "QTI";
       const ids = Array.isArray(set3.learningObjectiveIds) ? set3.learningObjectiveIds : [];
       for (const id of ids) {
@@ -122333,13 +122944,27 @@ var NUMERIC_COMPARISON_ATTRIBUTES2;
 var RESPONSE_CARDINALITIES2;
 var RESPONSE_BASE_TYPES2;
 var BLANK_SENTINEL22 = "￿";
+var QTI_FLOAT_VALUE;
 var PLAYABLE_POINT_VALUE;
 var POINT_INTERACTION_TYPES2;
 var INDEPENDENT_PROCESSING_TAGS2;
+var PRIVATE_PLAYABLE_KEYS2;
+var trimmedNonEmptyString2;
+var finiteNumber22;
+var positiveFiniteNumber2;
+var IDENTIFIER_VALUE2;
+var DIRECTED_PAIR_VALUE2;
+var scoringMatchComparisonSchema2;
+var scoringNumericEqualComparisonSchema2;
+var scoringNumericEqualRoundedComparisonSchema2;
+var scoringRuleSchema2;
+var scoringRulesSchema2;
+var scoringItemSchema2;
+var assessmentScoringArtifactItemsSchema2;
+var assessmentScoringArtifactSchema2;
 var SUPPORTED_BASE_TYPES2;
 var SUPPORTED_CARDINALITIES2;
 var MATCH_CORRECT_TEMPLATES2;
-var DIRECTED_PAIR_VALUE;
 var QtiScoringArtifactValidationError;
 var COMMON_CORE_MATH_FRAMEWORK_ALIASES2;
 var COMMON_CORE_ELA_FRAMEWORK_ALIASES2;
@@ -122351,6 +122976,7 @@ var init_qti = __esm(() => {
   init_timeback3();
   init_timeback3();
   init_timeback3();
+  init_esm();
   EVENT_HANDLER_ATTRIBUTE = /^on/i;
   SCRIPT_SCHEMES2 = {
     javascript: ["java", "script:"].join(""),
@@ -122575,6 +123201,7 @@ var init_qti = __esm(() => {
     "string",
     "uri"
   ]);
+  QTI_FLOAT_VALUE = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
   PLAYABLE_POINT_VALUE = /^-?\d+(?:\.\d+)? -?\d+(?:\.\d+)?$/;
   POINT_INTERACTION_TYPES2 = new Set([
     "select-point",
@@ -122593,6 +123220,93 @@ var init_qti = __esm(() => {
     "qti-sum",
     "qti-base-value"
   ]);
+  PRIVATE_PLAYABLE_KEYS2 = new Set([
+    "answer",
+    "answerkey",
+    "correctanswer",
+    "correctresponse",
+    "correctresponses",
+    "correct",
+    "correctvalue",
+    "correctvalues",
+    "iscorrect",
+    "responseprocessing",
+    "rule",
+    "rules",
+    "scoring",
+    "scoringrules",
+    "solution",
+    "expected",
+    "expectedanswer",
+    "expectedvalue",
+    "expectedvalues"
+  ]);
+  trimmedNonEmptyString2 = exports_external.string().min(1).refine((value) => value === value.trim());
+  finiteNumber22 = exports_external.number().finite();
+  positiveFiniteNumber2 = finiteNumber22.positive();
+  IDENTIFIER_VALUE2 = /^[A-Za-z_][\w.-]*$/;
+  DIRECTED_PAIR_VALUE2 = /^[A-Za-z_][\w.-]* [A-Za-z_][\w.-]*$/;
+  scoringMatchComparisonSchema2 = exports_external.object({
+    kind: exports_external.literal("match"),
+    correctValues: exports_external.array(trimmedNonEmptyString2).min(1).refine((values) => new Set(values).size === values.length)
+  }).strict();
+  scoringNumericEqualComparisonSchema2 = exports_external.object({ kind: exports_external.literal("numeric-equal"), correctValue: finiteNumber22 }).strict();
+  scoringNumericEqualRoundedComparisonSchema2 = exports_external.object({
+    kind: exports_external.literal("numeric-equal-rounded"),
+    correctValue: finiteNumber22,
+    roundingMode: exports_external.enum(["decimalPlaces", "significantFigures"]),
+    figures: exports_external.number().int().safe().nonnegative()
+  }).strict();
+  scoringRuleSchema2 = exports_external.object({
+    responseIdentifier: trimmedNonEmptyString2,
+    cardinality: exports_external.enum(["single", "multiple", "ordered"]),
+    baseType: exports_external.enum(["string", "identifier", "integer", "float", "directedPair"]),
+    points: positiveFiniteNumber2,
+    comparison: exports_external.discriminatedUnion("kind", [
+      scoringMatchComparisonSchema2,
+      scoringNumericEqualComparisonSchema2,
+      scoringNumericEqualRoundedComparisonSchema2
+    ])
+  }).strict().refine((rule) => rule.comparison.kind === "match" || rule.cardinality === "single" && (rule.baseType === "integer" || rule.baseType === "float")).refine((rule) => rule.baseType !== "directedPair" || rule.cardinality === "multiple" && rule.comparison.kind === "match").refine((rule) => rule.comparison.kind !== "match" || rule.cardinality !== "single" || rule.baseType === "string" || rule.comparison.correctValues.length === 1).refine((rule) => rule.comparison.kind !== "numeric-equal-rounded" || rule.comparison.roundingMode === "decimalPlaces" || rule.comparison.figures > 0).refine((rule) => {
+    if (rule.comparison.kind !== "match") {
+      return rule.baseType !== "integer" || Number.isSafeInteger(rule.comparison.correctValue);
+    }
+    if (rule.baseType === "integer" || rule.baseType === "float") {
+      return rule.comparison.correctValues.every((value) => validNumericMatchValue2(value, rule.baseType));
+    }
+    if (rule.baseType === "identifier") {
+      return rule.comparison.correctValues.every((value) => IDENTIFIER_VALUE2.test(value));
+    }
+    return rule.baseType !== "directedPair" || rule.comparison.correctValues.every((value) => DIRECTED_PAIR_VALUE2.test(value));
+  });
+  scoringRulesSchema2 = exports_external.array(scoringRuleSchema2).min(1).refine((rules) => new Set(rules.map((rule) => rule.responseIdentifier)).size === rules.length);
+  scoringItemSchema2 = exports_external.discriminatedUnion("strategy", [
+    exports_external.object({
+      strategy: exports_external.literal("qti"),
+      itemIdentifier: trimmedNonEmptyString2,
+      maxScore: positiveFiniteNumber2,
+      reason: exports_external.enum([
+        "response-mapping",
+        "area-mapping",
+        "unsupported-base-type",
+        "unsupported-cardinality",
+        "invalid-correct-response",
+        "no-scorable-response",
+        "unsupported-processing-template",
+        "unsupported-response-processing",
+        "cross-response-processing",
+        "inconsistent-max-score"
+      ])
+    }).strict(),
+    exports_external.object({
+      strategy: exports_external.literal("platform"),
+      itemIdentifier: trimmedNonEmptyString2,
+      maxScore: positiveFiniteNumber2,
+      rules: scoringRulesSchema2
+    }).strict()
+  ]).refine((item) => item.strategy === "qti" || sameScore2(item.rules.reduce((total, rule) => total + rule.points, 0), item.maxScore));
+  assessmentScoringArtifactItemsSchema2 = exports_external.array(scoringItemSchema2).refine((items) => new Set(items.map((item) => item.itemIdentifier)).size === items.length);
+  assessmentScoringArtifactSchema2 = exports_external.object({ items: assessmentScoringArtifactItemsSchema2 }).strict();
   SUPPORTED_BASE_TYPES2 = new Set([
     "string",
     "identifier",
@@ -122610,7 +123324,6 @@ var init_qti = __esm(() => {
     "https://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct",
     "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/match_correct"
   ].flatMap((template) => [template, `${template}.xml`]));
-  DIRECTED_PAIR_VALUE = /^[A-Za-z_][\w.-]* [A-Za-z_][\w.-]*$/;
   QtiScoringArtifactValidationError = class QtiScoringArtifactValidationError2 extends Error {
     constructor(message) {
       super(message);
@@ -124972,50 +125685,38 @@ var init_timeback_admin_service = __esm(async () => {
     init_timeback_mastery_completion_util()
   ]);
 });
-function normalizedKey(key) {
-  return key.replaceAll(/[^a-z0-9]/gi, "").toLowerCase();
-}
-function containsPrivatePlayableKey(value) {
-  if (Array.isArray(value)) {
-    return value.some(containsPrivatePlayableKey);
-  }
-  if (!isRecord(value)) {
-    return false;
-  }
-  return Object.entries(value).some(([key, entry2]) => PRIVATE_PLAYABLE_KEYS.has(normalizedKey(key)) || containsPrivatePlayableKey(entry2));
-}
 function playableSchema(identity) {
   return exports_external.object({
     contractVersion: exports_external.literal(PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION),
     identifier: exports_external.literal(identity.qtiTestIdentifier),
     contentRevision: exports_external.literal(identity.kind === "assessment" ? identity.contentRevision : identity.sourceContentRevision),
-    title: trimmedNonEmptyString,
+    title: trimmedNonEmptyString3,
     items: exports_external.array(playableItemSchema)
   }).strict();
 }
 function scoringSchema(identity) {
   if (identity.kind === "assessment") {
     return exports_external.object({
-      items: uniqueScoringItemsSchema,
+      items: assessmentScoringArtifactItemsSchema2,
       reviewBank: exports_external.undefined(),
       diagnostic: diagnosticContextSchema.optional()
-    });
+    }).strict();
   }
   return exports_external.object({
-    items: uniqueScoringItemsSchema,
+    items: assessmentScoringArtifactItemsSchema2,
     reviewBank: exports_external.object({
       sourceContentRevision: exports_external.literal(identity.sourceContentRevision),
       bankRevision: exports_external.literal(identity.bankRevision),
       items: exports_external.array(exports_external.object({
-        itemIdentifier: trimmedNonEmptyString,
+        itemIdentifier: trimmedNonEmptyString3,
         standards: exports_external.array(exports_external.unknown())
-      }))
-    }),
+      }).strict())
+    }).strict(),
     diagnostic: exports_external.undefined()
-  }).refine((payload) => payload.reviewBank.items.length === payload.items.length && payload.reviewBank.items.every((item, index2) => item.itemIdentifier === payload.items[index2]?.itemIdentifier));
+  }).strict().refine((payload) => payload.reviewBank.items.length === payload.items.length && payload.reviewBank.items.every((item, index2) => item.itemIdentifier === payload.items[index2]?.itemIdentifier));
 }
 function assertPlayableAssessmentArtifact(payload, identity) {
-  if (!playableSchema(identity).safeParse(payload).success || containsPrivatePlayableKey(payload)) {
+  if (!playableSchema(identity).safeParse(payload).success || containsPrivatePlayableAssessmentData(payload)) {
     throw new ValidationError("Playable assessment artifact payload is invalid or private");
   }
 }
@@ -125025,8 +125726,11 @@ function assertScoringAssessmentArtifact(payload, identity) {
   }
 }
 function assertScoringArtifactMatchesPlayable(assessment, scoring, identity) {
-  const scoringByIdentifier = new Map(scoring.items.map((item) => [item.itemIdentifier, item.maxScore]));
-  const playableMatches = assessment.items.every((item) => scoringByIdentifier.get(item.identifier) === item.maxScore);
+  const scoringByIdentifier = new Map(scoring.items.map((item) => [item.itemIdentifier, item]));
+  const playableMatches = assessment.items.every((item) => {
+    const scoringItem = scoringByIdentifier.get(item.identifier);
+    return scoringItem !== undefined && scoringItemMatchesPlayableItem(scoringItem, item);
+  });
   const hasExactManagedMembership = identity.kind === "review-bank" || scoring.items.length === assessment.items.length;
   if (!playableMatches || !hasExactManagedMembership) {
     throw new ValidationError("Scoring artifact does not match the playable assessment");
@@ -125064,9 +125768,9 @@ function pinnedReviewBankFromAttempt(metadata2, bankIdentifier) {
     }))
   };
 }
-var PRIVATE_PLAYABLE_KEYS;
-var trimmedNonEmptyString;
-var finiteNumber2;
+var trimmedNonEmptyString3;
+var finiteNumber3;
+var positiveFiniteNumber3;
 var nonnegativeInteger;
 var playableContentNodesSchema;
 var playableChoiceSchema;
@@ -125078,76 +125782,54 @@ var playableGapImageSchema;
 var playableInteractionBase;
 var playableInteractionSchema;
 var playableItemSchema;
-var scoringRuleSchema;
-var scoringItemSchema;
-var uniqueScoringItemsSchema;
 var diagnosticContextSchema;
 var init_assessment_artifact_runtime_util = __esm(() => {
   init_esm();
   init_src();
+  init_qti();
   init_errors2();
-  PRIVATE_PLAYABLE_KEYS = new Set([
-    "answer",
-    "answerkey",
-    "correctanswer",
-    "correctresponse",
-    "correctresponses",
-    "correct",
-    "correctvalue",
-    "correctvalues",
-    "iscorrect",
-    "responseprocessing",
-    "rule",
-    "rules",
-    "scoring",
-    "scoringrules",
-    "solution",
-    "expected",
-    "expectedanswer",
-    "expectedvalue",
-    "expectedvalues"
-  ]);
-  trimmedNonEmptyString = exports_external.string().min(1).refine((value) => value === value.trim());
-  finiteNumber2 = exports_external.number().finite();
+  trimmedNonEmptyString3 = exports_external.string().min(1).refine((value) => value === value.trim());
+  finiteNumber3 = exports_external.number().finite();
+  positiveFiniteNumber3 = finiteNumber3.positive();
   nonnegativeInteger = exports_external.number().int().nonnegative();
   playableContentNodesSchema = exports_external.array(exports_external.unknown());
   playableChoiceSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     content: exports_external.string(),
     contentNodes: playableContentNodesSchema.optional()
   }).strict();
   playableMatchChoiceSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     content: exports_external.string(),
     contentNodes: playableContentNodesSchema.optional(),
     matchMax: nonnegativeInteger
   }).strict();
   playableGraphicSchema = exports_external.object({
-    src: trimmedNonEmptyString,
-    width: finiteNumber2.optional(),
-    height: finiteNumber2.optional(),
+    src: trimmedNonEmptyString3,
+    width: finiteNumber3.optional(),
+    height: finiteNumber3.optional(),
     description: exports_external.string().optional()
   }).strict();
   playableHotspotSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     shape: exports_external.enum(["circle", "ellipse", "rect", "poly", "default"]),
-    coords: exports_external.array(finiteNumber2),
+    coords: exports_external.array(finiteNumber3),
     matchMax: nonnegativeInteger.optional(),
     description: exports_external.string().optional()
   }).strict();
   playableGapTextSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     content: exports_external.string(),
     matchMax: nonnegativeInteger
   }).strict();
   playableGapImageSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     image: playableGraphicSchema.optional(),
     matchMax: nonnegativeInteger,
     description: exports_external.string().optional()
   }).strict();
   playableInteractionBase = {
-    responseIdentifier: trimmedNonEmptyString,
+    responseIdentifier: trimmedNonEmptyString3,
     prompt: exports_external.string().optional()
   };
   playableInteractionSchema = exports_external.discriminatedUnion("type", [
@@ -125187,7 +125869,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
       ...playableInteractionBase,
       type: exports_external.literal("hottext"),
       segments: exports_external.array(exports_external.object({
-        identifier: trimmedNonEmptyString.optional(),
+        identifier: trimmedNonEmptyString3.optional(),
         content: exports_external.string(),
         selectable: exports_external.boolean()
       }).strict()),
@@ -125207,7 +125889,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
       content: exports_external.string(),
       contentNodes: playableContentNodesSchema,
       gapTexts: exports_external.array(playableGapTextSchema),
-      gaps: exports_external.array(trimmedNonEmptyString),
+      gaps: exports_external.array(trimmedNonEmptyString3),
       maxAssociations: nonnegativeInteger
     }).strict(),
     exports_external.object({
@@ -125241,59 +125923,17 @@ var init_assessment_artifact_runtime_util = __esm(() => {
     }).strict()
   ]);
   playableItemSchema = exports_external.object({
-    identifier: trimmedNonEmptyString,
+    identifier: trimmedNonEmptyString3,
     title: exports_external.string(),
     prompt: exports_external.string(),
     promptContent: playableContentNodesSchema.optional(),
-    maxScore: finiteNumber2,
+    maxScore: positiveFiniteNumber3,
     interactions: exports_external.array(playableInteractionSchema)
   }).strict();
-  scoringRuleSchema = exports_external.object({
-    responseIdentifier: trimmedNonEmptyString,
-    cardinality: exports_external.enum(["single", "multiple", "ordered"]),
-    baseType: exports_external.enum(["string", "identifier", "integer", "float", "directedPair"]),
-    points: finiteNumber2,
-    comparison: exports_external.discriminatedUnion("kind", [
-      exports_external.object({ kind: exports_external.literal("match"), correctValues: exports_external.array(exports_external.string()) }),
-      exports_external.object({ kind: exports_external.literal("numeric-equal"), correctValue: finiteNumber2 }),
-      exports_external.object({
-        kind: exports_external.literal("numeric-equal-rounded"),
-        correctValue: finiteNumber2,
-        roundingMode: exports_external.enum(["decimalPlaces", "significantFigures"]),
-        figures: exports_external.number().int().nonnegative()
-      })
-    ])
-  });
-  scoringItemSchema = exports_external.discriminatedUnion("strategy", [
-    exports_external.object({
-      strategy: exports_external.literal("qti"),
-      itemIdentifier: trimmedNonEmptyString,
-      maxScore: finiteNumber2,
-      reason: exports_external.enum([
-        "response-mapping",
-        "area-mapping",
-        "unsupported-base-type",
-        "unsupported-cardinality",
-        "invalid-correct-response",
-        "no-scorable-response",
-        "unsupported-processing-template",
-        "unsupported-response-processing",
-        "cross-response-processing",
-        "inconsistent-max-score"
-      ])
-    }),
-    exports_external.object({
-      strategy: exports_external.literal("platform"),
-      itemIdentifier: trimmedNonEmptyString,
-      maxScore: finiteNumber2,
-      rules: exports_external.array(scoringRuleSchema)
-    })
-  ]);
-  uniqueScoringItemsSchema = exports_external.array(scoringItemSchema).refine((items) => new Set(items.map((item) => item.itemIdentifier)).size === items.length);
   diagnosticContextSchema = exports_external.object({
-    routingRevision: trimmedNonEmptyString,
+    routingRevision: trimmedNonEmptyString3,
     routingManifest: exports_external.record(exports_external.unknown())
-  });
+  }).strict();
 });
 
 class AssessmentArtifactRuntimeLoader {
@@ -126211,16 +126851,8 @@ function prepareDiagnosticAssessmentResponses(assessment, current, input) {
   const update2 = { [input.itemIdentifier]: input.responses };
   validateAssessmentResponseUpdate(assessment, update2);
   const responses = applyAssessmentResponseUpdate(current, update2);
-  const item = assessment.items.find((candidate) => candidate.identifier === input.itemIdentifier);
   const itemResponses = responses[input.itemIdentifier];
-  const missingResponse = item?.interactions.find((interaction) => itemResponses?.[interaction.responseIdentifier] === undefined);
-  if (!item || !itemResponses || missingResponse) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", `Diagnostic item ${input.itemIdentifier} requires a response for every interaction.`, {
-      itemIdentifier: input.itemIdentifier,
-      ...missingResponse ? { responseIdentifier: missingResponse.responseIdentifier } : {}
-    });
-  }
-  validateAssessmentResponses(assessment, { [input.itemIdentifier]: itemResponses });
+  validateAssessmentDraftResponses(assessment, itemResponses ? { [input.itemIdentifier]: itemResponses } : {});
   return responses;
 }
 function validateAssessmentResponseUpdate(assessment, update2) {
@@ -127684,6 +128316,162 @@ var init_timeback_assessment_artifacts_util = __esm(() => {
   init_timeback_assessment_runtime_util();
   init_timeback_review_mapping_util();
 });
+async function buildSubmissionChildResultCommand(input) {
+  const { submission, context: context2 } = input;
+  const { isCorrect } = submission;
+  const common2 = {
+    attempt: input.attempt,
+    administration: {
+      submissionId: submission.submissionId,
+      responseVersion: submission.responseVersion,
+      itemIdentifier: submission.itemIdentifier
+    },
+    responses: input.responses ?? {},
+    score: submission.score,
+    grading: input.grading
+  };
+  if (context2.kind === "review") {
+    return buildAssessmentChildResultCommand({
+      ...common2,
+      ...typeof isCorrect === "boolean" ? { isCorrect } : {},
+      context: context2
+    }, submission.submittedAt);
+  }
+  if (typeof isCorrect !== "boolean") {
+    throw new Error("Diagnostic child results require determinate correctness");
+  }
+  return buildAssessmentChildResultCommand({ ...common2, isCorrect, context: context2 }, submission.submittedAt);
+}
+function reviewDefinitionWithoutStandards(definition) {
+  return Object.fromEntries(Object.entries(definition).filter(([field]) => field !== "standards"));
+}
+function assessmentChildLineItemMetadataMatches(key, stored, expected) {
+  if (key !== "playcademyReviewQuestionDefinition" || typeof stored !== "object" || stored === null || typeof expected !== "object" || expected === null) {
+    return canonicalJson2(stored) === canonicalJson2(expected);
+  }
+  const storedDefinition = stored;
+  const expectedDefinition = expected;
+  const storedStandards = storedDefinition.standards;
+  const expectedStandards = expectedDefinition.standards;
+  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)));
+}
+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) {
+    return false;
+  }
+  return Object.entries(expected.metadata).every(([key, value]) => assessmentChildLineItemMetadataMatches(key, stored.metadata[key], value));
+}
+function buildAssessmentChildResultUpdate(command, childLineItemId) {
+  return {
+    status: "active",
+    assessmentLineItem: { sourcedId: childLineItemId },
+    student: { sourcedId: command.payload.attempt.studentId },
+    score: command.payload.score.earned,
+    scoreDate: command.recordedAt,
+    ...ASSESSMENT_ATTEMPT_COMPLETED,
+    metadata: {
+      [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: command
+    }
+  };
+}
+async function classifyAssessmentChildResult(input) {
+  const { result } = input;
+  if (typeof result.metadata !== "object" || result.metadata === null || !(PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY in result.metadata)) {
+    return { outcome: "conflict", reason: "malformed-command" };
+  }
+  const verification2 = await verifyAssessmentChildResultCommand(result.metadata);
+  if (!verification2.ok) {
+    return {
+      outcome: "conflict",
+      reason: verification2.reason === "payload_hash_mismatch" ? "payload-hash-mismatch" : "malformed-command"
+    };
+  }
+  if (verification2.command.payloadHash !== input.command.payloadHash) {
+    return { outcome: "conflict", reason: "payload-conflict" };
+  }
+  if (result.status === "tobedeleted") {
+    return { outcome: "conflict", reason: "tombstoned" };
+  }
+  const expected = buildAssessmentChildResultUpdate(verification2.command, input.childLineItemId);
+  const projectionChecks = [
+    ["status-mismatch", result.status, expected.status],
+    ["line-item-mismatch", result.assessmentLineItem?.sourcedId, input.childLineItemId],
+    ["student-mismatch", result.student?.sourcedId, expected.student.sourcedId],
+    ["score-mismatch", result.score, expected.score],
+    ["score-date-mismatch", result.scoreDate, expected.scoreDate],
+    ["score-status-mismatch", result.scoreStatus, expected.scoreStatus],
+    ["in-progress-mismatch", result.inProgress, expected.inProgress]
+  ];
+  const mismatch = projectionChecks.find(([, stored, wanted]) => stored !== wanted);
+  if (mismatch) {
+    return { outcome: "conflict", reason: mismatch[0] };
+  }
+  const auxiliaryFields = [
+    result.textScore,
+    result.scoreScale,
+    result.scorePercentile,
+    result.comment,
+    result.learningObjectiveSet,
+    result.incomplete,
+    result.late,
+    result.missing
+  ];
+  if (auxiliaryFields.some((value) => value !== undefined && value !== null)) {
+    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);
+  if (!verification2.ok) {
+    throw new Error(`Invalid assessment child result command: ${verification2.reason}`);
+  }
+  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),
+      command,
+      childLineItemId
+    });
+    return resolution.outcome === "replay" ? { outcome: "replay", resultId } : { outcome: "conflict", resultId, reason: resolution.reason };
+  }
+  try {
+    return await classifyOccupant();
+  } catch (error88) {
+    if (!hasApiStatus(error88, 404)) {
+      throw error88;
+    }
+  }
+  try {
+    await assessmentResults.create({
+      sourcedId: resultId,
+      ...buildAssessmentChildResultUpdate(command, childLineItemId)
+    });
+    return { outcome: "created", resultId };
+  } catch (error88) {
+    if (!hasApiStatus(error88, 409)) {
+      throw error88;
+    }
+  }
+  return classifyOccupant();
+}
+var init_timeback_assessment_child_result_util = __esm(async () => {
+  init_src();
+  init_assessment_runtime2();
+  await init_errors8();
+});
 
 class AssessmentPreparationFlights {
   limit;
@@ -127816,6 +128604,7 @@ function buildPreparedAssessmentMetadata(plan, timestamp6, testName) {
         testName,
         routingRevision: plan.diagnostic.routingRevision,
         ledger: [],
+        routingSnapshots: [],
         state: plan.diagnostic.initialState
       }
     };
@@ -127867,7 +128656,7 @@ function declarationNeutralQtiXml(source) {
 }
 function managedMetadataRecord(metadata2, key) {
   const managed = metadata2?.[key];
-  return isRecord5(managed) ? managed : null;
+  return isRecord4(managed) ? managed : null;
 }
 function sourceMetadata(metadata2) {
   return Object.fromEntries(Object.entries(metadata2 ?? {}).filter(([key]) => !GENERATED_METADATA_KEYS.has(key)));
@@ -128068,7 +128857,7 @@ function assertManagedAssessmentPublication(test, expected) {
 function managedAssessmentDiagnosticRoutingManifest(test, assessmentKey) {
   const managed = managedMetadataRecord(test.metadata, PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY);
   const manifest = managed?.diagnosticRoutingManifest;
-  return managed?.assessmentKey === assessmentKey && isRecord5(manifest) ? manifest : null;
+  return managed?.assessmentKey === assessmentKey && isRecord4(manifest) ? manifest : null;
 }
 async function assertManagedAssessmentItem(item, expected) {
   const managed = managedMetadataRecord(item.metadata, PLAYCADEMY_MANAGED_ITEM_METADATA_KEY);
@@ -128111,6 +128900,192 @@ 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";
+  }
+  if (!artifact.diagnostic) {
+    return "diagnostic-context-missing";
+  }
+  return artifact.diagnostic.routingRevision === routingRevision ? "routing-manifest-invalid" : "routing-revision-mismatch";
+}
+function assertDiagnosticItemsAvailable(definitionId, manifest, assessment) {
+  const itemIdentifiers = new Set(assessment.items.map((item) => item.identifier));
+  const unknownItem = manifest.nodes.find((node) => !itemIdentifiers.has(node.itemIdentifier));
+  if (unknownItem) {
+    throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `Diagnostic routing references unavailable item ${unknownItem.itemIdentifier}.`, {
+      definitionId,
+      nodeKey: unknownItem.key,
+      itemIdentifier: unknownItem.itemIdentifier
+    });
+  }
+}
+function replayAttemptDiagnosticRouting(metadata2, manifest) {
+  const replayed = replayDiagnosticRouting(manifest, metadata2.diagnostic.ledger);
+  if (!replayed.ok || canonicalJson2(replayed.state) !== canonicalJson2(metadata2.diagnostic.state)) {
+    throw AssessmentRuntimeError.from(assessmentFlowViolation("The persisted diagnostic routing state is corrupt.", {
+      definitionId: metadata2.diagnostic.definitionId,
+      ...replayed.ok ? {} : { failure: replayed.failure }
+    }));
+  }
+  return replayed.state;
+}
+async function resolveCompiledDiagnosticRouting(metadata2, assessment, artifact) {
+  const diagnostic = artifact?.diagnostic;
+  if (diagnostic?.routingRevision !== metadata2.diagnostic.routingRevision) {
+    return null;
+  }
+  const initialized = initializeDiagnosticRouting(diagnostic.routingManifest);
+  if (!initialized.ok) {
+    return null;
+  }
+  const routingRevision = await diagnosticRoutingRevision(initialized.manifest);
+  if (routingRevision !== metadata2.diagnostic.routingRevision) {
+    return null;
+  }
+  assertDiagnosticItemsAvailable(metadata2.diagnostic.definitionId, initialized.manifest, assessment);
+  return {
+    manifest: initialized.manifest,
+    routingRevision,
+    state: replayAttemptDiagnosticRouting(metadata2, initialized.manifest)
+  };
+}
+function summarizeDiagnosticSubmission(metadata2, manifest) {
+  const state = replayAttemptDiagnosticRouting(metadata2, manifest);
+  const tracks = diagnosticTrackResults(state);
+  if (!tracks) {
+    throw AssessmentRuntimeError.from(assessmentFlowViolation("Diagnostic routing must be ready to complete before final submit.", { routingStatus: state.status }));
+  }
+  if (metadata2.itemSubmissions.length === 0) {
+    throw AssessmentRuntimeError.from(assessmentFlowViolation("A diagnostic cannot be finalized without an administered item."));
+  }
+  const possible = metadata2.itemSubmissions.reduce((total, submission) => total + submission.score.possible, 0);
+  const score = aggregateAssessmentScore(metadata2.itemSubmissions.map((submission) => submission.score.earned), possible);
+  const correctQuestions = countCorrectQuestions(metadata2.itemSubmissions.map((submission) => submission.isCorrect));
+  return { tracks, score, correctQuestions };
+}
+var init_timeback_assessment_routing_util = __esm(() => {
+  init_assessment_runtime2();
+  init_errors2();
+  init_timeback_assessment_runtime_util();
+});
 function validateAssessmentStatusTransition(current, next) {
   if (current === next) {
     return;
@@ -128187,6 +129162,157 @@ 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 };
+      }
+    }
+    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}`
+  };
+});
 function qtiItemHref(client2, itemIdentifier) {
   return `${client2.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
 }
@@ -128262,6 +129388,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   init_spans();
   init_assessment_runtime2();
   init_constants3();
+  init_qti();
   init_types2();
   init_uuid();
   init_errors2();
@@ -128270,13 +129397,18 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   init_timeback_assessment_artifacts_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_qti_hydration_util();
   await __promiseAll([
     init_dist5(),
     init_errors8(),
-    init_assessment_artifact_loader_util()
+    init_assessment_artifact_loader_util(),
+    init_timeback_assessment_child_result_util()
   ]);
   AssessmentPreparationPrerequisiteError = class AssessmentPreparationPrerequisiteError2 extends Error {
     original;
@@ -128657,12 +129789,19 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         activityId: params.input.activityId,
         source
       }));
-      await this.provisionPreparationPrerequisites(() => runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService2.SCORING_CONCURRENCY, (item) => this.ensureReviewQuestionLineItem({
-        parentLineItemId,
-        integration: context2.integration,
-        bank: catalog.bank,
-        item
-      })));
+      await this.provisionPreparationPrerequisites(() => runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService2.SCORING_CONCURRENCY, (item) => {
+        const indexed = catalog.bank.items.find((candidate) => candidate.itemIdentifier === item.identifier);
+        if (!indexed) {
+          throw new Error(`Review-bank index is missing item ${item.identifier}`);
+        }
+        return this.ensureReviewQuestionLineItem({
+          parentLineItemId,
+          integration: context2.integration,
+          bankRevision: catalog.bank.bankRevision,
+          standards: [...indexed.standards],
+          item
+        });
+      }));
       const attempt = await this.provisionPreparationPrerequisites(() => this.claimAttemptId({
         gameId: params.gameId,
         studentId: params.studentId,
@@ -128851,6 +129990,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             testName: assessment.title,
             routingRevision: routing.routingRevision,
             ledger: [],
+            routingSnapshots: [],
             state: routing.state
           }
         };
@@ -129010,15 +130150,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.ensureReviewChildResults({
-          result,
-          metadata: metadata2,
-          integration: context2.integration,
-          source,
-          assessment,
-          existingChildResults: refreshedListing.reviewChildren,
-          lookupMissingResults: false
-        });
         await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
         this.recordReviewPreparationPhase("provisioning", provisioningStartedAt);
         this.recordReviewPreparationPhase("total", preparationStartedAt, {
@@ -129153,13 +130284,39 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       let preparationAttempts = 1;
       while (true) {
         const committed = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-          const attempt = await this.authorizeAttempt(params, {
+          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) {
@@ -129178,6 +130335,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             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: {
@@ -129188,10 +130350,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
                 itemSubmissions: attempt.metadata.itemSubmissions,
                 submission: transition.submission
               },
+              checkpoint: child2,
               projection: attempt.metadata.purpose === "review" ? {
                 result: attempt.result,
                 metadata: attempt.metadata,
-                itemIdentifier: input.itemIdentifier
+                itemIdentifier: input.itemIdentifier,
+                integration: attempt.integration
               } : null
             };
           }
@@ -129207,6 +130371,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             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",
@@ -129218,10 +130387,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               itemSubmissions: completed.itemSubmissions,
               submission: completed.submission
             },
+            checkpoint: child,
             projection: metadata2.purpose === "review" ? {
               result: attempt.result,
               metadata: metadata2,
-              itemIdentifier: input.itemIdentifier
+              itemIdentifier: input.itemIdentifier,
+              integration: attempt.integration
             } : null
           };
         });
@@ -129230,7 +130401,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           preview = await this.scoreItemSubmission(params, input);
         } else {
           if (committed.projection) {
-            await this.projectReviewItemResponse(params, committed.projection);
+            this.projectReviewItemResponse(params, committed.projection, committed.checkpoint);
           }
           return committed.response;
         }
@@ -129241,40 +130412,39 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       let preparationAttempts = 1;
       while (true) {
         const committed = await this.deps.assessmentRuntimeLock(this.deps.db, [assessmentRuntimeAttemptLockKey(params.attemptId)], async (db2) => {
-          const attempt = await this.authorizeAttempt(params, {
-            db: db2,
-            developerAccessValidated: true
-          });
+          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 priorIndex = metadata2.itemSubmissions.findIndex((submission2) => submission2.submissionId === input.submissionId);
-          if (priorIndex !== -1) {
-            const prior = metadata2.itemSubmissions[priorIndex];
-            const ledgerEntry = metadata2.diagnostic.ledger[priorIndex];
-            const sameRequest = prior !== undefined && ledgerEntry !== undefined && prior.itemIdentifier === input.itemIdentifier && ledgerEntry.routingNodeKey === input.routingNodeKey && itemResponseUpdateMatches(metadata2.responses[input.itemIdentifier], input.responses);
-            if (!sameRequest || !prior || !ledgerEntry) {
-              throw AssessmentRuntimeError.from(assessmentFlowViolation("This diagnostic submission ID was already used for a different request.", {
-                submissionId: input.submissionId,
-                routingNodeKey: input.routingNodeKey,
-                itemIdentifier: input.itemIdentifier
-              }));
-            }
-            const loaded2 = await this.loadAttemptDiagnosticManifest(metadata2, 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 }));
+          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: {
-                attemptId: attempt.result.sourcedId,
-                responseVersion: prior.responseVersion,
-                status: "in_progress",
-                routing: this.diagnosticRoutingSnapshot(metadata2, replayed.state),
-                submission: this.diagnosticReceipt(prior, ledgerEntry)
-              },
+              response: buildDiagnosticItemReplayResult(attempt.result.sourcedId, prior, ledgerEntry, routing),
+              checkpoint: child2,
               projection: {
                 result: attempt.result,
                 metadata: metadata2,
@@ -129283,6 +130453,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               }
             };
           }
+          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) {
@@ -129316,14 +130487,17 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           }
           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: true,
+            answered: Object.keys(responses[input.itemIdentifier] ?? {}).length > 0,
             score: scoring.score,
-            isCorrect: scoring.isCorrect
+            isCorrect: scoring.isCorrect,
+            grading: scoring.grading
           };
           const nextMetadata = {
             ...metadata2,
@@ -129334,9 +130508,16 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             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",
@@ -129344,9 +130525,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               attemptId: attempt.result.sourcedId,
               responseVersion,
               status: "in_progress",
-              routing: this.diagnosticRoutingSnapshot(nextMetadata, advanced.state),
-              submission: this.diagnosticReceipt(submission, advanced.ledgerEntry)
+              routing: routingSnapshot,
+              submission: diagnosticReceipt(submission, advanced.ledgerEntry)
             },
+            checkpoint: child,
             projection: {
               result: attempt.result,
               metadata: nextMetadata,
@@ -129359,21 +130541,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           preparationAttempts += 1;
           preview = await this.scoreDiagnosticItemSubmission(params, input);
         } else {
-          await this.projectDiagnosticItemResponse(committed.projection, preview?.assessment);
+          this.projectDiagnosticItemResponse(committed.projection, preview?.assessment, committed.checkpoint);
           return committed.response;
         }
       }
     }
-    diagnosticReceipt(submission, ledgerEntry) {
-      return {
-        submissionId: submission.submissionId,
-        routingNodeKey: ledgerEntry.routingNodeKey,
-        itemIdentifier: submission.itemIdentifier,
-        submittedAt: submission.submittedAt,
-        responseVersion: submission.responseVersion,
-        answered: submission.answered
-      };
-    }
     async prepareDiagnosticItemSubmission(params, input) {
       try {
         return await this.scoreDiagnosticItemSubmission(params, input);
@@ -129393,22 +130565,24 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       const prior = attempt.metadata.itemSubmissions.find((submission) => submission.submissionId === input.submissionId);
       if (prior || !this.isOpen(attempt.result)) {
-        return {
-          responseVersion: attempt.metadata.responseVersion,
-          submissionId: input.submissionId,
-          routingNodeKey: input.routingNodeKey,
-          itemIdentifier: input.itemIdentifier,
-          assessment: await this.loadAttemptAssessment(attempt.metadata),
-          scoring: null
-        };
+        return null;
       }
       const assessment = await this.loadAttemptAssessment(attempt.metadata);
-      const loaded = await this.loadAttemptDiagnosticRouting(attempt.metadata, assessment);
+      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(assessment, responses, input.itemIdentifier, assessmentArtifactIdentityFromAttempt(attempt.metadata));
+        scoring = await this.scoreItem({
+          assessment,
+          responses,
+          itemIdentifier: input.itemIdentifier,
+          artifactIdentity,
+          purpose: attempt.metadata.purpose,
+          preparedArtifact: scoringArtifact
+        });
       }
       return {
         responseVersion: attempt.metadata.responseVersion,
@@ -129419,39 +130593,27 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         scoring
       };
     }
-    async scoreItems(assessment, responses, artifactIdentity, itemIdentifiers) {
-      await this.artifactLoader.loadMatchedScoring(assessment, artifactIdentity);
-      const client2 = this.requireClient();
-      const scoringItems = assessmentScoringRequests(assessment, responses).filter((item) => !itemIdentifiers || itemIdentifiers.has(item.itemIdentifier));
-      const scoringTasks = scoringItems.flatMap((item, itemIndex) => item.requests.map((request) => ({
-        itemIndex,
-        itemIdentifier: item.itemIdentifier,
-        request
-      })));
-      const interactionResults = await runWithConcurrency(scoringTasks, TimebackAssessmentRuntimeService2.SCORING_CONCURRENCY, async ({ itemIdentifier, request }) => client2.qtiApi.assessmentItems.processResponse(itemIdentifier, request));
-      const scoresByItem = scoringItems.map(() => []);
-      const verdictsByItem = scoringItems.map(() => []);
-      scoringTasks.forEach((task, taskIndex) => {
-        const processed = interactionResults[taskIndex];
-        scoresByItem[task.itemIndex].push(Number.isFinite(processed.score) ? processed.score : 0);
-        verdictsByItem[task.itemIndex].push(processed.isCorrect);
-      });
-      return scoringItems.map((item, itemIndex) => {
-        const earned = assessmentItemEarnedScore(scoresByItem[itemIndex], item.maxScore);
-        const possible = item.maxScore;
-        return {
-          itemIdentifier: item.itemIdentifier,
-          score: {
-            earned,
-            possible,
-            normalized: possible === 0 ? 0 : earned / possible
-          },
-          isCorrect: assessmentItemCorrectness(verdictsByItem[itemIndex])
-        };
+    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(assessment, responses, itemIdentifier, artifactIdentity) {
-      const [scoring] = await this.scoreItems(assessment, responses, artifactIdentity, new Set([itemIdentifier]));
+    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) {
@@ -129468,7 +130630,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
     async scoreItemSubmission(params, input) {
       const attempt = await this.peekAttempt(params);
-      if (!this.isOpen(attempt.result)) {
+      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);
@@ -129479,7 +130642,13 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         itemSubmissions: attempt.metadata.itemSubmissions,
         assessment
       }, input);
-      const scoring = transition.action === "commit" ? await this.scoreItem(assessment, transition.responses, input.itemIdentifier, assessmentArtifactIdentityFromAttempt(attempt.metadata)) : null;
+      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,
@@ -129491,8 +130660,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     async scoreSubmission(attempt) {
       const assessment = await this.loadAttemptAssessment(attempt.metadata);
       validateAssessmentResponses(assessment, attempt.metadata.responses);
-      const administeredItems = attempt.metadata.purpose === "review" ? administeredItemIdentifiers(attempt.metadata.itemSubmissions) : undefined;
-      const itemResults = await this.scoreItems(assessment, attempt.metadata.responses, assessmentArtifactIdentityFromAttempt(attempt.metadata), administeredItems);
+      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,
@@ -129501,7 +130674,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         correctQuestions: countCorrectQuestions(itemResults.map((result) => result.isCorrect))
       };
     }
-    async peekAttempt({ studentId, attemptId }) {
+    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);
@@ -129546,21 +130722,19 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       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 = await this.authorizeAttempt(params, {
-          db: db2,
-          developerAccessValidated: true
-        });
+        const { attempt: identity, enrollment } = await this.resolveAttemptAuthorization(params, { db: db2, developerAccessValidated: true });
         const submissionDisposition = classifyAssessmentSubmission({
-          inProgress: attempt.result.inProgress ?? "",
-          scoreStatus: attempt.result.scoreStatus,
-          submissionId: attempt.metadata.submissionId
+          inProgress: identity.result.inProgress ?? "",
+          scoreStatus: identity.result.scoreStatus,
+          submissionId: identity.metadata.submissionId
         }, input.submissionId);
         if (submissionDisposition === "replay") {
           return {
-            response: this.submittedResult(attempt.result, attempt.metadata),
-            emission: this.replayCompletion(attempt, input.submissionId, params, game2)
+            response: this.submittedResult(identity.result, identity.metadata),
+            emission: this.replayCompletion(identity, input.submissionId, params, game2)
           };
         }
+        const attempt = this.requireActiveAttempt({ attempt: identity, enrollment }, params.attemptId);
         if (submissionDisposition === "reject") {
           throw AssessmentRuntimeError.from(assessmentAlreadySubmitted(attempt.result.sourcedId));
         }
@@ -129588,12 +130762,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         const { assessment, itemResults, score, correctQuestions } = scored;
         const client2 = this.requireClient();
         const timestamp6 = new Date().toISOString();
-        const reviewOutcomes = attempt.metadata.purpose === "review" ? await this.finalizeReviewChildResults({
-          result: attempt.result,
+        const reviewOutcomes = attempt.metadata.purpose === "review" ? this.reviewItemOutcomes({
           metadata: attempt.metadata,
-          itemResults,
-          submissionId: input.submissionId,
-          timestamp: timestamp6
+          itemResults
         }) : null;
         const finalization = buildAssessmentResultSubmission({
           result: attempt.result,
@@ -129656,9 +130827,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...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)] : []
+          ...diagnosticCompletion ? [this.restoreDiagnosticChildResults(diagnosticCompletion)] : [],
+          ...metadata2.purpose === "review" ? [this.restoreAllCompletedReviewChildResponses(result, metadata2)] : []
         ]);
       }
       return submission.response;
@@ -129808,17 +130981,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     async finalizeDiagnosticSubmission(input) {
       const { attempt } = input;
       const routing = await this.loadAttemptDiagnosticManifest(attempt.metadata, input.db);
-      const state = this.replayAttemptDiagnosticRouting(attempt.metadata, routing.manifest);
-      const tracks = diagnosticTrackResults(state);
-      if (!tracks) {
-        throw AssessmentRuntimeError.from(assessmentFlowViolation("Diagnostic routing must be ready to complete before final submit.", { routingStatus: state.status }));
-      }
-      if (attempt.metadata.itemSubmissions.length === 0) {
-        throw AssessmentRuntimeError.from(assessmentFlowViolation("A diagnostic cannot be finalized without an administered item."));
-      }
-      const possible = attempt.metadata.itemSubmissions.reduce((total, submission) => total + submission.score.possible, 0);
-      const score = aggregateAssessmentScore(attempt.metadata.itemSubmissions.map((submission) => submission.score.earned), possible);
-      const correctQuestions = countCorrectQuestions(attempt.metadata.itemSubmissions.map((submission) => submission.isCorrect));
+      const { tracks, score, correctQuestions } = summarizeDiagnosticSubmission(attempt.metadata, routing.manifest);
       const timestamp6 = new Date().toISOString();
       const finalization = buildAssessmentResultSubmission({
         result: attempt.result,
@@ -129906,10 +131069,13 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             }) : undefined;
             const diagnostic = definition?.diagnosticKey ? await this.initializeHostedDiagnostic(definition, loaded.assessment) : null;
             const reviewBank = purpose === "review" ? await buildReviewBankIndex(loaded.assessment, loaded.questions, { customOnly: true }) : null;
+            const scoring = compileQtiScoringArtifact(loaded.questions);
+            const fullyPlatformScored = scoring.items.every((item) => item.strategy === "platform");
             return {
               ...test,
               live: true,
               assessment: loaded.assessment,
+              ...fullyPlatformScored ? { scoring } : {},
               ...diagnostic ? {
                 diagnostic: {
                   diagnosticKey: diagnostic.definition.diagnosticKey,
@@ -130254,21 +131420,31 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       if (resumed.metadata.purpose !== "review") {
         throw new Error("A standards-review request selected a non-review attempt");
       }
-      if (this.isSettled(resumed.result)) {
-        return this.snapshotForResult(resumed.result, resumed.metadata, context2.integration);
-      }
-      const source = await this.loadPinnedReviewBankSource(resumed.metadata);
-      const assessment = projectReviewAssessment(source.assessment, source.bank, resumed.metadata.review.selections);
-      await this.ensureReviewChildResults({
-        result: resumed.result,
-        metadata: resumed.metadata,
-        integration: context2.integration,
-        source,
-        assessment,
-        existingChildResults,
-        lookupMissingResults: true
+      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 this.snapshot(resumed.result, resumed.metadata, assessment, context2.integration);
+      return assessmentChildProjectionIsTerminal(current.result) ? this.snapshotForResult(current.result, current.metadata, context2.integration) : this.snapshot(current.result, current.metadata, assessment, context2.integration);
     }
     recordReviewPreparationPhase(phase, startedAt, counts = {}) {
       addEvent("assessment.review_preparation_phase", {
@@ -130490,20 +131666,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
     async initializeHostedDiagnostic(definition, assessment) {
       const initialized = await this.initializeHostedDiagnosticManifest(definition);
-      this.assertDiagnosticItemsAvailable(definition, initialized.manifest, assessment);
+      assertDiagnosticItemsAvailable(definition.id, initialized.manifest, assessment);
       return initialized;
     }
-    assertDiagnosticItemsAvailable(definition, manifest, assessment) {
-      const itemIdentifiers = new Set(assessment.items.map((item) => item.identifier));
-      const unknownItem = manifest.nodes.find((node) => !itemIdentifiers.has(node.itemIdentifier));
-      if (unknownItem) {
-        throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `Diagnostic routing references unavailable item ${unknownItem.itemIdentifier}.`, {
-          definitionId: definition.id,
-          nodeKey: unknownItem.key,
-          itemIdentifier: unknownItem.itemIdentifier
-        });
-      }
-    }
     async initializeHostedDiagnosticManifest(definition) {
       const initialized = initializeDiagnosticRouting(definition.diagnosticRoutingManifest);
       if (!initialized.ok) {
@@ -130527,21 +131692,32 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return initialized;
     }
-    replayAttemptDiagnosticRouting(metadata2, manifest) {
-      const replayed = replayDiagnosticRouting(manifest, metadata2.diagnostic.ledger);
-      if (!replayed.ok || canonicalJson2(replayed.state) !== canonicalJson2(metadata2.diagnostic.state)) {
-        throw AssessmentRuntimeError.from(assessmentFlowViolation("The persisted diagnostic routing state is corrupt.", {
-          definitionId: metadata2.diagnostic.definitionId,
-          ...replayed.ok ? {} : { failure: replayed.failure }
-        }));
-      }
-      return replayed.state;
-    }
-    async loadAttemptDiagnosticRouting(metadata2, assessment, db2 = this.deps.db) {
+    async loadAttemptDiagnosticRouting(metadata2, assessment, db2 = this.deps.db, preparedArtifact) {
+      const startedAt = Date.now();
+      const artifactIdentity = assessmentArtifactIdentityFromAttempt(metadata2);
+      const artifact = preparedArtifact === undefined ? await this.artifactLoader.loadMatchedScoring(assessment, artifactIdentity) : preparedArtifact;
+      const compiled = await resolveCompiledDiagnosticRouting(metadata2, assessment, artifact);
+      if (compiled) {
+        addEvent("assessment.diagnostic_routing_load", {
+          "app.assessment.diagnostic_definition_id": metadata2.diagnostic.definitionId,
+          "app.assessment.routing_source": "platform-artifact",
+          "app.assessment.routing_duration_ms": Date.now() - startedAt
+        });
+        return compiled;
+      }
+      addEvent("assessment.diagnostic_routing_fallback", {
+        "app.assessment.diagnostic_definition_id": metadata2.diagnostic.definitionId,
+        "app.assessment.fallback_reason": diagnosticRoutingFallbackReason(artifact, metadata2.diagnostic.routingRevision),
+        "app.assessment.fallback_duration_ms": Date.now() - startedAt
+      });
       const pinned = await this.loadAttemptDiagnosticManifest(metadata2, db2);
-      this.assertDiagnosticItemsAvailable(pinned.definition, pinned.manifest, assessment);
-      const state = this.replayAttemptDiagnosticRouting(metadata2, pinned.manifest);
-      return { ...pinned, state };
+      assertDiagnosticItemsAvailable(pinned.definition.id, pinned.manifest, assessment);
+      const state = replayAttemptDiagnosticRouting(metadata2, pinned.manifest);
+      return {
+        manifest: pinned.manifest,
+        routingRevision: pinned.routingRevision,
+        state
+      };
     }
     async loadAssessmentSource(identifier, expectedRevision) {
       const client2 = this.requireClient();
@@ -130676,11 +131852,167 @@ 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;
+      }
+      return {
+        attemptId: attempt.result.sourcedId,
+        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
+      };
+    }
+    prepareReviewAssessmentChildResult(input) {
+      return this.prepareAssessmentChildResult({
+        attempt: input.attempt,
+        metadata: input.metadata,
+        submission: input.submission,
+        context: () => this.reviewChildResultContext(input.metadata, input.submission)
+      });
+    }
+    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 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;
+      }
+      addEvent("assessment.question_line_item_conflict", {
+        "app.assessment.line_item_id": lineItemId
+      });
+      throw AssessmentRuntimeError.from(assessmentFlowViolation("A deterministic assessment question line item is occupied by incompatible data.", { lineItemId }));
+    }
     async ensureDiagnosticQuestionLineItem(input) {
       const client2 = this.requireClient();
       const lineItemId = await diagnosticQuestionLineItemId(input.parentLineItemId, input.item.identifier);
+      const expected = {
+        status: ONEROSTER_STATUS2.active,
+        parentAssessmentLineItem: { sourcedId: input.parentLineItemId },
+        course: { sourcedId: input.integration.courseId },
+        resultValueMin: 0,
+        resultValueMax: input.item.maxScore,
+        metadata: {
+          playcademyDiagnosticQuestionDefinition: {
+            version: 1,
+            definitionId: input.metadata.diagnostic.definitionId,
+            diagnosticKey: input.metadata.diagnostic.diagnosticKey,
+            routingRevision: input.metadata.diagnostic.routingRevision,
+            contentRevision: input.metadata.selectedTest.contentRevision,
+            itemIdentifier: input.item.identifier
+          }
+        }
+      };
       try {
-        await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        this.assertAssessmentChildLineItem(lineItemId, stored, expected);
         return lineItemId;
       } catch (error88) {
         if (!isApiError(error88) || error88.statusCode !== 404) {
@@ -130690,35 +132022,23 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       try {
         await client2.api.oneroster.assessmentLineItems.create({
           sourcedId: lineItemId,
-          status: ONEROSTER_STATUS2.active,
           title: input.item.title,
           description: "adaptive diagnostic question",
-          parentAssessmentLineItem: { sourcedId: input.parentLineItemId },
-          course: { sourcedId: input.integration.courseId },
-          resultValueMin: 0,
-          resultValueMax: input.item.maxScore,
-          metadata: {
-            playcademyDiagnosticQuestionDefinition: {
-              version: 1,
-              definitionId: input.metadata.diagnostic.definitionId,
-              diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-              routingRevision: input.metadata.diagnostic.routingRevision,
-              contentRevision: input.metadata.selectedTest.contentRevision,
-              itemIdentifier: input.item.identifier
-            }
-          }
+          ...expected
         });
       } catch (error88) {
         if (!isApiError(error88) || error88.statusCode !== 409) {
           throw error88;
         }
+        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        this.assertAssessmentChildLineItem(lineItemId, stored, expected);
         addEvent("assessment.diagnostic_question_line_item_create_conflict", {
           "app.assessment.line_item_id": lineItemId
         });
       }
       return lineItemId;
     }
-    async projectDiagnosticItemResponse(projection, assessment) {
+    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);
@@ -130731,6 +132051,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           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,
@@ -130739,7 +132062,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           metadata: projection.metadata,
           ledgerEntry: projection.ledgerEntry
         });
-        await this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, finalized.resultUpdate);
+        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,
@@ -130800,41 +132126,43 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     async ensureReviewQuestionLineItem(input) {
       const client2 = this.requireClient();
       const lineItemId = await reviewQuestionLineItemId(input.parentLineItemId, input.item.identifier);
+      const expected = {
+        status: ONEROSTER_STATUS2.active,
+        parentAssessmentLineItem: { sourcedId: input.parentLineItemId },
+        course: { sourcedId: input.integration.courseId },
+        resultValueMin: 0,
+        resultValueMax: input.item.maxScore,
+        metadata: {
+          playcademyReviewQuestionDefinition: {
+            version: 1,
+            bankRevision: input.bankRevision,
+            itemIdentifier: input.item.identifier,
+            standards: input.standards
+          }
+        }
+      };
       try {
-        await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        this.assertAssessmentChildLineItem(lineItemId, stored, expected);
         return lineItemId;
       } catch (error88) {
         if (!isApiError(error88) || error88.statusCode !== 404) {
           throw error88;
         }
       }
-      const indexed = input.bank.items.find((candidate) => candidate.itemIdentifier === input.item.identifier);
-      if (!indexed) {
-        throw new Error(`Review-bank index is missing item ${input.item.identifier}`);
-      }
       try {
         await client2.api.oneroster.assessmentLineItems.create({
           sourcedId: lineItemId,
-          status: ONEROSTER_STATUS2.active,
           title: input.item.title,
           description: "standards review question",
-          parentAssessmentLineItem: { sourcedId: input.parentLineItemId },
-          course: { sourcedId: input.integration.courseId },
-          resultValueMin: 0,
-          resultValueMax: input.item.maxScore,
-          metadata: {
-            playcademyReviewQuestionDefinition: {
-              version: 1,
-              bankRevision: input.bank.bankRevision,
-              itemIdentifier: input.item.identifier,
-              standards: indexed.standards
-            }
-          }
+          ...expected
         });
       } catch (error88) {
         if (!isApiError(error88) || error88.statusCode !== 409) {
           throw error88;
         }
+        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        this.assertAssessmentChildLineItem(lineItemId, stored, expected);
         addEvent("assessment.review_question_line_item_create_conflict", {
           "app.assessment.line_item_id": lineItemId
         });
@@ -130855,6 +132183,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
     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");
@@ -130862,19 +132191,20 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const administeredItems = administeredItemIdentifiers(input.metadata.itemSubmissions);
       await runWithConcurrency(input.metadata.review.selections, TimebackAssessmentRuntimeService2.SCORING_CONCURRENCY, async (selection) => {
         const item = itemByIdentifier.get(selection.itemIdentifier);
-        if (!item) {
-          throw new Error(`Review assessment is missing selected item ${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)) {
-          await this.ensureReviewQuestionLineItem({
-            parentLineItemId: input.result.assessmentLineItem.sourcedId,
-            integration: input.integration,
-            bank: input.source.bank,
-            item
-          });
           return;
         }
-        const childLineItemId = await reviewQuestionLineItemId(input.result.assessmentLineItem.sourcedId, item.identifier);
         const childResultId = await reviewQuestionResultId(input.result.sourcedId, childLineItemId);
         const streamedChildResult = input.existingChildResults.get(childResultId);
         let childResult = streamedChildResult;
@@ -130897,12 +132227,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         if (resolution.action === "reuse") {
           return;
         }
-        await this.ensureReviewQuestionLineItem({
-          parentLineItemId: input.result.assessmentLineItem.sourcedId,
-          integration: input.integration,
-          bank: input.source.bank,
-          item
-        });
         if (resolution.action === "restore") {
           addEvent("assessment.review_child_result_restore", {
             "app.assessment.review_child_restore_reason": resolution.reason,
@@ -130920,24 +132244,43 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       });
     }
-    async putReviewChildResponse(result, metadata2, itemIdentifier) {
+    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 childLineItemId = await reviewQuestionLineItemId(result.assessmentLineItem.sourcedId, selection.itemIdentifier);
+        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 this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, buildOpenReviewChildResult({
-          childLineItemId,
-          student: result.student,
-          metadata: childMetadata
-        }));
+        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,
@@ -130947,14 +132290,26 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async projectReviewItemResponse(params, projection) {
-      await this.putReviewChildResponse(projection.result, projection.metadata, projection.itemIdentifier);
+    async projectReviewItemResponse(params, projection, checkpoint) {
+      const terminal = assessmentChildProjectionIsTerminal(projection.result);
       try {
-        await crossAssessmentAttemptLockBarrier(this.deps.assessmentRuntimeLock, this.deps.db, params.attemptId);
-        const latest = await this.peekAttempt(params);
-        if (this.isSettled(latest.result) && latest.metadata.purpose === "review") {
-          await this.restoreCompletedReviewChildResponses(latest.result, latest.metadata, new Set([projection.itemIdentifier]));
-        }
+        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,
@@ -130964,6 +132319,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
+    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;
@@ -131007,28 +132365,22 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         }
       });
     }
-    async finalizeReviewChildResults(input) {
+    reviewItemOutcomes(input) {
       const resultByItem = new Map(input.itemResults.map((itemResult) => [itemResult.itemIdentifier, itemResult]));
       const administeredItems = administeredItemIdentifiers(input.metadata.itemSubmissions);
-      return runWithConcurrency(input.metadata.review.selections.filter((selection) => administeredItems.has(selection.itemIdentifier)), TimebackAssessmentRuntimeService2.SCORING_CONCURRENCY, async (selection) => {
+      return input.metadata.review.selections.filter((selection) => administeredItems.has(selection.itemIdentifier)).map((selection) => {
         const itemResult = resultByItem.get(selection.itemIdentifier);
-        if (!itemResult) {
+        const submission = itemAdministration(input.metadata.itemSubmissions, selection.itemIdentifier);
+        if (!itemResult || !submission) {
           throw new Error(`Scoring omitted selected review item ${selection.itemIdentifier}`);
         }
-        const childLineItemId = await reviewQuestionLineItemId(input.result.assessmentLineItem.sourcedId, selection.itemIdentifier);
-        const childResultId = await reviewQuestionResultId(input.result.sourcedId, childLineItemId);
-        const finalized = buildFinalizedReviewChildResult({
-          childLineItemId,
-          student: input.result.student,
-          parentAttemptId: input.result.sourcedId,
-          metadata: input.metadata,
-          selection,
-          itemResult,
-          submissionId: input.submissionId,
-          timestamp: input.timestamp
-        });
-        await this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, finalized.resultUpdate);
-        return finalized.outcome;
+        return {
+          itemIdentifier: selection.itemIdentifier,
+          standard: selection.standard,
+          answered: submission.answered,
+          score: itemResult.score,
+          isCorrect: itemResult.isCorrect
+        };
       });
     }
     async resolveAttemptAuthorization({ gameId, studentId, attemptId, user }, options = {}) {
@@ -131060,11 +132412,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       return { attempt: { result, metadata: metadata2, integration }, enrollment };
     }
     async authorizeAttempt(params, options = {}) {
-      const { attempt, enrollment } = await this.resolveAttemptAuthorization(params, options);
-      if (!enrollment || attempt.integration.status === "deactivated") {
-        throw this.unauthorizedAttempt(params.attemptId);
-      }
-      return { ...attempt, enrollment };
+      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);
@@ -132933,7 +134286,7 @@ function getTotalXpFromTimebackConfig(config5) {
     return courseMetadata.metrics.totalXp;
   }
   const resourceMetadata = config5.resource.metadata;
-  if (isRecord5(resourceMetadata) && typeof resourceMetadata.xp === "number") {
+  if (isRecord4(resourceMetadata) && typeof resourceMetadata.xp === "number") {
     return resourceMetadata.xp;
   }
   return null;
@@ -133949,8 +135302,8 @@ var init_timeback_service = __esm(async () => {
       });
     }
     static patchCourseMetadata(metadata2, totalXp, options) {
-      const nextMetadata = isRecord5(metadata2) ? { ...metadata2 } : {};
-      const currentMetrics = isRecord5(nextMetadata.metrics) ? nextMetadata.metrics : {};
+      const nextMetadata = isRecord4(metadata2) ? { ...metadata2 } : {};
+      const currentMetrics = isRecord4(nextMetadata.metrics) ? nextMetadata.metrics : {};
       const metrics2 = { ...currentMetrics };
       if (totalXp === null) {
         delete metrics2.totalXp;
@@ -133975,7 +135328,7 @@ var init_timeback_service = __esm(async () => {
         if (goals === null) {
           delete nextMetadata.goals;
         } else {
-          const currentGoals = isRecord5(nextMetadata.goals) ? nextMetadata.goals : {};
+          const currentGoals = isRecord4(nextMetadata.goals) ? nextMetadata.goals : {};
           const nextGoals = { ...currentGoals };
           for (const [key, value] of Object.entries(goals)) {
             if (value === null) {
@@ -133994,7 +135347,7 @@ var init_timeback_service = __esm(async () => {
       if (options?.publishStatus !== undefined) {
         if (options.publishStatus === null) {
           delete nextMetadata.publishStatus;
-          const alphaLearn = isRecord5(nextMetadata.AlphaLearn) ? { ...nextMetadata.AlphaLearn } : {};
+          const alphaLearn = isRecord4(nextMetadata.AlphaLearn) ? { ...nextMetadata.AlphaLearn } : {};
           delete alphaLearn.publishStatus;
           if (Object.keys(alphaLearn).length > 0) {
             nextMetadata.AlphaLearn = alphaLearn;
@@ -134003,7 +135356,7 @@ var init_timeback_service = __esm(async () => {
           }
         } else {
           nextMetadata.publishStatus = options.publishStatus;
-          const alphaLearn = isRecord5(nextMetadata.AlphaLearn) ? { ...nextMetadata.AlphaLearn } : {};
+          const alphaLearn = isRecord4(nextMetadata.AlphaLearn) ? { ...nextMetadata.AlphaLearn } : {};
           alphaLearn.publishStatus = options.publishStatus === "published" ? "active" : options.publishStatus;
           nextMetadata.AlphaLearn = alphaLearn;
         }
@@ -134021,9 +135374,9 @@ var init_timeback_service = __esm(async () => {
       return Object.keys(nextMetadata).length > 0 ? nextMetadata : undefined;
     }
     static patchResourceMetadata(metadata2, options) {
-      const nextMetadata = isRecord5(metadata2) ? { ...metadata2 } : {};
-      const playcademyMetadata = isRecord5(nextMetadata.playcademy) ? { ...nextMetadata.playcademy } : {};
-      const masteryMetadata = isRecord5(playcademyMetadata.mastery) ? { ...playcademyMetadata.mastery } : {};
+      const nextMetadata = isRecord4(metadata2) ? { ...metadata2 } : {};
+      const playcademyMetadata = isRecord4(nextMetadata.playcademy) ? { ...nextMetadata.playcademy } : {};
+      const masteryMetadata = isRecord4(playcademyMetadata.mastery) ? { ...playcademyMetadata.mastery } : {};
       nextMetadata.subject = options.subject;
       nextMetadata.grades = [options.grade];
       if (options.totalXp === null) {