@playcademy/sandbox 0.8.1-beta.6 → 0.9.0

package/dist/cli.js

@@ -1128,7 +1128,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.8.1-beta.6",
+    version: "0.9.0",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -10748,12 +10748,10 @@ function selectAssessmentCourseCandidate(candidates, subjectSpecified) {
   if (candidates.length === 0) {
     return { outcome: "none" };
   }
-  const serviceable = candidates.filter((candidate) => candidate.hasLiveTests || candidate.hasOpenAttempt);
-  if (serviceable.length === 0) {
+  const eligible = candidates.filter((candidate) => candidate.hasLiveTests);
+  if (eligible.length === 0) {
     return { outcome: "no_eligible_tests" };
   }
-  const withOpenAttempt = serviceable.filter((candidate) => candidate.hasOpenAttempt);
-  const eligible = withOpenAttempt.length > 0 ? withOpenAttempt : serviceable;
   const subjects = new Set(eligible.map((candidate) => candidate.subject)).size;
   if (!subjectSpecified && subjects > 1) {
     return { outcome: "ambiguous", subjects };
@@ -10765,12 +10763,9 @@ function assessmentAttemptTimestamp(value) {
   const parsed = Date.parse(value);
   return Number.isNaN(parsed) ? 0 : parsed;
 }
-function newestAttempt(left, right, field) {
-  const dateDifference = assessmentAttemptTimestamp(right[field]) - assessmentAttemptTimestamp(left[field]);
-  return dateDifference || left.attemptId.localeCompare(right.attemptId);
-}
 function compareNewestCompletedAssessmentAttempt(left, right) {
-  return newestAttempt(left, right, "scoreDate");
+  const dateDifference = assessmentAttemptTimestamp(right.scoreDate) - assessmentAttemptTimestamp(left.scoreDate);
+  return dateDifference || left.attemptId.localeCompare(right.attemptId);
 }
 function compareAssessmentCatalogOrder(left, right) {
   if (left.assessmentKey !== null && right.assessmentKey !== null) {
@@ -10793,31 +10788,22 @@ function orderRuntimeAssessmentTests(tests) {
   return [...tests].toSorted(compareAssessmentCatalogOrder);
 }
 function selectRuntimeAssessment(liveTests, attempts) {
-  const resumable = attempts.filter((attempt) => attempt.resumable !== false && (isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt))).toSorted((left, right) => newestAttempt(left, right, "updatedAt"));
-  if (resumable.length > 0) {
-    return {
-      kind: "resume",
-      attempt: resumable[0],
-      additionalResumableAttemptIds: resumable.slice(1).map((candidate) => candidate.attemptId)
-    };
-  }
   const orderedTests = orderRuntimeAssessmentTests(liveTests);
   if (orderedTests.length === 0) {
     return null;
   }
-  const completed = attempts.filter(isAssessmentAttemptCompleted);
-  const exposedAssessmentKeys = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedAssessmentKey));
+  const history = attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptAwaitingAward(attempt) || isAssessmentAttemptCompleted(attempt) || isAssessmentAttemptSuperseded(attempt));
+  const exposedAssessmentKeys = new Set(history.map((attempt) => attempt.selectedAssessmentKey));
   const unattempted = orderedTests.find((test) => !exposedAssessmentKeys.has(test.assessmentKey));
   if (unattempted) {
-    return { kind: "start", test: unattempted, reason: "unattempted" };
+    return { test: unattempted, reason: "unattempted" };
   }
-  const latestCompleted = completed.toSorted(compareNewestCompletedAssessmentAttempt)[0];
-  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.assessmentKey === latestCompleted.selectedAssessmentKey) : -1;
+  const latest = history.toSorted(compareNewestCompletedAssessmentAttempt)[0];
+  const latestTestIndex = latest ? orderedTests.findIndex((test) => test.assessmentKey === latest.selectedAssessmentKey) : -1;
   if (latestTestIndex === -1) {
-    return { kind: "start", test: orderedTests[0], reason: "first_live" };
+    return { test: orderedTests[0], reason: "first_live" };
   }
   return {
-    kind: "start",
     test: orderedTests[(latestTestIndex + 1) % orderedTests.length],
     reason: "round_robin"
   };
@@ -100352,13 +100338,6 @@ function buildAssessmentAwardRecord(input, mastery) {
     ...mastery.warnings ? { warnings: mastery.warnings } : {}
   };
 }
