@playcademy/vite-plugin 1.2.1-beta.10 → 1.2.1-beta.12

package/dist/index.js

@@ -24315,7 +24315,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.2.1-beta.10",
+  version: "1.2.1-beta.12",
   type: "module",
   exports: {
     ".": {
@@ -25921,7 +25921,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.7.1-beta.10",
+    version: "0.7.1-beta.12",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -34346,6 +34346,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",
@@ -34387,139 +34394,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);
@@ -34531,18 +34407,22 @@ function isAssessmentResponseValue(value) {
   const entries = Array.isArray(value) ? value : [value];
   return entries.length > 0 && entries.every((entry2) => typeof entry2 === "string" && entry2.length > 0 && entry2.length <= TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH);
 }
+function applyAssessmentItemResponseUpdate(current, update) {
+  const next = { ...current };
+  for (const [responseId, value] of Object.entries(update)) {
+    if (value === null) {
+      delete next[responseId];
+    } else {
+      next[responseId] = value;
+    }
+  }
+  return Object.keys(next).length === 0 ? undefined : next;
+}
 function applyAssessmentResponseUpdate(current, update) {
   const next = structuredClone(current);
   for (const [questionId, questionUpdate] of Object.entries(update)) {
-    const questionResponses = { ...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;
@@ -34703,6 +34583,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;
@@ -35094,6 +35224,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);
 }
@@ -35108,7 +35241,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)) {
@@ -35125,6 +35258,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 = {
@@ -35206,9 +35342,11 @@ var LatestAssessmentFiltersSchema;
 var LatestRuntimeAssessmentQuerySchema;
 var StartAssessmentBodySchema;
 var SaveAssessmentBodySchema;
+var SubmitAssessmentItemBodySchema;
 var SubmitAssessmentBodySchema;
 var StartRuntimeAssessmentRequestSchema;
 var SaveRuntimeAssessmentRequestSchema;
+var SubmitAssessmentItemRuntimeRequestSchema;
 var SubmitRuntimeAssessmentRequestSchema;
 var init_assessment_runtime = __esm(() => {
   init_timeback3();
@@ -35397,7 +35535,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+)?$/;
@@ -35468,12 +35607,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()
@@ -117029,6 +117175,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({
@@ -117121,6 +117270,7 @@ class TimebackAssessmentRuntimeService {
         attemptNumber,
         responseVersion: 0,
         responses: {},
+        itemSubmissions: [],
         startedAt: timestamp6,
         updatedAt: timestamp6
       };
@@ -117246,6 +117396,7 @@ class TimebackAssessmentRuntimeService {
         attemptNumber,
         responseVersion: 0,
         responses: {},
+        itemSubmissions: [],
         startedAt: timestamp6,
         updatedAt: timestamp6,
         review: {
@@ -117370,6 +117521,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);
@@ -117391,11 +117546,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,
@@ -117409,7 +117658,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 {
@@ -117422,6 +117671,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": errorMessage2(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,
@@ -117491,6 +117786,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();
@@ -118133,18 +118435,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": errorMessage2(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": errorMessage2(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": errorMessage2(error88)
+        });
+      }
     });
   }
   async finalizeReviewChildResults(input) {
@@ -118225,8 +118614,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
     };
@@ -182545,6 +182936,7 @@ var startRuntimeAssessment;
 var getRuntimeAssessment;
 var getLatestRuntimeAssessment;
 var saveRuntimeAssessment;
+var submitRuntimeAssessmentItem;
 var submitRuntimeAssessment;
 var exportRuntimeAssessmentFixture;
 var getStudentXp;
@@ -182888,6 +183280,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);
@@ -183339,6 +183750,7 @@ var init_timeback_controller = __esm(() => {
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
     saveRuntimeAssessment,
+    submitRuntimeAssessmentItem,
     submitRuntimeAssessment,
     exportRuntimeAssessmentFixture,
     getStudentXp,
@@ -184288,6 +184700,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");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "1.2.1-beta.10",
+    "version": "1.2.1-beta.12",
     "type": "module",
     "exports": {
         ".": {
@@ -19,14 +19,14 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.28.1-beta.10"
+        "playcademy": "0.28.1-beta.12"
     },
     "devDependencies": {
         "@electric-sql/pglite": "^0.3.16",
         "@inquirer/prompts": "^7.8.6",
         "@playcademy/constants": "0.0.1",
-        "@playcademy/sandbox": "0.7.1-beta.10",
-        "@playcademy/sdk": "0.16.1-beta.10",
+        "@playcademy/sandbox": "0.7.1-beta.12",
+        "@playcademy/sdk": "0.16.1-beta.12",
         "@playcademy/types": "0.0.1",
         "@playcademy/utils": "0.0.1",
         "@types/archiver": "^6.0.3",