@playcademy/sandbox 0.7.1-beta.10 → 0.7.1-beta.11

package/dist/server.js

@@ -1122,7 +1122,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.7.1-beta.10",
+    version: "0.7.1-beta.11",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -9423,6 +9423,13 @@ function classifyAssessmentSubmission(attempt, submissionId) {
   }
   return isAssessmentAttemptOpen(attempt) ? "submit" : "reject";
 }
+function assessmentFlowViolation(message, details) {
+  return {
+    code: "ASSESSMENT_FLOW_VIOLATION",
+    message,
+    ...details ? { details } : {}
+  };
+}
 function assessmentAttemptUnauthorized(attemptId) {
   return {
     code: "UNAUTHORIZED_ATTEMPT",
@@ -9464,139 +9471,8 @@ function assessmentReviewBankShortage(fulfillment) {
     details: { fulfillment }
   };
 }
-function selectAssessmentCourseCandidate(candidates, subjectSpecified) {
-  if (candidates.length === 0) {
-    return { outcome: "none" };
-  }
-  const serviceable = candidates.filter((candidate) => candidate.hasLiveTests || candidate.hasOpenAttempt);
-  if (serviceable.length === 0) {
-    return { outcome: "no_eligible_tests" };
-  }
-  const withOpenAttempt = serviceable.filter((candidate) => candidate.hasOpenAttempt);
-  const eligible = withOpenAttempt.length > 0 ? withOpenAttempt : serviceable;
-  const subjects = new Set(eligible.map((candidate) => candidate.subject)).size;
-  if (!subjectSpecified && subjects > 1) {
-    return { outcome: "ambiguous", subjects };
-  }
-  const selected = [...eligible].toSorted((left, right) => left.grade - right.grade || left.id.localeCompare(right.id))[0];
-  return { outcome: "selected", selected };
-}
-function assessmentAttemptTimestamp(value) {
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? 0 : parsed;
-}
-function newestAttempt(left, right, field) {
-  const dateDifference = assessmentAttemptTimestamp(right[field]) - assessmentAttemptTimestamp(left[field]);
-  return dateDifference || left.attemptId.localeCompare(right.attemptId);
-}
-function compareNewestCompletedAssessmentAttempt(left, right) {
-  return newestAttempt(left, right, "scoreDate");
-}
-function compareAssessmentCatalogOrder(left, right) {
-  if (left.sortOrder !== null || right.sortOrder !== null) {
-    if (left.sortOrder === null) {
-      return 1;
-    }
-    if (right.sortOrder === null) {
-      return -1;
-    }
-    const orderDifference = left.sortOrder - right.sortOrder;
-    if (orderDifference) {
-      return orderDifference;
-    }
-  }
-  const leftUpdatedAt = Date.parse(left.updatedAt);
-  const rightUpdatedAt = Date.parse(right.updatedAt);
-  const leftHasValidDate = Number.isFinite(leftUpdatedAt);
-  const rightHasValidDate = Number.isFinite(rightUpdatedAt);
-  if (leftHasValidDate && rightHasValidDate) {
-    const updatedDifference = leftUpdatedAt - rightUpdatedAt;
-    if (updatedDifference) {
-      return updatedDifference;
-    }
-  } else if (leftHasValidDate !== rightHasValidDate) {
-    return leftHasValidDate ? -1 : 1;
-  }
-  return left.qtiTestIdentifier.localeCompare(right.qtiTestIdentifier);
-}
-function orderRuntimeAssessmentTests(tests) {
-  return [...tests].toSorted(compareAssessmentCatalogOrder);
-}
-function selectRuntimeAssessment(liveTests, attempts) {
-  const resumable = attempts.filter((attempt) => attempt.resumable !== false && isAssessmentAttemptOpen(attempt)).toSorted((left, right) => newestAttempt(left, right, "updatedAt"));
-  if (resumable.length > 0) {
-    return {
-      kind: "resume",
-      attempt: resumable[0],
-      additionalResumableAttemptIds: resumable.slice(1).map((candidate) => candidate.attemptId)
-    };
-  }
-  const orderedTests = orderRuntimeAssessmentTests(liveTests);
-  if (orderedTests.length === 0) {
-    return null;
-  }
-  const completed = attempts.filter(isAssessmentAttemptCompleted);
-  const exposedTestIds = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedTestIdentifier));
-  const unattempted = orderedTests.find((test) => !exposedTestIds.has(test.qtiTestIdentifier));
-  if (unattempted) {
-    return { kind: "start", test: unattempted, reason: "unattempted" };
-  }
-  const latestCompleted = completed.toSorted(compareNewestCompletedAssessmentAttempt)[0];
-  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.qtiTestIdentifier === latestCompleted.selectedTestIdentifier) : -1;
-  if (latestTestIndex === -1) {
-    return { kind: "start", test: orderedTests[0], reason: "first_live" };
-  }
-  return {
-    kind: "start",
-    test: orderedTests[(latestTestIndex + 1) % orderedTests.length],
-    reason: "round_robin"
-  };
-}
-function presentationHash(value) {
-  let hash = 2166136261;
-  for (let index = 0;index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function comparePresentationText(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
-}
-function presentationChoices(choices, attemptId, itemIdentifier, domain) {
-  const seed = `${attemptId}\x00${itemIdentifier}\x00${domain}\x00`;
-  return [...choices].toSorted((left, right) => {
-    const hashDifference = presentationHash(`${seed}${left.identifier}`) - presentationHash(`${seed}${right.identifier}`);
-    return hashDifference || comparePresentationText(left.identifier, right.identifier);
-  });
-}
-function assessmentPresentationForAttempt(assessment, attemptId) {
-  const items = assessment.items.map((item) => {
-    const interactions = item.interactions.map((interaction) => {
-      if (interaction.type === "order" && interaction.shuffle) {
-        return {
-          ...interaction,
-          choices: presentationChoices(interaction.choices, attemptId, item.identifier, `order\x00${interaction.responseIdentifier}`)
-        };
-      }
-      if (interaction.type === "match" && interaction.shuffle) {
-        return {
-          ...interaction,
-          sourceChoices: presentationChoices(interaction.sourceChoices, attemptId, item.identifier, `match-source\x00${interaction.responseIdentifier}`),
-          targetChoices: presentationChoices(interaction.targetChoices, attemptId, item.identifier, `match-target\x00${interaction.responseIdentifier}`)
-        };
-      }
-      return interaction;
-    });
-    return { ...item, interactions };
-  });
-  return { ...assessment, items };
+function assessmentFlowForPurpose(purpose) {
+  return purpose === "review" || purpose === "mastery" ? "item-submit" : "attempt-submit";
 }
 function isTimebackGrade(value) {
   return typeof value === "number" && Number.isInteger(value) && GRADE_VALUES.includes(value);
@@ -9608,18 +9484,22 @@ function isAssessmentResponseValue(value) {
   const entries = Array.isArray(value) ? value : [value];
   return entries.length > 0 && entries.every((entry) => typeof entry === "string" && entry.length > 0 && entry.length <= TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH);
 }
+function applyAssessmentItemResponseUpdate(current, update) {
+  const next = { ...current };
+  for (const [responseId, value] of Object.entries(update)) {
+    if (value === null) {
+      delete next[responseId];
+    } else {
+      next[responseId] = value;
+    }
+  }
+  return Object.keys(next).length === 0 ? undefined : next;
+}
 function applyAssessmentResponseUpdate(current, update) {
   const next = structuredClone(current);
   for (const [questionId, questionUpdate] of Object.entries(update)) {
-    const questionResponses = { ...next[questionId] };
-    for (const [responseId, value] of Object.entries(questionUpdate)) {
-      if (value === null) {
-        delete questionResponses[responseId];
-      } else {
-        questionResponses[responseId] = value;
-      }
-    }
-    if (Object.keys(questionResponses).length === 0) {
+    const questionResponses = applyAssessmentItemResponseUpdate(next[questionId], questionUpdate);
+    if (questionResponses === undefined) {
       delete next[questionId];
     } else {
       next[questionId] = questionResponses;
@@ -9780,6 +9660,256 @@ function interactionResponseValidationMessage(itemIdentifier, interaction, respo
   }
   return null;
 }
+function invalidResponse(message) {
+  return { code: "INVALID_RESPONSE", message };
+}
+function responseValuesEqual(left, right) {
+  if (left === undefined || right === undefined) {
+    return left === right;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => value === right[index]);
+  }
+  return left === right;
+}
+function itemResponsesEqual(left, right) {
+  const leftEntries = Object.entries(left ?? {});
+  const rightEntries = Object.entries(right ?? {});
+  return leftEntries.length === rightEntries.length && leftEntries.every(([identifier, value]) => responseValuesEqual(value, right?.[identifier]));
+}
+function prepareAssessmentItemSubmission(state, input) {
+  const flow = assessmentFlowForPurpose(state.purpose);
+  if (flow !== "item-submit") {
+    return {
+      action: "reject",
+      failure: assessmentFlowViolation("Items cannot be submitted individually in this flow.", { flow })
+    };
+  }
+  const priorSubmission = state.itemSubmissions.find((submission) => submission.submissionId === input.submissionId);
+  if (priorSubmission) {
+    const replayedItemResponses = applyAssessmentItemResponseUpdate(state.responses[input.itemIdentifier], input.responses);
+    const sameRequest = priorSubmission.itemIdentifier === input.itemIdentifier && itemResponsesEqual(state.responses[input.itemIdentifier], replayedItemResponses);
+    if (!sameRequest) {
+      return {
+        action: "reject",
+        failure: assessmentFlowViolation("This item submission ID was already used for a different request.", {
+          submissionId: input.submissionId,
+          itemIdentifier: input.itemIdentifier,
+          committedItemIdentifier: priorSubmission.itemIdentifier,
+          flow
+        })
+      };
+    }
+    return {
+      action: "replay",
+      responseVersion: state.responseVersion,
+      responses: state.responses,
+      submission: priorSubmission
+    };
+  }
+  if (state.responseVersion !== input.expectedResponseVersion) {
+    return {
+      action: "reject",
+      failure: assessmentResponseVersionConflict(input.expectedResponseVersion, state.responseVersion)
+    };
+  }
+  const committed = new Set(state.itemSubmissions.map((submission) => submission.itemIdentifier));
+  const itemIndex = state.assessment.items.findIndex((item) => !committed.has(item.identifier));
+  const nextItem = state.assessment.items[itemIndex];
+  if (nextItem?.identifier !== input.itemIdentifier) {
+    return {
+      action: "reject",
+      failure: assessmentFlowViolation("Items must be submitted once and in presentation order.", {
+        itemIdentifier: input.itemIdentifier,
+        expectedItemIdentifier: nextItem?.identifier ?? null,
+        flow
+      })
+    };
+  }
+  const update = { [input.itemIdentifier]: input.responses };
+  const updateMessage = assessmentResponseUpdateValidationMessage(state.assessment, update);
+  if (updateMessage) {
+    return { action: "reject", failure: invalidResponse(updateMessage) };
+  }
+  const responses = applyAssessmentResponseUpdate(state.responses, update);
+  const validationMessage = assessmentResponseValidationMessage(state.assessment, responses);
+  if (validationMessage) {
+    return { action: "reject", failure: invalidResponse(validationMessage) };
+  }
+  return {
+    action: "commit",
+    itemIndex,
+    responseVersion: state.responseVersion + 1,
+    responses,
+    answered: Object.keys(responses[input.itemIdentifier] ?? {}).length > 0
+  };
+}
+function completeAssessmentItemSubmission(state, input, prepared, scoring) {
+  const submission = {
+    submissionId: input.submissionId,
+    itemIdentifier: input.itemIdentifier,
+    responseVersion: prepared.responseVersion,
+    answered: prepared.answered,
+    score: scoring.score,
+    isCorrect: scoring.isCorrect
+  };
+  return {
+    responseVersion: prepared.responseVersion,
+    responses: prepared.responses,
+    itemSubmissions: [...state.itemSubmissions, submission],
+    submission
+  };
+}
+function assessmentResponseUpdateFlowFailure(purpose, itemSubmissions, update) {
+  const committed = new Set(itemSubmissions.map((submission) => submission.itemIdentifier));
+  const committedUpdate = Object.keys(update).find((identifier) => committed.has(identifier));
+  return committedUpdate ? assessmentFlowViolation("A submitted item response cannot be edited.", {
+    itemIdentifier: committedUpdate,
+    flow: assessmentFlowForPurpose(purpose)
+  }) : null;
+}
+function assessmentCompletionFlowFailure(purpose, itemSubmissions, itemCount) {
+  const flow = assessmentFlowForPurpose(purpose);
+  return flow === "item-submit" && itemSubmissions.length !== itemCount ? assessmentFlowViolation("Every item must be submitted before the attempt can be completed.", {
+    flow,
+    submittedItemCount: itemSubmissions.length,
+    itemCount
+  }) : null;
+}
+function selectAssessmentCourseCandidate(candidates, subjectSpecified) {
+  if (candidates.length === 0) {
+    return { outcome: "none" };
+  }
+  const serviceable = candidates.filter((candidate) => candidate.hasLiveTests || candidate.hasOpenAttempt);
+  if (serviceable.length === 0) {
+    return { outcome: "no_eligible_tests" };
+  }
+  const withOpenAttempt = serviceable.filter((candidate) => candidate.hasOpenAttempt);
+  const eligible = withOpenAttempt.length > 0 ? withOpenAttempt : serviceable;
+  const subjects = new Set(eligible.map((candidate) => candidate.subject)).size;
+  if (!subjectSpecified && subjects > 1) {
+    return { outcome: "ambiguous", subjects };
+  }
+  const selected = [...eligible].toSorted((left, right) => left.grade - right.grade || left.id.localeCompare(right.id))[0];
+  return { outcome: "selected", selected };
+}
+function assessmentAttemptTimestamp(value) {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function newestAttempt(left, right, field) {
+  const dateDifference = assessmentAttemptTimestamp(right[field]) - assessmentAttemptTimestamp(left[field]);
+  return dateDifference || left.attemptId.localeCompare(right.attemptId);
+}
+function compareNewestCompletedAssessmentAttempt(left, right) {
+  return newestAttempt(left, right, "scoreDate");
+}
+function compareAssessmentCatalogOrder(left, right) {
+  if (left.sortOrder !== null || right.sortOrder !== null) {
+    if (left.sortOrder === null) {
+      return 1;
+    }
+    if (right.sortOrder === null) {
+      return -1;
+    }
+    const orderDifference = left.sortOrder - right.sortOrder;
+    if (orderDifference) {
+      return orderDifference;
+    }
+  }
+  const leftUpdatedAt = Date.parse(left.updatedAt);
+  const rightUpdatedAt = Date.parse(right.updatedAt);
+  const leftHasValidDate = Number.isFinite(leftUpdatedAt);
+  const rightHasValidDate = Number.isFinite(rightUpdatedAt);
+  if (leftHasValidDate && rightHasValidDate) {
+    const updatedDifference = leftUpdatedAt - rightUpdatedAt;
+    if (updatedDifference) {
+      return updatedDifference;
+    }
+  } else if (leftHasValidDate !== rightHasValidDate) {
+    return leftHasValidDate ? -1 : 1;
+  }
+  return left.qtiTestIdentifier.localeCompare(right.qtiTestIdentifier);
+}
+function orderRuntimeAssessmentTests(tests) {
+  return [...tests].toSorted(compareAssessmentCatalogOrder);
+}
+function selectRuntimeAssessment(liveTests, attempts) {
+  const resumable = attempts.filter((attempt) => attempt.resumable !== false && isAssessmentAttemptOpen(attempt)).toSorted((left, right) => newestAttempt(left, right, "updatedAt"));
+  if (resumable.length > 0) {
+    return {
+      kind: "resume",
+      attempt: resumable[0],
+      additionalResumableAttemptIds: resumable.slice(1).map((candidate) => candidate.attemptId)
+    };
+  }
+  const orderedTests = orderRuntimeAssessmentTests(liveTests);
+  if (orderedTests.length === 0) {
+    return null;
+  }
+  const completed = attempts.filter(isAssessmentAttemptCompleted);
+  const exposedTestIds = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedTestIdentifier));
+  const unattempted = orderedTests.find((test) => !exposedTestIds.has(test.qtiTestIdentifier));
+  if (unattempted) {
+    return { kind: "start", test: unattempted, reason: "unattempted" };
+  }
+  const latestCompleted = completed.toSorted(compareNewestCompletedAssessmentAttempt)[0];
+  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.qtiTestIdentifier === latestCompleted.selectedTestIdentifier) : -1;
+  if (latestTestIndex === -1) {
+    return { kind: "start", test: orderedTests[0], reason: "first_live" };
+  }
+  return {
+    kind: "start",
+    test: orderedTests[(latestTestIndex + 1) % orderedTests.length],
+    reason: "round_robin"
+  };
+}
+function presentationHash(value) {
+  let hash = 2166136261;
+  for (let index = 0;index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function comparePresentationText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function presentationChoices(choices, attemptId, itemIdentifier, domain) {
+  const seed = `${attemptId}\x00${itemIdentifier}\x00${domain}\x00`;
+  return [...choices].toSorted((left, right) => {
+    const hashDifference = presentationHash(`${seed}${left.identifier}`) - presentationHash(`${seed}${right.identifier}`);
+    return hashDifference || comparePresentationText(left.identifier, right.identifier);
+  });
+}
+function assessmentPresentationForAttempt(assessment, attemptId) {
+  const items = assessment.items.map((item) => {
+    const interactions = item.interactions.map((interaction) => {
+      if (interaction.type === "order" && interaction.shuffle) {
+        return {
+          ...interaction,
+          choices: presentationChoices(interaction.choices, attemptId, item.identifier, `order\x00${interaction.responseIdentifier}`)
+        };
+      }
+      if (interaction.type === "match" && interaction.shuffle) {
+        return {
+          ...interaction,
+          sourceChoices: presentationChoices(interaction.sourceChoices, attemptId, item.identifier, `match-source\x00${interaction.responseIdentifier}`),
+          targetChoices: presentationChoices(interaction.targetChoices, attemptId, item.identifier, `match-target\x00${interaction.responseIdentifier}`)
+        };
+      }
+      return interaction;
+    });
+    return { ...item, interactions };
+  });
+  return { ...assessment, items };
+}
 function compareCodeUnits(left, right) {
   if (left < right) {
     return -1;
@@ -10171,6 +10301,9 @@ function isReviewFulfillment(value) {
 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 && Number.isInteger(value.responseVersion) && typeof value.answered === "boolean" && isAssessmentScore(value.score) && (value.isCorrect === null || typeof value.isCorrect === "boolean");
+}
 function isReviewAttemptMetadata(value) {
   return isRecord(value) && typeof value.requestFingerprint === "string" && typeof value.bankRevision === "string" && Array.isArray(value.standards) && value.standards.every(isAssessmentStandardRef) && Number.isInteger(value.itemsPerStandard) && Array.isArray(value.selections) && value.selections.every((selection) => isRecord(selection) && isAssessmentStandardRef(selection.standard) && typeof selection.itemIdentifier === "string") && isReviewFulfillment(value.fulfillment);
 }
@@ -10185,7 +10318,7 @@ function isPlaycademyAssessmentResultMetadataV1(value) {
   const selectedTest = metadata2.selectedTest;
   const mastery = metadata2.mastery;
   const review = metadata2.review;
-  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && (metadata2.completion === undefined || isRecord(metadata2.completion) && typeof metadata2.completion.testName === "string" && Number.isInteger(metadata2.completion.correctQuestions) && (metadata2.completion.totalQuestions === undefined || Number.isInteger(metadata2.completion.totalQuestions) && metadata2.completion.totalQuestions >= 0) && (metadata2.completion.itemOutcomes === undefined || metadata2.purpose === "review" && Array.isArray(metadata2.completion.itemOutcomes) && metadata2.completion.itemOutcomes.every(isReviewItemOutcome)));
+  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && Array.isArray(metadata2.itemSubmissions) && metadata2.itemSubmissions.every(isAssessmentItemSubmission) && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && (metadata2.completion === undefined || isRecord(metadata2.completion) && typeof metadata2.completion.testName === "string" && Number.isInteger(metadata2.completion.correctQuestions) && (metadata2.completion.totalQuestions === undefined || Number.isInteger(metadata2.completion.totalQuestions) && metadata2.completion.totalQuestions >= 0) && (metadata2.completion.itemOutcomes === undefined || metadata2.purpose === "review" && Array.isArray(metadata2.completion.itemOutcomes) && metadata2.completion.itemOutcomes.every(isReviewItemOutcome)));
 }
 function isPlaycademyAssessmentItemResultMetadataV1(value) {
   if (!isRecord(value) || !isRecord(value.responses)) {
@@ -10202,6 +10335,9 @@ function playcademyAssessmentResultMetadata(value) {
     return null;
   }
   let normalized = metadata2.responses === undefined ? { ...metadata2, responses: {} } : metadata2;
+  if (normalized.itemSubmissions === undefined) {
+    normalized = { ...normalized, itemSubmissions: [] };
+  }
   const review = normalized.review;
   if (isRecord(review) && isRecord(review.fulfillment) && review.fulfillment.status === "complete" && review.fulfillment.shortages === undefined) {
     normalized = {
@@ -10228,7 +10364,7 @@ function playcademyAssessmentItemResultMetadata(value) {
   const normalized = metadata2.responses === undefined ? { ...metadata2, responses: {} } : metadata2;
   return isPlaycademyAssessmentItemResultMetadataV1(normalized) ? normalized : null;
 }
-var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_RUNTIME_ERROR_STATUS, GRADE_VALUES, POINT_RESPONSE_PATTERN, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", DEFAULT_REVIEW_SELECTION_POLICY, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema, AssessmentRuntimeIdentitySchema, ResponseKeySchema, StartAssessmentBaseSchema, AssessmentStandardRefSchema, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, SaveAssessmentBodySchema, SubmitAssessmentBodySchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, SubmitRuntimeAssessmentRequestSchema;
+var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_RUNTIME_ERROR_STATUS, GRADE_VALUES, POINT_RESPONSE_PATTERN, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", DEFAULT_REVIEW_SELECTION_POLICY, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema, AssessmentRuntimeIdentitySchema, ResponseKeySchema, StartAssessmentBaseSchema, AssessmentStandardRefSchema, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, SaveAssessmentBodySchema, SubmitAssessmentItemBodySchema, SubmitAssessmentBodySchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, SubmitAssessmentItemRuntimeRequestSchema, SubmitRuntimeAssessmentRequestSchema;
 var init_assessment_runtime = __esm(() => {
   init_timeback3();
   init_timeback3();
@@ -10416,7 +10552,8 @@ var init_assessment_runtime = __esm(() => {
     RESPONSE_VERSION_CONFLICT: 409,
     INVALID_RESPONSE: 422,
     UNAUTHORIZED_ATTEMPT: 403,
-    ATTEMPT_ALREADY_SUBMITTED: 409
+    ATTEMPT_ALREADY_SUBMITTED: 409,
+    ASSESSMENT_FLOW_VIOLATION: 409
   };
   GRADE_VALUES = TIMEBACK_GRADES;
   POINT_RESPONSE_PATTERN = /^-?\d+(?:\.\d+)? -?\d+(?:\.\d+)?$/;
@@ -10487,12 +10624,19 @@ var init_assessment_runtime = __esm(() => {
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     responses: exports_external.record(ResponseKeySchema, exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema.nullable()))
   });
+  SubmitAssessmentItemBodySchema = exports_external.object({
+    expectedResponseVersion: exports_external.number().int().nonnegative(),
+    submissionId: exports_external.string().trim().min(1),
+    itemIdentifier: ResponseKeySchema,
+    responses: exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema.nullable())
+  });
   SubmitAssessmentBodySchema = exports_external.object({
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     submissionId: exports_external.string().trim().min(1)
   });
   StartRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentBodySchema);
   SaveRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SaveAssessmentBodySchema.shape);
+  SubmitAssessmentItemRuntimeRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentItemBodySchema.shape);
   SubmitRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentBodySchema.shape).extend({
     appName: exports_external.string().trim().min(1),
     sensorUrl: exports_external.string().url()
@@ -91167,6 +91311,9 @@ class TimebackAssessmentRuntimeService {
   static ASSESSMENT_CACHE_LIMIT = 32;
   static ASSESSMENT_CACHE_TTL_MS = 60000;
   static EXPORT_CONCURRENCY = 4;
+  static ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS = 3;
+  static PROJECTION_BARRIER_MAX_ATTEMPTS = 5;
+  static PROJECTION_BARRIER_RETRY_DELAY_MS = 25;
   static SCORING_CONCURRENCY = 4;
   deps;
   assessmentCache = new TimebackCache({
@@ -91259,6 +91406,7 @@ class TimebackAssessmentRuntimeService {
         attemptNumber,
         responseVersion: 0,
         responses: {},
+        itemSubmissions: [],
         startedAt: timestamp6,
         updatedAt: timestamp6
       };
@@ -91384,6 +91532,7 @@ class TimebackAssessmentRuntimeService {
         attemptNumber,
         responseVersion: 0,
         responses: {},
+        itemSubmissions: [],
         startedAt: timestamp6,
         updatedAt: timestamp6,
         review: {
@@ -91508,6 +91657,10 @@ class TimebackAssessmentRuntimeService {
       this.assertInProgress(attempt.result);
       this.assertResponseVersion(attempt.metadata, input.expectedResponseVersion);
       const assessment = await this.loadAttemptAssessment(attempt.metadata);
+      const flowFailure = assessmentResponseUpdateFlowFailure(attempt.metadata.purpose, attempt.metadata.itemSubmissions, input.responses);
+      if (flowFailure) {
+        throw AssessmentRuntimeError.from(flowFailure);
+      }
       validateAssessmentResponseUpdate(assessment, input.responses);
       const responses = applyAssessmentResponseUpdate(attempt.metadata.responses, input.responses);
       validateAssessmentResponses(assessment, responses);
@@ -91529,11 +91682,105 @@ class TimebackAssessmentRuntimeService {
       };
     });
   }
-  async scoreSubmission(attempt) {
+  async submitItem({
+    input,
+    ...params
+  }) {
+    await this.deps.validateDeveloperAccess(params.user, params.gameId);
+    let preview = await this.prepareItemSubmission(params, input);
+    let preparationAttempts = 1;
+    while (true) {
+      const committed = await this.deps.assessmentRuntimeLock(this.deps.db, assessmentRuntimeAttemptLockKey(params.attemptId), async (db2) => {
+        const attempt = await this.authorizeAttempt(params, {
+          db: db2,
+          developerAccessValidated: true
+        });
+        this.assertInProgress(attempt.result);
+        if (!preview || preview.responseVersion !== attempt.metadata.responseVersion || preview.submissionId !== input.submissionId || preview.itemIdentifier !== input.itemIdentifier) {
+          if (preparationAttempts >= TimebackAssessmentRuntimeService.ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS) {
+            if (input.expectedResponseVersion === attempt.metadata.responseVersion) {
+              throw new ServiceUnavailableError("The assessment response state changed repeatedly while this item was being prepared. Try again shortly.", {
+                retryable: true,
+                reason: "PREPARATION_CONTENTION",
+                expectedResponseVersion: input.expectedResponseVersion,
+                responseVersion: attempt.metadata.responseVersion
+              });
+            }
+            throw AssessmentRuntimeError.from(assessmentResponseVersionConflict(input.expectedResponseVersion, attempt.metadata.responseVersion));
+          }
+          return { action: "prepare" };
+        }
+        const transition = prepareAssessmentItemSubmission({
+          purpose: attempt.metadata.purpose,
+          responseVersion: attempt.metadata.responseVersion,
+          responses: attempt.metadata.responses,
+          itemSubmissions: attempt.metadata.itemSubmissions,
+          assessment: preview.assessment
+        }, input);
+        if (transition.action === "reject") {
+          throw AssessmentRuntimeError.from(transition.failure);
+        }
+        if (transition.action === "replay") {
+          return {
+            action: "complete",
+            response: {
+              attemptId: attempt.result.sourcedId,
+              responseVersion: transition.responseVersion,
+              status: "in_progress",
+              responses: transition.responses,
+              itemSubmissions: attempt.metadata.itemSubmissions,
+              submission: transition.submission
+            },
+            projection: attempt.metadata.purpose === "review" ? {
+              result: attempt.result,
+              metadata: attempt.metadata,
+              itemIdentifier: input.itemIdentifier
+            } : null
+          };
+        }
+        if (!preview.scoring) {
+          throw new Error("Prepared item submission is missing its score");
+        }
+        const completed = completeAssessmentItemSubmission(attempt.metadata, input, transition, preview.scoring);
+        const metadata2 = {
+          ...attempt.metadata,
+          responses: completed.responses,
+          responseVersion: completed.responseVersion,
+          itemSubmissions: completed.itemSubmissions,
+          updatedAt: new Date().toISOString()
+        };
+        await this.putResultMetadata(attempt.result, metadata2);
+        return {
+          action: "complete",
+          response: {
+            attemptId: attempt.result.sourcedId,
+            responseVersion: completed.responseVersion,
+            status: "in_progress",
+            responses: completed.responses,
+            itemSubmissions: completed.itemSubmissions,
+            submission: completed.submission
+          },
+          projection: metadata2.purpose === "review" ? {
+            result: attempt.result,
+            metadata: metadata2,
+            itemIdentifier: input.itemIdentifier
+          } : null
+        };
+      });
+      if (committed.action === "prepare") {
+        preparationAttempts += 1;
+        preview = await this.scoreItemSubmission(params, input);
+      } else {
+        if (committed.projection) {
+          await this.projectReviewItemResponse(params, committed.projection);
+        }
+        return committed.response;
+      }
+    }
+  }
+  async scoreItems(assessment, responses, itemIdentifiers) {
     const client2 = this.requireClient();
-    const assessment = await this.loadAttemptAssessment(attempt.metadata);
-    validateAssessmentResponses(assessment, attempt.metadata.responses);
-    const scoringItems = assessmentScoringRequests(assessment, attempt.metadata.responses);
+    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,
@@ -91547,7 +91794,7 @@ class TimebackAssessmentRuntimeService {
       scoresByItem[task.itemIndex].push(Number.isFinite(processed.score) ? processed.score : 0);
       verdictsByItem[task.itemIndex].push(processed.isCorrect);
     });
-    const itemResults = scoringItems.map((item, itemIndex) => {
+    return scoringItems.map((item, itemIndex) => {
       const earned = assessmentItemEarnedScore(scoresByItem[itemIndex], item.maxScore);
       const possible = item.maxScore;
       return {
@@ -91560,6 +91807,52 @@ class TimebackAssessmentRuntimeService {
         isCorrect: assessmentItemCorrectness(verdictsByItem[itemIndex])
       };
     });
+  }
+  async scoreItem(assessment, responses, itemIdentifier) {
+    const [scoring] = await this.scoreItems(assessment, responses, new Set([itemIdentifier]));
+    return scoring;
+  }
+  async prepareItemSubmission(params, input) {
+    try {
+      return await this.scoreItemSubmission(params, input);
+    } catch (error88) {
+      addEvent("assessment.item_submission_preview_failed", {
+        "app.assessment.attempt_id": params.attemptId,
+        "exception.type": errorType(error88),
+        "app.error.message": errorMessage(error88)
+      });
+      return null;
+    }
+  }
+  async scoreItemSubmission(params, input) {
+    const attempt = await this.peekAttempt(params);
+    if (!isAssessmentAttemptOpen({
+      inProgress: attempt.result.inProgress ?? "",
+      scoreStatus: attempt.result.scoreStatus
+    })) {
+      return null;
+    }
+    const assessment = await this.loadAttemptAssessment(attempt.metadata);
+    const transition = prepareAssessmentItemSubmission({
+      purpose: attempt.metadata.purpose,
+      responseVersion: attempt.metadata.responseVersion,
+      responses: attempt.metadata.responses,
+      itemSubmissions: attempt.metadata.itemSubmissions,
+      assessment
+    }, input);
+    const scoring = transition.action === "commit" ? await this.scoreItem(assessment, transition.responses, input.itemIdentifier) : null;
+    return {
+      responseVersion: attempt.metadata.responseVersion,
+      submissionId: input.submissionId,
+      itemIdentifier: input.itemIdentifier,
+      assessment,
+      scoring
+    };
+  }
+  async scoreSubmission(attempt) {
+    const assessment = await this.loadAttemptAssessment(attempt.metadata);
+    validateAssessmentResponses(assessment, attempt.metadata.responses);
+    const itemResults = await this.scoreItems(assessment, attempt.metadata.responses);
     return {
       responseVersion: attempt.metadata.responseVersion,
       assessment,
@@ -91629,6 +91922,13 @@ class TimebackAssessmentRuntimeService {
         throw AssessmentRuntimeError.from(assessmentAlreadySubmitted(attempt.result.sourcedId));
       }
       this.assertResponseVersion(attempt.metadata, input.expectedResponseVersion);
+      if (assessmentFlowForPurpose(attempt.metadata.purpose) === "item-submit") {
+        const assessment2 = await this.loadAttemptAssessment(attempt.metadata);
+        const flowFailure = assessmentCompletionFlowFailure(attempt.metadata.purpose, attempt.metadata.itemSubmissions, assessment2.items.length);
+        if (flowFailure) {
+          throw AssessmentRuntimeError.from(flowFailure);
+        }
+      }
       const scored = preview && preview.responseVersion === attempt.metadata.responseVersion ? preview : await this.scoreSubmission(attempt);
       const { assessment, itemResults, score, correctQuestions } = scored;
       const client2 = this.requireClient();
@@ -92271,18 +92571,105 @@ class TimebackAssessmentRuntimeService {
   }
   async putReviewChildResponses(result, metadata2, changedItemIdentifiers) {
     await runWithConcurrency(metadata2.review.selections.filter((selection) => changedItemIdentifiers.has(selection.itemIdentifier)), TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (selection) => {
-      const childLineItemId = await reviewQuestionLineItemId(result.assessmentLineItem.sourcedId, selection.itemIdentifier);
-      const childResultId = await reviewQuestionResultId(result.sourcedId, childLineItemId);
-      const childMetadata = buildReviewItemResultMetadata({
-        metadata: metadata2,
-        selection,
-        parentAttemptId: result.sourcedId
+      try {
+        const childLineItemId = await reviewQuestionLineItemId(result.assessmentLineItem.sourcedId, selection.itemIdentifier);
+        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
+        }));
+      } catch (error88) {
+        addEvent("assessment.review_child_response_projection_failed", {
+          "app.assessment.attempt_id": result.sourcedId,
+          "app.assessment.qti_item_identifier": selection.itemIdentifier,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage(error88)
+        });
+      }
+    });
+  }
+  async projectReviewItemResponse(params, projection) {
+    await this.putReviewChildResponses(projection.result, projection.metadata, new Set([projection.itemIdentifier]));
+    try {
+      await this.crossAttemptLockBarrier(params.attemptId);
+      const latest = await this.peekAttempt(params);
+      if (isAssessmentAttemptCompleted({
+        inProgress: latest.result.inProgress ?? "",
+        scoreStatus: latest.result.scoreStatus
+      }) && latest.metadata.purpose === "review") {
+        await this.restoreCompletedReviewChildResponses(latest.result, latest.metadata, new Set([projection.itemIdentifier]));
+      }
+    } catch (error88) {
+      addEvent("assessment.review_child_projection_barrier_failed", {
+        "app.assessment.attempt_id": params.attemptId,
+        "app.assessment.qti_item_identifier": projection.itemIdentifier,
+        "exception.type": errorType(error88),
+        "app.error.message": errorMessage(error88)
       });
-      await this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, buildOpenReviewChildResult({
-        childLineItemId,
-        student: result.student,
-        metadata: childMetadata
-      }));
+    }
+  }
+  async crossAttemptLockBarrier(attemptId) {
+    for (let attempt = 1;attempt <= TimebackAssessmentRuntimeService.PROJECTION_BARRIER_MAX_ATTEMPTS; attempt += 1) {
+      try {
+        await this.deps.assessmentRuntimeLock(this.deps.db, assessmentRuntimeAttemptLockKey(attemptId), async () => {
+          return;
+        });
+        return;
+      } catch (error88) {
+        if (!(error88 instanceof ServiceUnavailableError) || attempt === TimebackAssessmentRuntimeService.PROJECTION_BARRIER_MAX_ATTEMPTS) {
+          throw error88;
+        }
+        await sleep(TimebackAssessmentRuntimeService.PROJECTION_BARRIER_RETRY_DELAY_MS);
+      }
+    }
+  }
+  async restoreCompletedReviewChildResponses(result, metadata2, changedItemIdentifiers) {
+    const outcomes = metadata2.completion?.itemOutcomes;
+    const submissionId = metadata2.submissionId;
+    if (!submissionId || !outcomes) {
+      addEvent("assessment.review_child_terminal_restore_unavailable", {
+        "app.assessment.attempt_id": result.sourcedId
+      });
+      return;
+    }
+    const outcomeByItem = new Map(outcomes.map((outcome) => [outcome.itemIdentifier, outcome]));
+    await runWithConcurrency(metadata2.review.selections.filter((selection) => changedItemIdentifiers.has(selection.itemIdentifier)), TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, async (selection) => {
+      try {
+        const outcome = outcomeByItem.get(selection.itemIdentifier);
+        if (!outcome) {
+          throw new Error(`Completed review omitted item ${selection.itemIdentifier}`);
+        }
+        const childLineItemId = await reviewQuestionLineItemId(result.assessmentLineItem.sourcedId, selection.itemIdentifier);
+        const childResultId = await reviewQuestionResultId(result.sourcedId, childLineItemId);
+        const finalized = buildFinalizedReviewChildResult({
+          childLineItemId,
+          student: result.student,
+          parentAttemptId: result.sourcedId,
+          metadata: metadata2,
+          selection,
+          itemResult: {
+            itemIdentifier: outcome.itemIdentifier,
+            score: outcome.score,
+            isCorrect: outcome.isCorrect
+          },
+          submissionId,
+          timestamp: result.scoreDate
+        });
+        await this.requireClient().api.oneroster.assessmentResults.upsert(childResultId, finalized.resultUpdate);
+      } catch (error88) {
+        addEvent("assessment.review_child_terminal_restore_failed", {
+          "app.assessment.attempt_id": result.sourcedId,
+          "app.assessment.qti_item_identifier": selection.itemIdentifier,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage(error88)
+        });
+      }
     });
   }
   async finalizeReviewChildResults(input) {
@@ -92363,8 +92750,10 @@ class TimebackAssessmentRuntimeService {
       attemptId: result.sourcedId,
       responseVersion: metadata2.responseVersion,
       status: completed ? "completed" : "in_progress",
+      flow: assessmentFlowForPurpose(metadata2.purpose),
       assessment: assessmentPresentationForAttempt(assessment, result.sourcedId),
       responses: metadata2.responses,
+      itemSubmissions: metadata2.itemSubmissions,
       score: completed ? this.scoreFromResult(result, assessmentPossibleScore(assessment), metadata2) : null,
       selection
     };
@@ -154073,7 +154462,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, updateAssessment, reorderAssessments, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessmentItem, submitRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, updateAssessment, reorderAssessments, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -154381,6 +154770,25 @@ var init_timeback_controller = __esm(() => {
       user: ctx.user
     });
   });
+  submitRuntimeAssessmentItem = requireDeveloper(async (ctx) => {
+    const attemptId = ctx.params.attemptId;
+    const body2 = await parseRequestBody(ctx.request, SubmitAssessmentItemRuntimeRequestSchema);
+    if (!attemptId) {
+      throw ApiError.badRequest("Missing attemptId");
+    }
+    return ctx.services.timebackAssessmentRuntime.submitItem({
+      gameId: body2.gameId,
+      studentId: body2.studentId,
+      attemptId,
+      input: {
+        expectedResponseVersion: body2.expectedResponseVersion,
+        submissionId: body2.submissionId,
+        itemIdentifier: body2.itemIdentifier,
+        responses: body2.responses
+      },
+      user: ctx.user
+    });
+  });
   submitRuntimeAssessment = requireDeveloper(async (ctx) => {
     const attemptId = ctx.params.attemptId;
     const body2 = await parseRequestBody(ctx.request, SubmitRuntimeAssessmentRequestSchema);
@@ -154832,6 +155240,7 @@ var init_timeback_controller = __esm(() => {
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
     saveRuntimeAssessment,
+    submitRuntimeAssessmentItem,
     submitRuntimeAssessment,
     exportRuntimeAssessmentFixture,
     getStudentXp,
@@ -155820,6 +156229,7 @@ var init_timeback8 = __esm(async () => {
   timebackRouter.get("/assessments/latest", handle2(timeback2.getLatestRuntimeAssessment));
   timebackRouter.get("/assessments/:attemptId", handle2(timeback2.getRuntimeAssessment));
   timebackRouter.post("/assessments/:attemptId/save", handle2(timeback2.saveRuntimeAssessment));
+  timebackRouter.post("/assessments/:attemptId/submit-item", handle2(timeback2.submitRuntimeAssessmentItem));
   timebackRouter.post("/assessments/:attemptId/submit", handle2(timeback2.submitRuntimeAssessment));
   timebackRouter.get("/user", async (c2) => {
     const user = c2.get("user");