-function stageAssessmentAttemptSupersession(attempt) {
-  Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
-  Object.assign(attempt.selection, ASSESSMENT_ATTEMPT_SUPERSEDED);
-}
-function shouldConfirmAssessmentVersionUnavailable(details) {
-  return typeof details === "object" && details !== null && "expectedRevision" in details && typeof details.expectedRevision === "string" && !("currentRevision" in details);
-}
 function buildAssessmentAttemptSupersessionUpdate(result) {
   if (result.status !== "active" || !isAssessmentAttemptOpen({
     inProgress: result.inProgress ?? "",
@@ -100376,17 +100355,6 @@ function buildAssessmentAttemptSupersessionUpdate(result) {
     metadata: result.metadata ?? {}
   };
 }
-async function resolveAvailableAssessmentAttempt(initialDecision, select3, resume) {
-  let decision = initialDecision;
-  while (decision?.kind === "resume") {
-    const snapshot = await resume(decision);
-    if (snapshot !== null) {
-      return { kind: "resumed", snapshot };
-    }
-    decision = select3();
-  }
-  return { kind: "continue", decision };
-}
 function diagnosticQuestionLineItemId(parentLineItemId, itemIdentifier) {
   return deterministicUUID(["playcademy:diagnostic-question-line-item:v1", parentLineItemId, itemIdentifier].join("\x00"));
 }
@@ -100461,6 +100429,20 @@ function assessmentAttemptId(input) {
     String(input.attemptNumber)
   ].join("\x00"));
 }
+function buildAssessmentAttemptResultWhere(scope) {
+  return {
+    "student.sourcedId": scope.studentId,
+    status: ONEROSTER_STATUS2.active,
+    [`metadata.${PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY}.activityId`]: scope.activityId
+  };
+}
+function buildAssessmentChildResultWhere(scope) {
+  return {
+    "student.sourcedId": scope.studentId,
+    status: ONEROSTER_STATUS2.active,
+    [`metadata.${PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY}.payload.attempt.activityId`]: scope.activityId
+  };
+}
 async function findLatestAssessmentResult(results, match) {
   let latest = null;
   let latestTimestamp = 0;
@@ -100900,6 +100882,7 @@ var PLAYABLE_SHAPE_SET;
 var init_timeback_assessment_runtime_util = __esm(() => {
   init_src();
   init_assessment_runtime2();
+  init_constants3();
   init_qti();
   init_types2();
   init_utils6();
@@ -102687,21 +102670,6 @@ function assessmentPreparationFlightKey(input) {
 async function assessmentPreparationReceiptMatches(plan, request) {
   return plan.gameId === request.gameId && plan.studentId === request.studentId && plan.activityId === request.input.activityId && plan.purpose === request.input.purpose && plan.requestHash === await assessmentPreparationRequestHash(request.input);
 }
-function resolveAssessmentPreparationSelection(decision, candidateCourseCount) {
-  if (decision?.kind === "resume") {
-    return {
-      status: "blocked",
-      result: { status: "canonical_required", reason: "resumable_attempt" }
-    };
-  }
-  if (candidateCourseCount !== 1) {
-    return {
-      status: "blocked",
-      result: { status: "unprepared", reason: "prerequisite_unavailable" }
-    };
-  }
-  return decision ? { status: "ready", decision } : { status: "unavailable" };
-}
 function preparedAssessmentIntegration(plan, candidates) {
   if (candidates.rows.length !== 1) {
     return null;
@@ -103447,15 +103415,16 @@ function assessmentReviewTranscriptExposures(input) {
   for (const { result, metadata: metadata2 } of input.attempts) {
     const state = { ...result, inProgress: result.inProgress ?? "" };
     const settled = isAssessmentAttemptAwaitingAward(state) || isAssessmentAttemptCompleted(state);
-    if (metadata2.purpose === "review" && (metadata2.transcript !== undefined || settled)) {
+    const useTranscript = !settled && metadata2.transcript !== undefined;
+    if (metadata2.purpose === "review" && (useTranscript || settled)) {
       authoritative.add(result.sourcedId);
       if (metadata2.review.bankRevision === input.bankRevision) {
-        const accepted = settled ? metadata2.itemSubmissions.map((submission) => ({
-          itemIdentifier: submission.itemIdentifier,
-          deliveredAt: submission.submittedAt
-        })) : metadata2.transcript.administrations.map((entry) => ({
+        const accepted = useTranscript ? metadata2.transcript.administrations.map((entry) => ({
           itemIdentifier: entry.itemIdentifier,
           deliveredAt: metadata2.updatedAt
+        })) : metadata2.itemSubmissions.map((submission) => ({
+          itemIdentifier: submission.itemIdentifier,
+          deliveredAt: submission.submittedAt
         }));
         exposures.push(...accepted);
       }
@@ -103589,7 +103558,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     static PREPARATION_IN_FLIGHT_LIMIT = 32;
     static ASSESSMENT_CACHE_TTL_MS = 60000;
     static EXPORT_CONCURRENCY = 4;
-    static ASSESSMENT_VERSION_CONFIRMATION_DELAY_MS = 25;
     static SCORING_CONCURRENCY = 4;
     static STALE_AWARD_AGE_MS = 15 * 60 * 1000;
     deps;
@@ -103679,8 +103647,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         return this.startReview({ gameId, studentId, input, user });
       }
       const masteryStandard = input.purpose === "mastery" ? normalizeMasteryStandard(input.standard) : undefined;
-      const requestFingerprint = this.startRequestFingerprint(input);
-      const pendingSupersessions = new Set;
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
         studentId,
@@ -103689,7 +103655,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -103702,39 +103668,28 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2, masteryStandard),
           this.listAttempts(attemptScope)
         ]);
-        const attempts = listing.attempts;
-        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeSnapshot(resumeDecision, attempts, context2.integration));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
-        }
-        let decision = this.requireDecision(initialResolution.decision, input.purpose);
-        let assessment = await this.loadAssessment(decision.test.qtiTestIdentifier);
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeSnapshot(resumeDecision, refreshed, context2.integration));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        decision = this.requireDecision(refreshedResolution.decision, input.purpose);
-        if (assessment.identifier !== decision.test.qtiTestIdentifier) {
-          assessment = await this.loadAssessment(decision.test.qtiTestIdentifier);
-        }
-        const classId = await this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId);
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
+        }
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
+        const [assessment, classId, { attemptNumber, attemptId }] = await Promise.all([
+          this.loadAssessment(decision.test.qtiTestIdentifier),
+          this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
         const lineItemId = await this.ensureLineItem({
           classId,
           integration: context2.integration,
           purpose: input.purpose,
           assessment
         });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
         const timestamp6 = new Date().toISOString();
         const metadataBase = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
@@ -103759,7 +103714,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...metadataBase,
           purpose: input.purpose,
           mastery: {
-            requestFingerprint,
+            requestFingerprint: masteryRequestFingerprint(input),
             standard: masteryStandard
           }
         } : { ...metadataBase, purpose: input.purpose };
@@ -103777,17 +103732,24 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-        return this.snapshot(result, metadata2, assessment, context2.integration);
+        const [snapshot] = await Promise.all([
+          this.snapshot(result, metadata2, assessment, context2.integration),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
+        return snapshot;
       });
     }
     async prepareNewAttempt(params, requestHash) {
       const startedAt = Date.now();
       const [candidates, results] = await Promise.all([
         this.candidateIntegrations(params.gameId, params.studentId, params.input),
-        this.studentAssessmentResults(params.studentId)
+        this.activityAssessmentResults({
+          studentId: params.studentId,
+          activityId: params.input.activityId,
+          purpose: params.input.purpose
+        })
       ]);
-      const context2 = await this.selectIntegration(candidates, params.studentId, params.input, results);
+      const context2 = await this.selectIntegration(candidates, params.input);
       const attemptScope = {
         studentId: params.studentId,
         activityId: params.input.activityId,
@@ -103798,40 +103760,30 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       };
       const tests = await this.liveTests(context2.integration.id, params.input.purpose, this.deps.db, params.input.purpose === "mastery" ? params.input.standard : undefined, params.input.purpose === "diagnostic" ? params.input.diagnosticKey : undefined);
       const listing = await this.attemptListing(results, attemptScope);
-      const decision = selectRuntimeAssessment(tests, [
-        ...this.attemptsMatchingRequest(listing.attempts, this.startRequestFingerprint(params.input)).values()
-      ].map((entry) => entry.selection));
-      const selection = resolveAssessmentPreparationSelection(decision, candidates.rows.length);
-      if (selection.status === "blocked") {
-        this.recordPreparation(selection.result.status, params.input.purpose, startedAt, {
-          reason: selection.result.status === "canonical_required" ? selection.result.reason : "multiple_candidate_courses"
+      if (this.pendingAwardAttempt(listing, context2.enrollment.id)) {
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason: "pending_award"
         });
-        return selection.result;
+        return { status: "unprepared", reason: "prerequisite_unavailable" };
       }
-      if (selection.status === "unavailable") {
-        throw AssessmentRuntimeError.from(assessmentNoEligibleTests(params.input.purpose));
+      if (candidates.rows.length !== 1) {
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason: "multiple_candidate_courses"
+        });
+        return { status: "unprepared", reason: "prerequisite_unavailable" };
       }
       const preparation = {
         context: context2,
         tests,
         listing,
-        decision: selection.decision
+        decision: this.selectFreshStart(tests, listing, params.input.purpose)
       };
       let prepared;
       try {
         prepared = await this.buildPreparationPlan(params, requestHash, preparation);
-        const assessment = await this.loadPreparedPlanAssessment(prepared.plan);
-        if (!assessment) {
+        if (!await this.loadPreparedPlanAssessment(prepared.plan)) {
           throw new Error("Prepared assessment artifact is unavailable");
         }
-        await this.provisionPreparationPrerequisites(() => this.ensureTranscriptLineItems({
-          version: 1,
-          gameId: prepared.plan.gameId,
-          studentId: prepared.plan.studentId,
-          attemptId: prepared.plan.attemptId,
-          parentLineItemId: prepared.plan.parentLineItemId,
-          metadata: buildPreparedAssessmentMetadata(prepared.plan, new Date().toISOString(), assessment.title)
-        }, assessment));
       } catch (error88) {
         if (error88 instanceof ValidationError || error88 instanceof AssessmentRuntimeError) {
           throw error88;
@@ -103920,6 +103872,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseName: context2.enrollment.course.title,
         ...attempt,
         parentLineItemId,
+        supersedes: [...this.replacedAttemptIds(listing.attempts, context2.enrollment.id)],
         selectedTest: {
           assessmentKey: decision.test.assessmentKey,
           identifier: assessment.identifier,
@@ -103971,26 +103924,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         throw AssessmentRuntimeError.from(assessmentReviewBankShortage(selected.fulfillment));
       }
       const artifact = await this.loadOrCompileReviewBankArtifact(catalog);
-      const assessment = projectReviewAssessment(artifact.assessment, catalog.bank, selected.selections);
       const source = { assessment: artifact.assessment, bank: catalog.bank };
       const parentLineItemId = await this.provisionPreparationPrerequisites(() => this.ensureReviewBankLineItem({
         integration: context2.integration,
         activityId: params.input.activityId,
         source
       }));
-      await this.provisionPreparationPrerequisites(() => runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, (item) => {
-        const indexed = catalog.bank.items.find((candidate) => candidate.itemIdentifier === item.identifier);
-        if (!indexed) {
-          throw new Error(`Review-bank index is missing item ${item.identifier}`);
-        }
-        return this.ensureReviewQuestionLineItem({
-          parentLineItemId,
-          integration: context2.integration,
-          bankRevision: catalog.bank.bankRevision,
-          standards: [...indexed.standards],
-          item
-        });
-      }));
       const attempt = await this.provisionPreparationPrerequisites(() => this.claimAttemptId({
         gameId: params.gameId,
         studentId: params.studentId,
@@ -104012,6 +103951,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseName: context2.enrollment.course.title,
         ...attempt,
         parentLineItemId,
+        supersedes: [...this.replacedAttemptIds(listing.attempts, context2.enrollment.id)],
         selectedTest: {
           assessmentKey: decision.test.assessmentKey,
           identifier: artifact.assessment.identifier,
@@ -104060,10 +104000,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           if (!integration || !await this.preparedPlanTestIsLive(verified, db2)) {
             return null;
           }
-          if (await this.attemptIdOccupied(verified.attemptId)) {
-            return null;
-          }
-          return this.createPreparedAttempt(verified, assessment, integration);
+          return this.claimPreparedAttempt(db2, verified, assessment, integration);
         });
         if (!outcome) {
           this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
@@ -104088,8 +104025,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       studentId,
       input
     }) {
-      const requestFingerprint = this.startRequestFingerprint(input);
-      const pendingSupersessions = new Set;
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
         studentId,
@@ -104098,7 +104033,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -104111,32 +104046,25 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2, undefined, input.diagnosticKey),
           this.listAttempts(attemptScope)
         ]);
-        const initialResolution = await this.resumeAvailableAttempt(tests, listing.attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeDiagnosticSnapshot(resumeDecision, listing.attempts, context2.integration, db2));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
         }
-        let decision = this.requireDecision(initialResolution.decision, input.purpose);
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
         let definition = await this.requireDiagnosticDefinition(decision.test.id, context2.integration.id, db2, true);
-        let assessment = await this.loadAssessment(definition.qtiTestIdentifier);
-        let routing = await this.initializeHostedDiagnostic(definition, assessment);
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeDiagnosticSnapshot(resumeDecision, refreshed, context2.integration, db2));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        decision = this.requireDecision(refreshedResolution.decision, input.purpose);
-        if (definition.id !== decision.test.id) {
-          definition = await this.requireDiagnosticDefinition(decision.test.id, context2.integration.id, db2, true);
-          assessment = await this.loadAssessment(definition.qtiTestIdentifier);
-          routing = await this.initializeHostedDiagnostic(definition, assessment);
-        } else {
-          definition = await this.requireDiagnosticDefinition(definition.id, context2.integration.id, db2, true);
-          routing = await this.initializeHostedDiagnostic(definition, assessment);
-        }
-        const classId = await this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId);
+        const [assessment, classId, { attemptNumber, attemptId }] = await Promise.all([
+          this.loadAssessment(definition.qtiTestIdentifier),
+          this.resolveClassId(context2.integration.courseId, context2.enrollment, studentId),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
+        definition = await this.requireDiagnosticDefinition(definition.id, context2.integration.id, db2, true);
+        const routing = await this.initializeHostedDiagnostic(definition, assessment);
         const lineItemId = await this.ensureLineItem({
           classId,
           integration: context2.integration,
@@ -104148,13 +104076,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             routingRevision: routing.routingRevision
           }
         });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
         const timestamp6 = new Date().toISOString();
         const metadata2 = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
@@ -104198,10 +104119,13 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-        return this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, {
-          state: routing.state
-        });
+        const [snapshot] = await Promise.all([
+          this.diagnosticSnapshot(result, metadata2, assessment, context2.integration, {
+            state: routing.state
+          }),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
+        return snapshot;
       });
     }
     async startReview({
@@ -104211,7 +104135,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }) {
       const preparationStartedAt = Date.now();
       const requestFingerprint = reviewRequestFingerprint(input, DEFAULT_REVIEW_SELECTION_POLICY);
-      const pendingSupersessions = new Set;
       const normalizedRequest = normalizeReviewRequest(input);
       const candidates = await this.candidateIntegrations(gameId, studentId, input);
       const lockKeys = candidates.rows.map((row) => assessmentRuntimeStartLockKey({
@@ -104221,7 +104144,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         courseId: row.courseId
       }));
       return this.deps.assessmentRuntimeLock(this.deps.db, lockKeys, async (db2) => {
-        const context2 = await this.selectIntegration(candidates, studentId, input);
+        const context2 = await this.selectIntegration(candidates, input);
         const attemptScope = {
           studentId,
           activityId: input.activityId,
@@ -104234,42 +104157,22 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           this.liveTests(context2.integration.id, input.purpose, db2),
           this.listAttempts(attemptScope)
         ]);
-        const attempts = listing.attempts;
-        const initialResolution = await this.resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, attempts, context2));
-        if (initialResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return initialResolution.snapshot;
-        }
-        let decision = initialResolution.decision;
-        if (tests.length === 0 || !decision) {
-          throw AssessmentRuntimeError.from(assessmentNoEligibleTests(input.purpose));
+        const pending = await this.pendingAwardSnapshot(listing, context2);
+        if (pending) {
+          return pending;
         }
+        const decision = this.selectFreshStart(tests, listing, input.purpose);
         if (tests.length > 1) {
           throw new ValidationError("Standards review requires exactly one live review-bank assessment.");
         }
         const manifestStartedAt = Date.now();
-        let catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
+        const catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
         this.recordReviewPreparationPhase("manifest_load", manifestStartedAt, {
           candidateCount: catalog.bank.items.length
         });
-        const refreshedListing = await this.listAttempts(attemptScope);
-        const refreshed = refreshedListing.attempts;
-        const refreshedResolution = await this.resumeAvailableAttempt(tests, refreshed, requestFingerprint, pendingSupersessions, (resumeDecision) => this.resumeReviewSnapshot(resumeDecision, refreshed, context2));
-        if (refreshedResolution.kind === "resumed") {
-          await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
-          return refreshedResolution.snapshot;
-        }
-        const refreshedDecision = refreshedResolution.decision;
-        if (!refreshedDecision || refreshedDecision.kind !== "start") {
-          throw AssessmentRuntimeError.from(assessmentNoEligibleTests(input.purpose));
-        }
-        decision = refreshedDecision;
-        if (catalog.test.identifier !== decision.test.qtiTestIdentifier) {
-          catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
-        }
         const exposures = assessmentReviewTranscriptExposures({
-          attempts: refreshedListing.attempts.values(),
-          children: refreshedListing.reviewChildren.values(),
+          attempts: listing.attempts.values(),
+          children: listing.reviewChildren.values(),
           bankRevision: catalog.bank.bankRevision
         });
         const selected = selectReviewItems({
@@ -104290,18 +104193,20 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
         const assessment = projectReviewAssessment(source.assessment, source.bank, selected.selections);
         const provisioningStartedAt = Date.now();
-        const parentLineItemId = await this.ensureReviewBankLineItem({
-          integration: context2.integration,
-          activityId: input.activityId,
-          source
-        });
-        const { attemptNumber, attemptId } = await this.claimAttemptId({
-          gameId,
-          studentId,
-          courseId: context2.integration.courseId,
-          activityId: input.activityId,
-          purpose: input.purpose
-        }, Math.max(0, ...[...refreshed.values()].map((entry) => entry.metadata.attemptNumber)) + 1);
+        const [parentLineItemId, { attemptNumber, attemptId }] = await Promise.all([
+          this.ensureReviewBankLineItem({
+            integration: context2.integration,
+            activityId: input.activityId,
+            source
+          }),
+          this.claimAttemptId({
+            gameId,
+            studentId,
+            courseId: context2.integration.courseId,
+            activityId: input.activityId,
+            purpose: input.purpose
+          }, nextAssessmentAttemptNumber(listing.attempts.values()))
+        ]);
         const timestamp6 = new Date().toISOString();
         const metadata2 = {
           version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
@@ -104345,13 +104250,16 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             grade: context2.integration.grade
           })
         });
-        await this.persistPendingSupersessionsBestEffort(db2, pendingSupersessions);
+        const [snapshot] = await Promise.all([
+          this.snapshot(result, metadata2, assessment, context2.integration),
+          this.supersedeReplacedAttempts(db2, listing.attempts, context2.enrollment.id)
+        ]);
         this.recordReviewPreparationPhase("provisioning", provisioningStartedAt);
         this.recordReviewPreparationPhase("total", preparationStartedAt, {
           candidateCount: catalog.bank.items.length,
           selectedCount: selected.selections.length
         });
-        return this.snapshot(result, metadata2, assessment, context2.integration);
+        return snapshot;
       });
     }
     async get(params) {
@@ -104869,28 +104777,11 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         liveTestIntegrationIds: integrationIdsWithLiveTests
       };
     }
