@playcademy/sandbox 0.10.1-beta.3 → 0.10.1-beta.5

package/dist/cli.js

@@ -285,7 +285,7 @@ var init_platform = __esm(() => {
 var PLATFORM_TIMEZONE = "America/New_York";
 
 // ../constants/src/timeback.ts
-var TIMEBACK_GRADES, TIMEBACK_SUBJECTS, ASSESSMENT_PURPOSES, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION = 1, PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION = 1, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY = "playcademyAssessment", PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY = "playcademyAssessmentItem", TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS, TIMEBACK_ORG_SOURCED_ID = "PLAYCADEMY", TIMEBACK_ORG_NAME = "Playcademy Studios", TIMEBACK_ORG_TYPE = "department", TIMEBACK_COURSE_DEFAULTS, TIMEBACK_RESOURCE_DEFAULTS, TIMEBACK_COMPONENT_DEFAULTS, TIMEBACK_COMPONENT_RESOURCE_DEFAULTS, TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH = 2048, TIMEBACK_GAME_METRIC_DECIMAL_PLACES, TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE;
+var TIMEBACK_GRADES, TIMEBACK_SUBJECTS, ASSESSMENT_PURPOSES, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION = 1, PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION = 2, PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY = "playcademyAssessment", PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY = "playcademyAssessmentItem", TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS, TIMEBACK_ORG_SOURCED_ID = "PLAYCADEMY", TIMEBACK_ORG_NAME = "Playcademy Studios", TIMEBACK_ORG_TYPE = "department", TIMEBACK_COURSE_DEFAULTS, TIMEBACK_RESOURCE_DEFAULTS, TIMEBACK_COMPONENT_DEFAULTS, TIMEBACK_COMPONENT_RESOURCE_DEFAULTS, TIMEBACK_ASSESSMENT_RESPONSE_VALUE_MAX_LENGTH = 2048, TIMEBACK_GAME_METRIC_DECIMAL_PLACES, TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE;
 var init_timeback2 = __esm(() => {
   TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
   TIMEBACK_SUBJECTS = [
@@ -1128,7 +1128,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.10.1-beta.3",
+    version: "0.10.1-beta.5",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -10834,30 +10834,60 @@ function comparePresentationText(left, right) {
   }
   return 0;
 }
+function presentationRandomIndex(seed) {
+  let state = presentationHash(seed);
+  const range = 2 ** 32;
+  return (bound) => {
+    const limit = range - range % bound;
+    let value;
+    do {
+      state = state + 1831565813 >>> 0;
+      let mixed = Math.imul(state ^ state >>> 15, state | 1);
+      mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+      value = (mixed ^ mixed >>> 14) >>> 0;
+    } while (value >= limit);
+    return value % bound;
+  };
+}
 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);
-  });
+  const randomIndex = presentationRandomIndex(JSON.stringify([attemptId, itemIdentifier, domain]));
+  const movable = choices.filter((choice) => !choice.fixed).toSorted((left, right) => comparePresentationText(left.identifier, right.identifier));
+  for (let index = movable.length - 1;index > 0; index--) {
+    const other = randomIndex(index + 1);
+    [movable[index], movable[other]] = [movable[other], movable[index]];
+  }
+  let next = 0;
+  return choices.map((choice) => choice.fixed ? choice : movable[next++]);
 }
 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 (!("shuffle" in interaction) || !interaction.shuffle) {
+        return interaction;
       }