-    async selectIntegration(candidates, studentId, input, results) {
-      const {
-        rows: candidateRows,
-        enrollmentByCourse,
-        liveTestIntegrationIds: integrationIdsWithLiveTests
-      } = candidates;
-      const needsOpenAnnotation = candidateRows.length > 1 || candidateRows.some((row) => !integrationIdsWithLiveTests.has(row.id));
-      const openAttemptScope = {
-        studentId,
-        activityId: input.activityId,
-        purpose: input.purpose,
-        enrollmentIdByCourse: new Map(candidateRows.map((row) => [row.courseId, enrollmentByCourse.get(row.courseId).id])),
-        requestFingerprint: this.startRequestFingerprint(input)
-      };
-      let openAttemptCourseIds = new Set;
-      if (needsOpenAnnotation) {
-        openAttemptCourseIds = results ? this.openAttemptCourseIdsFromResults(results, openAttemptScope) : await this.openAttemptCourseIds(openAttemptScope);
-      }
+    async selectIntegration(candidates, input) {
+      const { rows: candidateRows, enrollmentByCourse, liveTestIntegrationIds } = candidates;
       const annotated = candidateRows.map((row) => ({
         ...row,
-        hasLiveTests: integrationIdsWithLiveTests.has(row.id),
-        hasOpenAttempt: openAttemptCourseIds.has(row.courseId)
+        hasLiveTests: liveTestIntegrationIds.has(row.id)
       }));
       const selection = selectAssessmentCourseCandidate(annotated, Boolean(input.subject));
       if (selection.outcome === "none") {
@@ -104919,15 +104810,19 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         standard: assessmentStandardForRow(row)
       })).filter((test) => !matchesMasteryStandard || matchesMasteryStandard(test.standard));
     }
-    async openAttemptCourseIds(scope) {
-      return this.openAttemptCourseIdsFromResults(await this.studentAssessmentResults(scope.studentId), scope);
+    async activityAssessmentResults(scope) {
+      const [parents, children] = await Promise.all([
+        this.collectAssessmentResults(buildAssessmentAttemptResultWhere(scope)),
+        scope.purpose === "review" ? this.activityChildResults(scope) : []
+      ]);
+      return [...parents, ...children];
+    }
+    activityChildResults(scope) {
+      return this.collectAssessmentResults(buildAssessmentChildResultWhere(scope));
     }
-    async studentAssessmentResults(studentId) {
+    async collectAssessmentResults(where) {
       const stream = this.requireClient().api.oneroster.assessmentResults.stream({
-        where: {
-          "student.sourcedId": studentId,
-          status: ONEROSTER_STATUS2.active
-        }
+        where
       });
       const results = [];
       for await (const result of stream) {
@@ -104935,18 +104830,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return results;
     }
-    openAttemptCourseIdsFromResults(results, scope) {
-      const courseIds = new Set;
-      for (const result of results) {
-        const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
-        if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && this.attemptMatchesRequestFingerprint(metadata2, scope.requestFingerprint) && result.student.sourcedId === scope.studentId && metadata2.enrollmentId === scope.enrollmentIdByCourse.get(metadata2.courseId) && (this.isOpen(result) || this.isAwaitingAward(result))) {
-          courseIds.add(metadata2.courseId);
-        }
-      }
-      return courseIds;
-    }
     async listAttempts(scope) {
-      return this.attemptListing(await this.studentAssessmentResults(scope.studentId), scope);
+      return this.attemptListing(await this.activityAssessmentResults(scope), scope);
     }
     async attemptListing(results, scope) {
       const attempts = new Map;
@@ -104975,7 +104860,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
             }
           }
         }