-      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}`)
-        };
+      function shuffled(choices, domain) {
+        return presentationChoices(choices, attemptId, item.identifier, `${domain}\x00${interaction.responseIdentifier}`);
+      }
+      switch (interaction.type) {
+        case "choice":
+        case "inline-choice":
+        case "order": {
+          return {
+            ...interaction,
+            choices: shuffled(interaction.choices, interaction.type)
+          };
+        }
+        case "gap-match": {
+          return { ...interaction, gapTexts: shuffled(interaction.gapTexts, "gap-match") };
+        }
+        case "match": {
+          return {
+            ...interaction,
+            sourceChoices: shuffled(interaction.sourceChoices, "match-source"),
+            targetChoices: shuffled(interaction.targetChoices, "match-target")
+          };
+        }
       }
-      return interaction;
     });
     return { ...item, interactions };
   });
@@ -11812,6 +11842,7 @@ var init_assessment_runtime2 = __esm(() => {
   init_src();
   init_timeback3();
   init_src();
+  init_src();
   init_uuid();
   init_esm();
   init_src();
@@ -39209,7 +39240,7 @@ function assertMatchingAssessmentArtifactPair(playable, scoring, expectedIdentit
     throw new ValidationError("Assessment artifact pair does not describe one revision");
   }
 }
-var ASSESSMENT_ARTIFACT_SCHEMA_VERSION = 1, ASSESSMENT_GRADER_PROTOCOL_VERSION = 1, ARTIFACT_KEY_PREFIX = "assessment-artifacts", SHA256_HEX, textEncoder;
+var ASSESSMENT_ARTIFACT_SCHEMA_VERSION = 2, ASSESSMENT_GRADER_PROTOCOL_VERSION = 1, ARTIFACT_KEY_PREFIX = "assessment-artifacts", SHA256_HEX, textEncoder;
 var init_assessment_artifact_envelope_util = __esm(() => {
   init_errors2();
   SHA256_HEX = /^[a-f0-9]{64}$/;
@@ -47958,7 +47989,7 @@ function rejectSystemManagedReview(input, context2) {
     });
   }
 }
-var TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, AssessmentKeySchema, DiagnosticKeySchema, DiagnosticRoutingManifestSchema, DiagnosticAssessmentDefinitionInputSchema, AssessmentStandardRefSchema3, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, AssessmentAssociationImportEntrySchema, AttachExistingAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
+var TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, AssessmentKeySchema, DiagnosticKeySchema, DiagnosticRoutingManifestSchema, DiagnosticAssessmentDefinitionInputSchema, AssessmentStandardRefSchema3, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, ReviseAssessmentRequestSchema, AssessmentAssociationImportEntrySchema, AttachExistingAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
   init_esm();
   init_src();
@@ -48241,6 +48272,11 @@ var init_schemas4 = __esm(() => {
     requireMasteryStandard(input, context2);
     rejectSystemManagedReview(input, context2);
   });
+  ReviseAssessmentRequestSchema = exports_external.object({
+    currentQtiTestIdentifier: exports_external.string().trim().min(1, "The current assessment identifier is required"),
+    title: exports_external.string().trim().min(1, "Assessment title is required"),
+    questions: exports_external.array(exports_external.record(exports_external.string(), exports_external.unknown())).min(1, "A revision must contain at least one question").max(500, "A revision cannot contain more than 500 questions")
+  });
   AssessmentAssociationImportEntrySchema = exports_external.object({
     assessmentKey: AssessmentKeySchema,
     qtiTestIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
@@ -94303,6 +94339,30 @@ var init_timeback_game_metrics_comparison_util = __esm(() => {
 });
 
 // ../timeback/dist/engines/qti/index.js
+function qtiAttributeNumber(attributes, name3, fallback) {
+  const raw = attributes[name3]?.trim();
+  if (!raw) {
+    return fallback;
+  }
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : fallback;
+}
+function qtiAttributeCapacity(attributes, name3, fallback) {
+  const raw = attributes[name3]?.trim();
+  if (!raw) {
+    return fallback;
+  }
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
+function qtiAttributeMaximum(attributes, name3, fallback, unlimited) {
+  const maximum = qtiAttributeNumber(attributes, name3, fallback);
+  return maximum === 0 ? unlimited : maximum;
+}
+function qtiAttributeBoolean(attributes, name3) {
+  const value = attributes[name3];
+  return value === "true" || value === "1";
+}
 function decodeCssEscapes(value) {
   return value.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_, hex3) => {
     const code = Number.parseInt(hex3, 16);
@@ -94890,7 +94950,8 @@ function parseGapTexts(interaction) {
     return {
       identifier: attributes2.identifier || "",
       content: plainTextFromNodes(gapText.children),
-      matchMax: finiteNumber(attributes2["match-max"]) ?? 1
+      matchMax: finiteNumber(attributes2["match-max"]) ?? 1,
+      ...qtiAttributeBoolean(attributes2, "fixed") ? { fixed: true } : {}
     };
   }).filter((gapText) => gapText.identifier);
 }
@@ -95990,30 +96051,6 @@ ${body2}
 ${processing}` : ""}
 </qti-assessment-item>`;
 }
-function qtiAttributeNumber(attributes2, name3, fallback) {
-  const raw = attributes2[name3]?.trim();
-  if (!raw) {
-    return fallback;
-  }
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : fallback;
-}
-function qtiAttributeCapacity(attributes2, name3, fallback) {
-  const raw = attributes2[name3]?.trim();
-  if (!raw) {
-    return fallback;
-  }
-  const value = Number(raw);
-  return Number.isInteger(value) && value >= 0 ? value : null;
-}
-function qtiAttributeMaximum(attributes2, name3, fallback, unlimited) {
-  const maximum = qtiAttributeNumber(attributes2, name3, fallback);
-  return maximum === 0 ? unlimited : maximum;
-}
-function qtiAttributeBoolean(attributes2, name3) {
-  const value = attributes2[name3];
-  return value === "true" || value === "1";
-}
 function gapContentIdentifiers(nodes) {
   return nodes.flatMap((node) => {
     if (node.kind === "gap") {
@@ -96094,6 +96131,7 @@ function authorableQtiInteractionProjection(interaction) {
         type: interaction.type,
         choices: interaction.choices,
         minChoices: qtiAttributeNumber(attributes2, "min-choices", 1),
+        shuffle: qtiAttributeBoolean(attributes2, "shuffle"),
         maxChoices: qtiAttributeMaximum(attributes2, "max-choices", 1, interaction.choices.length)
       };
     }
@@ -96102,6 +96140,7 @@ function authorableQtiInteractionProjection(interaction) {
         ...base,
         type: interaction.type,
         choices: interaction.choices,
+        shuffle: qtiAttributeBoolean(attributes2, "shuffle"),
         blankIndex: interaction.blankIndex ?? 0
       } : null;
     }
@@ -99933,11 +99972,13 @@ var init_assessment_artifact_runtime_util = __esm(() => {
   playableContentNodesSchema = exports_external.array(exports_external.unknown());
   playableChoiceSchema = exports_external.object({
     identifier: trimmedNonEmptyString3,
+    fixed: exports_external.boolean().optional(),
     content: exports_external.string(),
     contentNodes: playableContentNodesSchema.optional()
   }).strict();
   playableMatchChoiceSchema = exports_external.object({
     identifier: trimmedNonEmptyString3,
+    fixed: exports_external.boolean().optional(),
     content: exports_external.string(),
     contentNodes: playableContentNodesSchema.optional(),
     matchMax: nonnegativeInteger
@@ -99957,6 +99998,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
   }).strict();
   playableGapTextSchema = exports_external.object({
     identifier: trimmedNonEmptyString3,
+    fixed: exports_external.boolean().optional(),
     content: exports_external.string(),
     matchMax: nonnegativeInteger
   }).strict();
@@ -99974,6 +100016,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
     exports_external.object({
       ...playableInteractionBase,
       type: exports_external.literal("choice"),
+      shuffle: exports_external.boolean(),
       choices: exports_external.array(playableChoiceSchema),
       minChoices: nonnegativeInteger,
       maxChoices: nonnegativeInteger
@@ -99981,6 +100024,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
     exports_external.object({
       ...playableInteractionBase,
       type: exports_external.literal("inline-choice"),
+      shuffle: exports_external.boolean(),
       choices: exports_external.array(playableChoiceSchema)
     }).strict(),
     exports_external.object({
@@ -100024,6 +100068,7 @@ var init_assessment_artifact_runtime_util = __esm(() => {
     exports_external.object({
       ...playableInteractionBase,
       type: exports_external.literal("gap-match"),
+      shuffle: exports_external.boolean(),
       content: exports_external.string(),
       contentNodes: playableContentNodesSchema,
       gapTexts: exports_external.array(playableGapTextSchema),
@@ -100536,6 +100581,7 @@ function playableChoice(choice) {
   return {
     identifier: choice.identifier,
     content: choice.content,
+    ...qtiAttributeBoolean(choice.attributes, "fixed") ? { fixed: true } : {},
     ...choice.contentNodes ? { contentNodes: choice.contentNodes } : {}
   };
 }
@@ -100598,6 +100644,7 @@ function parseInteraction2(questionIdentifier, interaction) {
       responseIdentifier,
       ...prompt,
       choices,
+      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle"),
       minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 1),
       maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, choices.length)
     };
@@ -100607,7 +100654,8 @@ function parseInteraction2(questionIdentifier, interaction) {
       type,
       responseIdentifier,
       ...prompt,
-      choices: requireChoices2(interaction.choices.map(playableChoice))
+      choices: requireChoices2(interaction.choices.map(playableChoice)),
+      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle")
     };
   }
   if (type === "text-entry") {
@@ -100668,11 +100716,13 @@ function parseInteraction2(questionIdentifier, interaction) {
       responseIdentifier,
       ...prompt,
       content: interaction.textWithGaps,
+      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle"),
       contentNodes: interaction.gapContent,
       gapTexts: interaction.gapTexts.map((gapText) => ({
         identifier: gapText.identifier,
         content: gapText.content,
-        matchMax: gapText.matchMax
+        matchMax: gapText.matchMax,
+        ...gapText.fixed ? { fixed: true } : {}
       })),
       gaps: [...interaction.gaps],
       maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 0)
@@ -101491,7 +101541,7 @@ function buildInlineChoiceQuestionXml(input, identifier, title) {
   if (!envelope) {
     return null;
   }
-  const { structure, responseIdentifier, prompt } = envelope;
+  const { interaction, structure, responseIdentifier, prompt } = envelope;
   const promptParts = prompt.split(INLINE_CHOICE_BLANK);
   if (promptParts.length !== 2) {
     throw new ValidationError("Inline-choice questions require exactly one blank");
@@ -101505,7 +101555,7 @@ function buildInlineChoiceQuestionXml(input, identifier, title) {
   const choicesXml = choices.map((choice) => `        <qti-inline-choice identifier="${escapeXml(choice.identifier)}">${escapeXml(choice.content)}</qti-inline-choice>`).join(`
 `);
   const [before = "", after = ""] = promptParts;
-  const itemBody = `    <p>${escapeXml(before)}<qti-inline-choice-interaction response-identifier="${escapeXml(responseIdentifier)}">
+  const itemBody = `    <p>${escapeXml(before)}<qti-inline-choice-interaction response-identifier="${escapeXml(responseIdentifier)}" shuffle="${interaction.shuffle === true}">
 ${choicesXml}
       </qti-inline-choice-interaction>${escapeXml(after)}</p>`;
   return buildExactMatchQuestionXml({
@@ -102120,7 +102170,7 @@ async function prepareReviewMappingUpdate(test, questions) {
   const contentRevision = await assessmentContentRevision(test, questions);
   const assessment = {
     identifier: test.identifier,
-    contractVersion: 1,
+    contractVersion: PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION,
     contentRevision,
     title: test.title,
     items: questions.questions.map(({ question }) => ({
@@ -102159,6 +102209,7 @@ async function prepareReviewMappingUpdate(test, questions) {
 var PLAYCADEMY_REVIEW_BANK_TITLE = "Review Bank", PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink", PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1, StoredSinkWarningSchema, ReviewBankSinkMarkerSchema;
 var init_timeback_review_mapping_util = __esm(() => {
   init_esm();
+  init_src();
   init_assessment_runtime2();
   init_qti();
   init_timeback3();
@@ -106176,6 +106227,69 @@ var init_timeback_assessment_import_util = __esm(() => {
   init_timeback_qti_authoring_util();
 });
 
+// ../api-core/src/utils/timeback-assessment-revision.util.ts
+function assertRevisableAssessment(row, reviewBankIdentifier) {
+  if (row.purpose === "review" || row.qtiTestIdentifier === reviewBankIdentifier) {
+    throw new ValidationError("The review bank is system-managed. Revise its mastery sources instead.");
+  }
+  if (row.purpose === "diagnostic") {
+    throw new ValidationError("Diagnostics are revised by importing a new revision and archiving the current one.");
+  }
+  if (row.status !== "live") {
+    throw new ValidationError(row.status === "draft" ? "Draft assessments are edited directly. Only live assessments can be revised in place." : "Archived assessments cannot be revised. Restore it to live first.");
+  }
+  if (!row.assessmentKey) {
+    throw new ValidationError("This unmanaged assessment cannot be revised. Republish it with an explicit assessment key.");
+  }
+}
+function assertRevisableTestStructure(current) {
+  const parts2 = qtiTestParts(current);
+  const sectionCount = parts2.reduce((count, part) => count + part["qti-assessment-section"].length, 0);
+  if (parts2.length !== 1 || sectionCount !== 1) {
+    throw new ValidationError(`Assessment ${current.identifier} has ${parts2.length} test part(s) and ${sectionCount} section(s). Revisions can only replace content in single-section assessments.`);
+  }
+}
+function buildRevisionSourceTestInput(input) {
+  assertRevisableTestStructure(input.current);
+  const { "qti-outcome-declaration": outcomeDeclarations, ...structure } = buildQtiTestStructureInput(input.current, input.sourceIdentifier);
+  return {
+    identifier: input.sourceIdentifier,
+    title: input.title,
+    ...qtiTestOptionalAttributes(input.current),
+    metadata: {
+      ...sourceMetadata(input.current.metadata),
+      ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+      ownerGameSlug: input.gameSlug,
+      assessmentKey: input.assessmentKey,
+      integrationId: input.integrationId,
+      subject: input.subject,
+      grade: String(input.grade),
+      [PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY]: emptyReviewBankManifest(input.sourceIdentifier)
+    },
+    ...outcomeDeclarations && outcomeDeclarations.length > 0 ? { "qti-outcome-declaration": outcomeDeclarations } : {},
+    "qti-test-part": structure["qti-test-part"].map((part) => ({
+      ...part,
+      "qti-assessment-section": part["qti-assessment-section"].map((section) => ({
+        ...section,
+        "qti-assessment-item-ref": []
+      }))
+    }))
+  };
+}
+function revisionConflict(requestedIdentifier, currentIdentifier) {
+  return new ConflictError("This assessment was revised by someone else. Reload to see the current version before revising again.", {
+    requestedQtiTestIdentifier: requestedIdentifier,
+    currentQtiTestIdentifier: currentIdentifier
+  });
+}
+var init_timeback_assessment_revision_util = __esm(() => {
+  init_assessment_runtime2();
+  init_timeback3();
+  init_errors2();
+  init_timeback_assessment_publication_util();
+  init_timeback_qti_authoring_util();
+});
+
 // ../api-core/src/utils/timeback-qti-library.util.ts
 function newPlaycademyTestIdentifier() {
   return `${PLAYCADEMY_QTI_SOURCE_PREFIX}${crypto.randomUUID()}`;
@@ -106601,6 +106715,109 @@ class TimebackAssessmentsService {
       throw error88;
     }
   }
+  async reviseAssessment(integrationId, input) {
+    const client2 = this.requireClient();
+    const reviewBankIdentifier = reviewBankSinkIdentifier(integrationId);
+    const current = await this.requireCurrentRevisionRow(integrationId, input.currentQtiTestIdentifier);
+    assertRevisableAssessment(current, reviewBankIdentifier);
+    const ownership = await this.requireQtiTestOwnershipContext(integrationId);
+    const { integration } = ownership;
+    const creations = input.questions.map((question) => {
+      const creation = parseQtiQuestionCreationInput(question);
+      if (creation.kind === "authoring") {
+        assertSupportedQtiQuestionInteraction(creation.input);
+      }
+      return creation;
+    });
+    assertAssessmentHasQuestions(creations);
+    const currentTest = await client2.qtiApi.assessmentTests.get(current.qtiTestIdentifier);
+    const sourceIdentifier = input.sourceTestIdentifier;
+    const sourceInput = buildRevisionSourceTestInput({
+      sourceIdentifier,
+      title: input.title,
+      current: currentTest,
+      assessmentKey: current.assessmentKey,
+      integrationId,
+      gameSlug: ownership.gameSlug,
+      subject: integration.subject,
+      grade: integration.grade
+    });
+    const createdItemIdentifiers = [];
+    let sourceCreateAttempted = false;
+    try {
+      sourceCreateAttempted = true;
+      await client2.qtiApi.assessmentTests.create(sourceInput);
+      const sourceTest = await client2.qtiApi.assessmentTests.get(sourceIdentifier);
+      for (const creation of creations) {
+        const created = await this.createQuestionInOwnedTest({
+          client: client2,
+          integrationId,
+          qtiTestIdentifier: sourceIdentifier,
+          test: sourceTest,
+          gameSlug: ownership.gameSlug,
+          creation
+        });
+        createdItemIdentifiers.push(created.reference.identifier);
+      }
+      const loaded = await loadHydratedQtiTest(client2, sourceIdentifier);
+      await this.validateAssessmentHasQuestions(loaded);
+      const publication = await this.publishManagedAssessment(current, current.purpose, null, loaded);
+      if (!publication.artifactsAvailable) {
+        throw new ValidationError("The revised assessment could not be compiled for the runtime. The current version stays live; try again.");
+      }
+      const result = await this.deps.db.transaction(async (tx) => {
+        const rows = await tx.select().from(gameTimebackAssessmentTests).where(and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.assessmentKey, current.assessmentKey))).for("update");
+        const row = rows[0];
+        if (!row) {
+          throw new NotFoundError(`Assessment not found: ${input.currentQtiTestIdentifier}`);
+        }
+        if (row.qtiTestIdentifier !== input.currentQtiTestIdentifier) {
+          throw revisionConflict(input.currentQtiTestIdentifier, row.qtiTestIdentifier);
+        }
+        assertRevisableAssessment(row, reviewBankIdentifier);
+        const previousQtiTestIdentifier = row.qtiTestIdentifier;
+        const unchanged = publication.qtiTestIdentifier === previousQtiTestIdentifier;
+        if (unchanged) {
+          setAttribute("app.assessment.operation", "revise_unchanged");
+          return { row, previousQtiTestIdentifier, unchanged };
+        }
+        const [updatedRow] = await tx.update(gameTimebackAssessmentTests).set({
+          qtiTestIdentifier: publication.qtiTestIdentifier,
+          updatedAt: new Date
+        }).where(eq(gameTimebackAssessmentTests.id, row.id)).returning();
+        setAttribute("app.assessment.operation", "revise");
+        addEvent("assessment.revised", {
+          "app.assessment.assessment_key": row.assessmentKey,
+          "app.assessment.previous_qti_test_identifier": previousQtiTestIdentifier,
+          "app.assessment.qti_test_identifier": publication.qtiTestIdentifier
+        });
+        return { row: updatedRow ?? row, previousQtiTestIdentifier, unchanged };
+      });
+      let warning;
+      if (!result.unchanged && result.row.purpose === "mastery") {
+        try {
+          const sync = await this.synchronizeReviewBank(integrationId);
+          if (sync.warnings.length > 0) {
+            warning = `Review bank: ${sync.warnings.map((entry) => entry.message).join(" ")}`;
+          }
+        } catch (error88) {
+          addEvent("assessment.revision_review_bank_sync_failed", {
+            "app.assessment.qti_test_identifier": result.row.qtiTestIdentifier,
+            "exception.type": errorType(error88),
+            "app.error.message": errorMessage(error88)
+          });
+          warning = `The review bank could not be synchronized: ${errorMessage(error88)}. Use Sync Review Bank to retry.`;
+        }
+      }
+      return {
+        ...this.associationSummary(result.row, warning),
+        previousQtiTestIdentifier: result.previousQtiTestIdentifier,
+        unchanged: result.unchanged
+      };
+    } finally {
+      await this.cleanupQtiAssessmentCopy(client2, sourceCreateAttempted ? sourceIdentifier : undefined, createdItemIdentifiers);
+    }
+  }
   async removeAssessment(integrationId, qtiTestIdentifier) {
     return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx) => {
       if (qtiTestIdentifier === reviewBankSinkIdentifier(integrationId)) {
@@ -106873,106 +107090,118 @@ class TimebackAssessmentsService {
       assertAllAssessmentAssociationsDraft(associations);
       const ownership = await this.requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, row, tx);
       const creation = parseQtiQuestionCreationInput(input);
-      const itemIdentifier = newPlaycademyQuestionIdentifier(qtiTestIdentifier);
-      let title;
-      let metadata2;
-      let xml;
-      let structuredInput;
-      let fallbackItem;
-      if (creation.kind === "copy") {
-        const source = await client2.qtiApi.assessmentItems.get(creation.sourceItemIdentifier);
-        const copy = buildQtiQuestionCopyInput({
-          source,
-          targetIdentifier: itemIdentifier,
-          targetTestIdentifier: qtiTestIdentifier,
-          gameSlug: ownership.gameSlug,
-          integrationId
-        });
-        title = copy.title;
-        metadata2 = copy.metadata;
-        xml = copy.xml;
-        fallbackItem = {
-          ...source,
-          identifier: itemIdentifier,
-          title,
-          rawXml: xml,
-          metadata: metadata2
-        };
-      } else {
-        structuredInput = creation.input;
-        assertSupportedQtiQuestionInteraction(structuredInput);
-        title = typeof structuredInput.title === "string" ? structuredInput.title.trim() : "";
-        metadata2 = buildOwnedQtiQuestionMetadata(structuredInput, {
-          gameSlug: ownership.gameSlug,
-          testIdentifier: qtiTestIdentifier
-        });
-        xml = buildQuestionXml(structuredInput, itemIdentifier, title);
-        fallbackItem = {
-          ...structuredInput,
-          identifier: itemIdentifier,
-          title,
-          ...xml ? { rawXml: xml } : {}
-        };
-      }
-      const section = await this.qtiSectionItems(client2, qtiTestIdentifier, undefined, undefined, ownership.test);
-      const href = qtiItemHref(client2, itemIdentifier);
-      let item;
-      let itemCreationAttempted = false;
-      let referenceCreationAttempted = false;
-      try {
-        itemCreationAttempted = true;
-        item = xml ? await client2.course.createAssessmentItemXml({ xml, metadata: metadata2 }) : await client2.qtiApi.assessmentItems.create({
-          ...structuredInput,
-          identifier: itemIdentifier,
-          metadata: metadata2
-        });
-        referenceCreationAttempted = true;
-        await section.items.add({
-          identifier: itemIdentifier,
-          href
-        });
-      } catch (error88) {
-        let referenceRemoved = !referenceCreationAttempted;
-        const creationStatus = isApiError(error88) ? error88.statusCode : undefined;
-        const itemCreationDefinitelyRejected = !referenceCreationAttempted && typeof creationStatus === "number" && creationStatus >= 400 && creationStatus < 500 && creationStatus !== 408;
-        if (referenceCreationAttempted) {
-          try {
-            await section.items.remove(itemIdentifier);
-            referenceRemoved = true;
-          } catch (cleanupError) {
-            referenceRemoved = isApiError(cleanupError) && cleanupError.statusCode === 404;
-            addEvent("assessment.qti_question_reference_cleanup_failed", {
-              "app.assessment.qti_test_identifier": qtiTestIdentifier,
-              "app.assessment.qti_item_identifier": itemIdentifier,
-              "exception.type": errorType(cleanupError),
-              "app.error.message": errorMessage(cleanupError)
-            });
-          }
-        }
-        if (itemCreationAttempted && !itemCreationDefinitelyRejected && referenceRemoved) {
-          try {
-            await client2.qtiApi.assessmentItems.delete(itemIdentifier);
-          } catch (cleanupError) {
-            addEvent("assessment.qti_question_cleanup_failed", {
-              "app.assessment.qti_test_identifier": qtiTestIdentifier,
-              "app.assessment.qti_item_identifier": itemIdentifier,
-              "exception.type": errorType(cleanupError),
-              "app.error.message": errorMessage(cleanupError)
-            });
-          }
-        }
-        throw error88;
-      }
+      const created = await this.createQuestionInOwnedTest({
+        client: client2,
+        integrationId,
+        qtiTestIdentifier,
+        test: ownership.test,
+        gameSlug: ownership.gameSlug,
+        creation
+      });
       setAttribute("app.assessment.operation", creation.kind === "copy" ? "copy_question" : "create_question");
-      return buildCreatedQtiQuestionReference({
-        item,
-        fallbackItem,
-        itemIdentifier,
-        href,
-        partIdentifier: section.partIdentifier,
-        sectionIdentifier: section.sectionIdentifier,
+      return created;
+    });
+  }
+  async createQuestionInOwnedTest(input) {
+    const { client: client2, integrationId, qtiTestIdentifier, creation } = input;
+    const itemIdentifier = newPlaycademyQuestionIdentifier(qtiTestIdentifier);
+    let title;
+    let metadata2;
+    let xml;
+    let structuredInput;
+    let fallbackItem;
+    if (creation.kind === "copy") {
+      const source = await client2.qtiApi.assessmentItems.get(creation.sourceItemIdentifier);
+      const copy = buildQtiQuestionCopyInput({
+        source,
+        targetIdentifier: itemIdentifier,
+        targetTestIdentifier: qtiTestIdentifier,
+        gameSlug: input.gameSlug,
+        integrationId
+      });
+      title = copy.title;
+      metadata2 = copy.metadata;
+      xml = copy.xml;
+      fallbackItem = {
+        ...source,
+        identifier: itemIdentifier,
+        title,
+        rawXml: xml,
         metadata: metadata2
+      };
+    } else {
+      structuredInput = creation.input;
+      assertSupportedQtiQuestionInteraction(structuredInput);
+      title = typeof structuredInput.title === "string" ? structuredInput.title.trim() : "";
+      metadata2 = buildOwnedQtiQuestionMetadata(structuredInput, {
+        gameSlug: input.gameSlug,
+        testIdentifier: qtiTestIdentifier
       });
+      xml = buildQuestionXml(structuredInput, itemIdentifier, title);
+      fallbackItem = {
+        ...structuredInput,
+        identifier: itemIdentifier,
+        title,
+        ...xml ? { rawXml: xml } : {}
+      };
+    }
+    const section = await this.qtiSectionItems(client2, qtiTestIdentifier, undefined, undefined, input.test);
+    const href = qtiItemHref(client2, itemIdentifier);
+    let item;
+    let itemCreationAttempted = false;
+    let referenceCreationAttempted = false;
+    try {
+      itemCreationAttempted = true;
+      item = xml ? await client2.course.createAssessmentItemXml({ xml, metadata: metadata2 }) : await client2.qtiApi.assessmentItems.create({
+        ...structuredInput,
+        identifier: itemIdentifier,
+        metadata: metadata2
+      });
+      referenceCreationAttempted = true;
+      await section.items.add({
+        identifier: itemIdentifier,
+        href
+      });
+    } catch (error88) {
+      let referenceRemoved = !referenceCreationAttempted;
+      const creationStatus = isApiError(error88) ? error88.statusCode : undefined;
+      const itemCreationDefinitelyRejected = !referenceCreationAttempted && typeof creationStatus === "number" && creationStatus >= 400 && creationStatus < 500 && creationStatus !== 408;
+      if (referenceCreationAttempted) {
+        try {
+          await section.items.remove(itemIdentifier);
+          referenceRemoved = true;
+        } catch (cleanupError) {
+          referenceRemoved = isApiError(cleanupError) && cleanupError.statusCode === 404;
+          addEvent("assessment.qti_question_reference_cleanup_failed", {
+            "app.assessment.qti_test_identifier": qtiTestIdentifier,
+            "app.assessment.qti_item_identifier": itemIdentifier,
+            "exception.type": errorType(cleanupError),
+            "app.error.message": errorMessage(cleanupError)
+          });
+        }
+      }
+      if (itemCreationAttempted && !itemCreationDefinitelyRejected && referenceRemoved) {
+        try {
+          await client2.qtiApi.assessmentItems.delete(itemIdentifier);
+        } catch (cleanupError) {
+          addEvent("assessment.qti_question_cleanup_failed", {
+            "app.assessment.qti_test_identifier": qtiTestIdentifier,
+            "app.assessment.qti_item_identifier": itemIdentifier,
+            "exception.type": errorType(cleanupError),
+            "app.error.message": errorMessage(cleanupError)
+          });
+        }
+      }
+      throw error88;
+    }
+    return buildCreatedQtiQuestionReference({
+      item,
+      fallbackItem,
+      itemIdentifier,
+      href,
+      partIdentifier: section.partIdentifier,
+      sectionIdentifier: section.sectionIdentifier,
+      metadata: metadata2
     });
   }
   async updateQuestion(integrationId, qtiTestIdentifier, itemIdentifier, input) {
@@ -107220,6 +107449,22 @@ class TimebackAssessmentsService {
     }
     return row;
   }
+  async requireCurrentRevisionRow(integrationId, qtiTestIdentifier) {
+    const row = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+      where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, qtiTestIdentifier))
+    });
+    if (row) {
+      return row;
+    }
+    const assessmentKey = assessmentKeyFromManagedQtiIdentifier(qtiTestIdentifier);
+    const successor = assessmentKey ? await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+      where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.assessmentKey, assessmentKey))
+    }) : undefined;
+    if (successor) {
+      throw revisionConflict(qtiTestIdentifier, successor.qtiTestIdentifier);
+    }
+    throw new NotFoundError(`Assessment not found: ${qtiTestIdentifier}`);
+  }
   async requireDraftAssessmentRow(integrationId, qtiTestIdentifier, lockedRow) {
     const row = lockedRow ?? await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
     assertDraftAssessment(row);
@@ -107367,9 +107612,21 @@ class TimebackAssessmentsService {
       itemHref: (identifier) => qtiItemHref(client2, identifier)
     });
     const artifactSource = await this.ensureManagedQtiPublication(client2, plan);
-    const artifactsAvailable = await this.storeManagedArtifacts(artifactSource, managedAssessmentDiagnosticRoutingManifest(artifactSource.test, plan.assessmentKey));
+    const artifactsAvailable = await this.managedArtifactsStored(plan.qtiTestIdentifier) || await this.storeManagedArtifacts(artifactSource, managedAssessmentDiagnosticRoutingManifest(artifactSource.test, plan.assessmentKey));
     const warning = assessmentArtifactPublicationWarning(artifactsAvailable);
-    return { ...plan, ...warning ? { warning } : {} };
+    return { ...plan, artifactsAvailable, ...warning ? { warning } : {} };
+  }
+  async managedArtifactsStored(qtiTestIdentifier) {
+    try {
+      return await this.deps.assessmentArtifacts.loadManagedPlayable(qtiTestIdentifier) !== null;
+    } catch (error88) {
+      addEvent("assessment.artifact_lookup_failed", {
+        "app.assessment.qti_test_identifier": qtiTestIdentifier,
+        "exception.type": errorType(error88),
+        "app.error.message": errorMessage(error88)
+      });
+      return false;
+    }
   }
   async cleanupQtiAssessmentCopy(client2, testIdentifier, itemIdentifiers) {
     let testDeleted = !testIdentifier;
@@ -107496,6 +107753,7 @@ var init_timeback_assessments_service = __esm(async () => {
   init_timeback_assessment_diagnostic_util();
   init_timeback_assessment_import_util();
   init_timeback_assessment_publication_util();
+  init_timeback_assessment_revision_util();
   init_timeback_assessment_rules_util();
   init_timeback_qti_authoring_util();
   init_timeback_qti_hydration_util();
@@ -167505,7 +167763,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, reviseAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -168250,6 +168508,20 @@ var init_timeback_controller = __esm(() => {
     const body2 = await parseRequestBody(ctx.request, UpdateAssessmentRequestSchema);
     return ctx.services.timebackAssessments.updateAssessment(integrationId, testIdentifier, body2);
   });
+  reviseAssessment = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
+    }
+    const body2 = await parseRequestBody(ctx.request, ReviseAssessmentRequestSchema);
+    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
+    return ctx.services.timebackAssessments.reviseAssessment(integrationId, {
+      currentQtiTestIdentifier: body2.currentQtiTestIdentifier,
+      sourceTestIdentifier: newPlaycademyTestIdentifier(),
+      title: body2.title,
+      questions: body2.questions
+    });
+  });
   synchronizeReviewBank = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
     if (!gameId || !courseId) {
@@ -168400,6 +168672,7 @@ var init_timeback_controller = __esm(() => {
     createAssessment,
     attachExistingAssessments,
     updateAssessment,
+    reviseAssessment,
     synchronizeReviewBank,
     removeAssessment,
     reorderQuestions,