-        if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && metadata2.courseId === scope.courseId && metadata2.integrationId === scope.integrationId && result.student.sourcedId === scope.studentId) {
+        if (metadata2 && this.attemptInScope(result, metadata2, scope)) {
           const selectedAssessmentKey = metadata2.selectedTest.assessmentKey ?? assessmentKeyFromManagedQtiIdentifier(metadata2.selectedTest.identifier);
           if (selectedAssessmentKey) {
             attempts.set(result.sourcedId, {
@@ -104984,12 +104869,9 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
               selection: {
                 attemptId: result.sourcedId,
                 selectedAssessmentKey,
-                selectedTestIdentifier: metadata2.selectedTest.identifier,
                 inProgress: result.inProgress ?? "",
                 scoreStatus: result.scoreStatus,
-                scoreDate: result.scoreDate,
-                updatedAt: result.dateLastModified ?? metadata2.updatedAt,
-                resumable: metadata2.enrollmentId === scope.enrollmentId
+                scoreDate: result.scoreDate
               }
             });
           }
@@ -104997,114 +104879,61 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return { attempts, reviewChildren };
     }
-    attemptsMatchingRequest(attempts, requestFingerprint) {
-      if (requestFingerprint === undefined) {
-        return attempts;
-      }
-      return new Map([...attempts].filter(([, attempt]) => this.attemptMatchesRequestFingerprint(attempt.metadata, requestFingerprint)));
-    }
-    startRequestFingerprint(input) {
-      if (input.purpose === "review") {
-        return reviewRequestFingerprint(input, DEFAULT_REVIEW_SELECTION_POLICY);
-      }
-      if (input.purpose === "mastery") {
-        return masteryRequestFingerprint(input);
-      }
-      return input.purpose === "diagnostic" ? input.diagnosticKey : undefined;
-    }
-    attemptMatchesRequestFingerprint(metadata2, requestFingerprint) {
-      if (metadata2.purpose === "review") {
-        return metadata2.review.requestFingerprint === requestFingerprint;
-      }
-      if (metadata2.purpose === "mastery") {
-        return metadata2.mastery.requestFingerprint === requestFingerprint;
-      }
-      if (metadata2.purpose === "diagnostic" && requestFingerprint !== undefined) {
-        return this.isPlatformRoutedDiagnosticMetadata(metadata2) && metadata2.diagnostic.diagnosticKey === requestFingerprint;
-      }
-      return true;
-    }
-    requireDecision(decision, purpose) {
+    selectFreshStart(tests, listing, purpose) {
+      const decision = selectRuntimeAssessment(tests, [...listing.attempts.values()].map((entry) => entry.selection));
       if (!decision) {
         throw AssessmentRuntimeError.from(assessmentNoEligibleTests(purpose));
       }
       return decision;
     }
-    resumeSnapshot(decision, attempts, integration) {
-      if (decision.additionalResumableAttemptIds.length > 0) {
-        addEvent("assessment.multiple_resumable_attempts", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.additional_attempt_ids": decision.additionalResumableAttemptIds.join(",")
-        });
-      }
-      const resumed = attempts.get(decision.attempt.attemptId);
-      return this.snapshotForResult(resumed.result, resumed.metadata, integration);
-    }
-    async resumeDiagnosticSnapshot(decision, attempts, integration, _db = this.deps.db) {
-      const resumed = attempts.get(decision.attempt.attemptId);
-      return this.snapshotForResult(resumed.result, resumed.metadata, integration);
+    pendingAwardAttempt(listing, enrollmentId) {
+      const pending = [...listing.attempts.values()].filter((attempt) => attempt.metadata.enrollmentId === enrollmentId && this.isAwaitingAward(attempt.result));
+      return pending.toSorted((left, right) => compareNewestCompletedAssessmentAttempt(left.selection, right.selection))[0] ?? null;
     }
-    async resumeAvailableAttempt(tests, attempts, requestFingerprint, pendingSupersessions, resume) {
-      const select3 = () => selectRuntimeAssessment(tests, [...this.attemptsMatchingRequest(attempts, requestFingerprint).values()].map((entry) => entry.selection));
-      return resolveAvailableAssessmentAttempt(select3(), select3, (decision) => this.resumeSnapshotOrStageSupersession(decision, attempts, pendingSupersessions, () => resume(decision)));
+    async pendingAwardSnapshot(listing, context2) {
+      const pending = this.pendingAwardAttempt(listing, context2.enrollment.id);
+      if (!pending) {
+        return null;
+      }
+      addEvent("assessment.pending_award_returned", {
+        "app.assessment.attempt_id": pending.result.sourcedId
+      });
+      return this.snapshotForResult(pending.result, pending.metadata, context2.integration);
     }
-    async resumeSnapshotOrStageSupersession(decision, attempts, pendingSupersessions, resume) {
-      try {
-        return await resume();
-      } catch (error88) {
-        if (!(error88 instanceof AssessmentRuntimeError) || error88.runtimeCode !== "SELECTED_TEST_VERSION_UNAVAILABLE") {
-          throw error88;
-        }
-        if (shouldConfirmAssessmentVersionUnavailable(error88.details)) {
-          await sleep(TimebackAssessmentRuntimeService.ASSESSMENT_VERSION_CONFIRMATION_DELAY_MS);
-          try {
-            return await resume();
-          } catch (confirmationError) {
-            if (!(confirmationError instanceof AssessmentRuntimeError) || confirmationError.runtimeCode !== "SELECTED_TEST_VERSION_UNAVAILABLE") {
-              throw confirmationError;
-            }
-          }
+    replacedAttemptIds(attempts, enrollmentId) {
+      const replaced = new Set;
+      for (const attempt of attempts.values()) {
+        if (attempt.metadata.enrollmentId === enrollmentId && this.isOpen(attempt.result)) {
+          replaced.add(attempt.result.sourcedId);
         }
-        const staged = attempts.get(decision.attempt.attemptId);
-        pendingSupersessions.add(staged.result.sourcedId);
-        stageAssessmentAttemptSupersession(staged);
-        addEvent("assessment.attempt_supersession_staged", {
-          "app.assessment.attempt_id": decision.attempt.attemptId,
-          "app.assessment.reason": "selected_test_version_unavailable"
-        });
-        return null;
       }
+      return replaced;
+    }
+    supersedeReplacedAttempts(db2, attempts, enrollmentId) {
+      return this.supersedeAttemptsBestEffort(db2, this.replacedAttemptIds(attempts, enrollmentId));
     }
-    async persistPendingSupersessions(db2, attemptIds) {
+    async supersedeAttempts(db2, attemptIds) {
       for (const attemptId of [...attemptIds].toSorted()) {
         await this.deps.assessmentRuntimeLock(db2, [assessmentRuntimeAttemptLockKey(attemptId)], async () => {
-          let result;
-          try {
-            result = await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
-          } catch (error88) {
-            if (isApiError(error88) && error88.statusCode === 404) {
-              return;
-            }
-            throw error88;
-          }
-          const update2 = buildAssessmentAttemptSupersessionUpdate(result);
+          const result = await this.findAttemptResult(attemptId);
+          const update2 = result && buildAssessmentAttemptSupersessionUpdate(result);
           if (!update2) {
             return;
           }
           await this.requireClient().api.oneroster.assessmentResults.upsert(attemptId, update2);
           addEvent("assessment.attempt_superseded", {
             "app.assessment.attempt_id": attemptId,
-            "app.assessment.reason": "selected_test_version_unavailable"
+            "app.assessment.reason": "replaced_by_fresh_start"
           });
         });
       }
     }
-    async persistPendingSupersessionsBestEffort(db2, attemptIds) {
+    async supersedeAttemptsBestEffort(db2, attemptIds) {
       if (attemptIds.size === 0) {
         return;
       }
       try {
-        await this.persistPendingSupersessions(db2, attemptIds);
+        await this.supersedeAttempts(db2, attemptIds);
       } catch (error88) {
         addEvent("assessment.attempt_supersession_persist_failed", {
           "app.assessment.attempt_ids": [...attemptIds].toSorted().join(","),
@@ -105113,10 +104942,6 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         });
       }
     }
-    async resumeReviewSnapshot(decision, attempts, context2) {
-      const resumed = attempts.get(decision.attempt.attemptId);
-      return this.snapshotForResult(resumed.result, resumed.metadata, context2.integration);
-    }
     recordReviewPreparationPhase(phase, startedAt, counts = {}) {
       addEvent("assessment.review_preparation_phase", {
         "app.assessment.review_phase": phase,
@@ -105467,12 +105292,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           }
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        addEvent("assessment.line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
+        await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
       }
       return lineItemId;
     }
@@ -105514,15 +105334,26 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           }
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        addEvent("assessment.review_bank_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
+        await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.review_bank_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
       }
       return lineItemId;
     }
+    async confirmLineItemAfterRefusedCreate(lineItemId, createError, event, read) {
+      let stored;
+      try {
+        stored = await read();
+      } catch (readError) {
+        if (isApiError(readError) && readError.statusCode === 404) {
+          throw createError;
+        }
+        throw readError;
+      }
+      addEvent(event, {
+        "app.assessment.line_item_id": lineItemId,
+        ...isApiError(createError) ? { "app.timeback.status": createError.statusCode } : {}
+      });
+      return stored;
+    }
     tokenContext(attempt) {
       return {
         version: 1,
@@ -105576,10 +105407,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           try {
             await store.create({ sourcedId: id, title: item.title, ...expected });
           } catch (error88) {
-            if (!isApiError(error88) || error88.statusCode !== 409) {
-              throw error88;
-            }
-            this.assertAssessmentChildLineItem(id, await store.get(id), expected);
+            this.assertAssessmentChildLineItem(id, await this.confirmLineItemAfterRefusedCreate(id, error88, "assessment.question_line_item_create_conflict", () => store.get(id)), expected);
           }
         }
         this.childLineItemCache.set(id, true);
@@ -105645,14 +105473,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...expected
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.diagnostic_question_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
         this.assertAssessmentChildLineItem(lineItemId, stored, expected);
-        addEvent("assessment.diagnostic_question_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
       }
       return lineItemId;
     }
@@ -105691,14 +105513,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           ...expected
         });
       } catch (error88) {
-        if (!isApiError(error88) || error88.statusCode !== 409) {
-          throw error88;
-        }
-        const stored = await client2.api.oneroster.assessmentLineItems.get(lineItemId);
+        const stored = await this.confirmLineItemAfterRefusedCreate(lineItemId, error88, "assessment.review_question_line_item_create_conflict", () => client2.api.oneroster.assessmentLineItems.get(lineItemId));
         this.assertAssessmentChildLineItem(lineItemId, stored, expected);
-        addEvent("assessment.review_question_line_item_create_conflict", {
-          "app.assessment.line_item_id": lineItemId
-        });
       }
       return lineItemId;
     }
@@ -105780,7 +105596,10 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const graded = await resumeAssessmentTranscript({
         suppliedTranscript,
         checkpointTranscript: metadata2.transcript,
-        recover: async () => recoverAssessmentTranscript(context2, await this.studentAssessmentResults(context2.studentId)),
+        recover: async () => recoverAssessmentTranscript(context2, await this.activityChildResults({
+          studentId: context2.studentId,
+          activityId: context2.metadata.activityId
+        })),
         grade: (transcript) => this.gradeTranscript(context2, transcript)
       });
       const session2 = await this.assessmentSession(context2, graded.transcript);
@@ -105939,7 +105758,22 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return projectReviewAssessment(playable, preparedReviewBankIndex(plan), plan.review.selections);
     }
-    async createPreparedAttempt(plan, assessment, integration) {
+    async claimPreparedAttempt(db2, plan, assessment, integration) {
+      const occupant = await this.findAttemptResult(plan.attemptId);
+      if (occupant) {
+        const metadata3 = playcademyAssessmentResultMetadata(occupant.metadata);
+        if (occupant.status !== ONEROSTER_STATUS2.active || !metadata3 || !this.attemptInScope(occupant, metadata3, plan) || metadata3.enrollmentId !== plan.enrollmentId || !this.isOpen(occupant) || !this.attemptMatchesPlan(metadata3, plan)) {
+          return null;
+        }
+        addEvent("assessment.prepared_attempt_recovered", {
+          "app.assessment.attempt_id": plan.attemptId
+        });
+        const [snapshot2] = await Promise.all([
+          this.snapshotForResult(occupant, metadata3, integration),
+          this.supersedeAttemptsBestEffort(db2, new Set(plan.supersedes))
+        ]);
+        return snapshot2;
+      }
       const timestamp6 = new Date().toISOString();
       const metadata2 = buildPreparedAssessmentMetadata(plan, timestamp6, assessment.title);
       const result = await this.requireClient().api.oneroster.assessmentResults.upsert(plan.attemptId, {
@@ -105956,9 +105790,42 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
           grade: integration.grade
         })
       });
-      return this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, {
-        state: metadata2.diagnostic.state
-      }) : this.snapshot(result, metadata2, assessment, integration);
+      const [snapshot] = await Promise.all([
+        this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, {
+          state: metadata2.diagnostic.state
+        }) : this.snapshot(result, metadata2, assessment, integration),
+        this.supersedeAttemptsBestEffort(db2, new Set(plan.supersedes))
+      ]);
+      return snapshot;
+    }
+    attemptMatchesPlan(metadata2, plan) {
+      const planned = buildPreparedAssessmentMetadata(plan, metadata2.startedAt, "");
+      if (metadata2.selectedTest.assessmentKey !== planned.selectedTest.assessmentKey || metadata2.selectedTest.identifier !== planned.selectedTest.identifier || metadata2.selectedTest.contentRevision !== planned.selectedTest.contentRevision) {
+        return false;
+      }
+      if (metadata2.purpose === "review" && planned.purpose === "review") {
+        return metadata2.review.requestFingerprint === planned.review.requestFingerprint && metadata2.review.bankRevision === planned.review.bankRevision && metadata2.review.selections.length === planned.review.selections.length && metadata2.review.selections.every((selection, index2) => selection.itemIdentifier === planned.review.selections[index2].itemIdentifier);
+      }
+      if (metadata2.purpose === "mastery" && planned.purpose === "mastery") {
+        return metadata2.mastery.requestFingerprint === planned.mastery.requestFingerprint;
+      }
+      if (metadata2.purpose === "diagnostic" && plan.purpose === "diagnostic") {
+        return this.isPlatformRoutedDiagnosticMetadata(metadata2) && metadata2.diagnostic.definitionId === plan.diagnostic.definitionId && metadata2.diagnostic.routingRevision === plan.diagnostic.routingRevision;
+      }
+      return metadata2.purpose === planned.purpose;
+    }
+    async findAttemptResult(attemptId) {
+      try {
+        return await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
+      } catch (error88) {
+        if (isApiError(error88) && error88.statusCode === 404) {
+          return null;
+        }
+        throw error88;
+      }
+    }
+    attemptInScope(result, metadata2, scope) {
+      return metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && metadata2.courseId === scope.courseId && metadata2.integrationId === scope.integrationId && result.student.sourcedId === scope.studentId;
     }
     async claimAttemptId(scope, from) {
       for (let attemptNumber = from;attemptNumber < from + 20; attemptNumber += 1) {
@@ -105974,15 +105841,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       throw new Error(`Assessment attempt numbers ${from} through ${from + 19} are all occupied by records this code cannot read; refusing to overwrite them.`);
     }
     async attemptIdOccupied(attemptId) {
-      try {
-        await this.requireClient().api.oneroster.assessmentResults.get(attemptId);
-      } catch (error88) {
-        if (isApiError(error88) && error88.statusCode === 404) {
-          return false;
-        }
-        throw error88;
-      }
-      return true;
+      return await this.findAttemptResult(attemptId) !== null;
     }
     replayCompletion(attempt, submissionId, params, game2) {
       const { score, completion } = attempt.metadata;