@playcademy/vite-plugin 1.2.1-beta.27 → 1.2.1-beta.28

package/dist/index.js

@@ -24317,7 +24317,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.2.1-beta.27",
+  version: "1.2.1-beta.28",
   type: "module",
   exports: {
     ".": {
@@ -25934,7 +25934,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.7.1-beta.25",
+    version: "0.7.1-beta.26",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -35693,6 +35693,14 @@ function compareAssessmentCatalogOrder(left, right) {
   } else if (leftHasValidDate !== rightHasValidDate) {
     return leftHasValidDate ? -1 : 1;
   }
+  if (left.assessmentKey !== null && right.assessmentKey !== null) {
+    const keyDifference = left.assessmentKey.localeCompare(right.assessmentKey);
+    if (keyDifference) {
+      return keyDifference;
+    }
+  } else if (left.assessmentKey !== null || right.assessmentKey !== null) {
+    return left.assessmentKey === null ? 1 : -1;
+  }
   return left.qtiTestIdentifier.localeCompare(right.qtiTestIdentifier);
 }
 function orderRuntimeAssessmentTests(tests) {
@@ -35712,13 +35720,13 @@ function selectRuntimeAssessment(liveTests, attempts) {
     return null;
   }
   const completed = attempts.filter(isAssessmentAttemptCompleted);
-  const exposedTestIds = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedTestIdentifier));
-  const unattempted = orderedTests.find((test) => !exposedTestIds.has(test.qtiTestIdentifier));
+  const exposedAssessmentKeys = new Set(attempts.filter((attempt) => isAssessmentAttemptOpen(attempt) || isAssessmentAttemptCompleted(attempt)).map((attempt) => attempt.selectedAssessmentKey));
+  const unattempted = orderedTests.find((test) => !exposedAssessmentKeys.has(test.assessmentKey));
   if (unattempted) {
     return { kind: "start", test: unattempted, reason: "unattempted" };
   }
   const latestCompleted = completed.toSorted(compareNewestCompletedAssessmentAttempt)[0];
-  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.qtiTestIdentifier === latestCompleted.selectedTestIdentifier) : -1;
+  const latestTestIndex = latestCompleted ? orderedTests.findIndex((test) => test.assessmentKey === latestCompleted.selectedAssessmentKey) : -1;
   if (latestTestIndex === -1) {
     return { kind: "start", test: orderedTests[0], reason: "first_live" };
   }
@@ -36380,7 +36388,7 @@ function isPlaycademyAssessmentResultMetadataV1(value) {
   const review = metadata2.review;
   const diagnostic = metadata2.diagnostic;
   const routedDiagnostic = metadata2.purpose === "diagnostic" && diagnostic !== undefined && Array.isArray(metadata2.itemSubmissions) && Number.isInteger(metadata2.responseVersion) && isRoutedDiagnosticAttemptMetadata(diagnostic, metadata2.itemSubmissions, metadata2.responseVersion);
-  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && Array.isArray(metadata2.itemSubmissions) && metadata2.itemSubmissions.every(isAssessmentItemSubmission) && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.purpose === "diagnostic" ? diagnostic === undefined || routedDiagnostic : diagnostic === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && isCompletionMetadata(metadata2.completion, metadata2.purpose, routedDiagnostic);
+  return metadata2.version === 1 && typeof metadata2.activityId === "string" && isAssessmentPurpose(metadata2.purpose) && typeof metadata2.courseId === "string" && typeof metadata2.integrationId === "string" && typeof metadata2.enrollmentId === "string" && Boolean(selectedTest) && (selectedTest?.assessmentKey === undefined || isNonEmptyString(selectedTest.assessmentKey)) && typeof selectedTest?.identifier === "string" && typeof selectedTest.contentRevision === "string" && Number.isInteger(metadata2.attemptNumber) && Number.isInteger(metadata2.responseVersion) && Boolean(metadata2.responses) && typeof metadata2.responses === "object" && Array.isArray(metadata2.itemSubmissions) && metadata2.itemSubmissions.every(isAssessmentItemSubmission) && typeof metadata2.startedAt === "string" && typeof metadata2.updatedAt === "string" && (metadata2.purpose === "mastery" ? isMasteryAttemptMetadata(mastery) : mastery === undefined) && (metadata2.purpose === "review" ? isReviewAttemptMetadata(review) : review === undefined) && (metadata2.purpose === "diagnostic" ? diagnostic === undefined || routedDiagnostic : diagnostic === undefined) && (metadata2.submissionId === undefined || typeof metadata2.submissionId === "string") && (metadata2.score === undefined || isAssessmentScore(metadata2.score)) && isCompletionMetadata(metadata2.completion, metadata2.purpose, routedDiagnostic);
 }
 function isPlaycademyReviewAssessmentItemResultMetadataV1(value) {
   if (!isRecord(value) || !isRecord(value.responses)) {
@@ -36528,6 +36536,7 @@ var REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1"
 var PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank";
 var PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1;
 var DEFAULT_REVIEW_SELECTION_POLICY;
+var ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 7;
 var RuntimeSubjectSchema;
 var RuntimeGradeSchema;
 var OptionalQueryGradeSchema;
@@ -43138,6 +43147,7 @@ var init_table7 = __esm(() => {
   gameTimebackAssessmentTests = pgTable("game_timeback_assessment_tests", {
     id: uuid("id").primaryKey().defaultRandom(),
     integrationId: uuid("integration_id").notNull().references(() => gameTimebackIntegrations.id, { onDelete: "cascade" }),
+    assessmentKey: text("assessment_key"),
     qtiTestIdentifier: text("qti_test_identifier").notNull(),
     purpose: gameTimebackAssessmentPurposeEnum("purpose").notNull().default("end_of_course"),
     status: gameTimebackAssessmentStatusEnum("status").notNull().default("draft"),
@@ -43150,6 +43160,7 @@ var init_table7 = __esm(() => {
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
   }, (table3) => [
     uniqueIndex("game_timeback_assessment_tests_integration_qti_idx").on(table3.integrationId, table3.qtiTestIdentifier),
+    uniqueIndex("game_timeback_assessment_tests_integration_key_idx").on(table3.integrationId, table3.assessmentKey).where(sql`${table3.assessmentKey} IS NOT NULL`),
     uniqueIndex("game_timeback_assessment_tests_one_live_review_idx").on(table3.integrationId).where(sql`${table3.purpose} = 'review' AND ${table3.status} = 'live'`),
     uniqueIndex("game_timeback_assessment_tests_one_live_diagnostic_key_idx").on(table3.integrationId, table3.diagnosticKey).where(sql`${table3.purpose} = 'diagnostic' AND ${table3.status} = 'live' AND ${table3.diagnosticKey} IS NOT NULL`),
     check("game_timeback_assessment_tests_mastery_standard_check", sql`(
@@ -71629,6 +71640,7 @@ var ReactivateEnrollmentRequestSchema;
 var VerifyTimebackMetricDiscrepancyRequestSchema;
 var AssessmentPurposeSchema;
 var AssessmentStatusSchema;
+var AssessmentKeySchema;
 var DiagnosticKeySchema;
 var DiagnosticRoutingManifestSchema;
 var DiagnosticAssessmentDefinitionInputSchema;
@@ -71884,6 +71896,7 @@ var init_schemas4 = __esm(() => {
   });
   AssessmentPurposeSchema = exports_external.enum(gameTimebackAssessmentPurposeEnum.enumValues);
   AssessmentStatusSchema = exports_external.enum(gameTimebackAssessmentStatusEnum.enumValues);
+  AssessmentKeySchema = exports_external.string().min(1, "Assessment key is required").max(100, "Assessment key cannot exceed 100 characters").regex(/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/, "Assessment key must use lowercase letters, numbers, dots, underscores, or hyphens");
   DiagnosticKeySchema = exports_external.string().trim().min(1).max(200);
   DiagnosticRoutingManifestSchema = exports_external.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value), "Diagnostic routing manifest must be an object");
   DiagnosticAssessmentDefinitionInputSchema = exports_external.object({
@@ -71895,6 +71908,7 @@ var init_schemas4 = __esm(() => {
     identifier: exports_external.string().trim().min(1).max(TIMEBACK_ASSESSMENT_REVIEW_REQUEST_LIMITS.standardFieldLength)
   });
   CreateAssessmentRequestSchema = exports_external.object({
+    assessmentKey: AssessmentKeySchema,
     title: exports_external.string().min(1, "Assessment title is required"),
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional()
@@ -71909,11 +71923,13 @@ var init_schemas4 = __esm(() => {
     message: "Title, purpose, standard, diagnostic, or status is required"
   });
   CopyAssessmentRequestSchema = exports_external.object({
+    assessmentKey: AssessmentKeySchema,
     testIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional()
   }).superRefine(requireMasteryStandard);
   AssessmentAssociationImportEntrySchema = exports_external.object({
+    assessmentKey: AssessmentKeySchema,
     qtiTestIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
     purpose: AssessmentPurposeSchema,
     standard: AssessmentStandardRefSchema2.optional(),
@@ -71945,16 +71961,25 @@ var init_schemas4 = __esm(() => {
     targetStatus: exports_external.enum(["draft", "live"]),
     assessments: exports_external.array(AssessmentAssociationImportEntrySchema).min(1, "At least one assessment is required").max(500, "A bulk import can contain at most 500 assessments")
   }).superRefine((input, context2) => {
-    const seen = new Set;
+    const seenIdentifiers = new Set;
+    const seenKeys = new Set;
     input.assessments.forEach((assessment, index2) => {
-      if (seen.has(assessment.qtiTestIdentifier)) {
+      if (seenIdentifiers.has(assessment.qtiTestIdentifier)) {
         context2.addIssue({
           code: "custom",
           path: ["assessments", index2, "qtiTestIdentifier"],
           message: "Assessment identifiers must be unique"
         });
       }
-      seen.add(assessment.qtiTestIdentifier);
+      if (seenKeys.has(assessment.assessmentKey)) {
+        context2.addIssue({
+          code: "custom",
+          path: ["assessments", index2, "assessmentKey"],
+          message: "Assessment keys must be unique"
+        });
+      }
+      seenIdentifiers.add(assessment.qtiTestIdentifier);
+      seenKeys.add(assessment.assessmentKey);
     });
   });
   ReorderAssessmentsRequestSchema = exports_external.object({
@@ -124173,113 +124198,947 @@ var init_assessment_runtime_lock_util = __esm(() => {
     }
   };
 });
-function validateAssessmentStatusTransition(current, next) {
-  if (current === next) {
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function persistableAuthoringDocument(value) {
+  const document2 = recordValue(value);
+  const item = recordValue(document2?.item);
+  if (!document2 || !item) {
     return;
   }
-  const allowed = current === "draft" && next === "live" || current === "live" && next === "archived" || current === "archived" && next === "live";
-  if (!allowed) {
-    throw new ValidationError(`Assessment status cannot change from ${current} to ${next}`);
+  const persistableItem = { ...item };
+  Reflect.deleteProperty(persistableItem, "metadata");
+  return { ...document2, item: persistableItem };
+}
+function qtiAuthoringSnapshot(input) {
+  const document2 = persistableAuthoringDocument(input.document);
+  if (!recordValue(input.interaction) && !document2) {
+    return;
   }
+  return Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => {
+    if (field === "document") {
+      return document2 ? [[field, document2]] : [];
+    }
+    return input[field] === undefined ? [] : [[field, input[field]]];
+  }));
 }
-function isAssessmentPublicationTransition(current, next) {
-  return current !== "live" && next === "live";
+function buildOwnedQtiQuestionMetadata(input, ownership, existingMetadata = {}) {
+  const inputMetadata = recordValue(input.metadata) ?? {};
+  const metadata2 = {
+    ...existingMetadata,
+    ...inputMetadata
+  };
+  const existingAuthoring = recordValue(existingMetadata[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
+  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
+  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_EDITOR_MODE_KEY);
+  const authoring = qtiAuthoringSnapshot(input);
+  const shouldReplaceAuthoring = "interaction" in input || "numericTextEntry" in input || "document" in input;
+  const persistedAuthoring = authoring ?? (shouldReplaceAuthoring ? undefined : existingAuthoring);
+  return {
+    ...metadata2,
+    ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+    ownerGameSlug: ownership.gameSlug,
+    [PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]: ownership.testIdentifier,
+    ...persistedAuthoring ? { [PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]: persistedAuthoring } : {}
+  };
 }
-function assertDraftAssessment(row) {
-  if (row.status !== "draft") {
-    throw new ValidationError("Only draft assessments can change QTI content or question membership");
+function restoreQtiQuestionAuthoringData(item) {
+  const authoring = recordValue(item.metadata?.[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
+  if (!authoring) {
+    return item;
   }
+  const restored = Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => authoring[field] === undefined ? [] : [[field, authoring[field]]]));
+  return { ...item, ...restored };
 }
-function assertMasteryPurposeChangeDraft(row, nextPurpose) {
-  if (row.purpose !== nextPurpose && (row.purpose === "mastery" || nextPurpose === "mastery") && row.status !== "draft") {
-    throw new ValidationError("Only draft assessments can change to or from mastery");
+function mergeQtiQuestionItem(item, fallbackItem, itemIdentifier, metadata2) {
+  return restoreQtiQuestionAuthoringData({
+    ...fallbackItem,
+    ...item,
+    identifier: itemIdentifier,
+    title: item.title || fallbackItem?.title || itemIdentifier,
+    type: item.type ?? fallbackItem?.type,
+    rawXml: item.rawXml ?? fallbackItem?.rawXml,
+    interaction: item.interaction ?? fallbackItem?.interaction,
+    responseDeclarations: item.responseDeclarations ?? fallbackItem?.responseDeclarations,
+    metadata: {
+      ...fallbackItem?.metadata,
+      ...item.metadata,
+      ...metadata2
+    }
+  });
+}
+function newPlaycademyQuestionIdentifier(testIdentifier) {
+  return `${testIdentifier}-q${crypto.randomUUID().slice(0, 8)}`;
+}
+function parseQtiQuestionCreationInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new ValidationError("Question creation input must be an object");
   }
+  const rawInput = input;
+  if (rawInput.mode === undefined) {
+    return { kind: "authoring", input: rawInput };
+  }
+  if (rawInput.mode !== "copy") {
+    throw new ValidationError("Question creation mode is invalid");
+  }
+  const sourceItemIdentifier = typeof rawInput.sourceItemIdentifier === "string" ? rawInput.sourceItemIdentifier.trim() : "";
+  if (!sourceItemIdentifier) {
+    throw new ValidationError("A source question identifier is required to create a copy");
+  }
+  const unexpectedField = Object.keys(rawInput).find((field) => field !== "mode" && field !== "sourceItemIdentifier");
+  if (unexpectedField) {
+    throw new ValidationError(`Question copy input contains an unexpected “${unexpectedField}” field`);
+  }
+  return { kind: "copy", sourceItemIdentifier };
 }
-function assertDiagnosticPurposeChangeDraft(row, nextPurpose) {
-  if (row.purpose !== nextPurpose && (row.purpose === "diagnostic" || nextPurpose === "diagnostic") && row.status !== "draft") {
-    throw new ValidationError("Only draft assessments can change to or from diagnostic");
+function nonEmptyMetadataString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function qtiQuestionOwnerTestIdentifier(item) {
+  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
   }
+  return nonEmptyMetadataString(item.metadata[PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]);
 }
-function diagnosticDefinitionForRow(row) {
-  return row.diagnosticKey && row.diagnosticRoutingManifest ? {
-    diagnosticKey: row.diagnosticKey,
-    routingManifest: row.diagnosticRoutingManifest
-  } : null;
+function qtiTestReferencesItem(test, itemIdentifier) {
+  return (test["qti-test-part"] ?? []).some((part) => (part["qti-assessment-section"] ?? []).some((section) => (section["qti-assessment-item-ref"] ?? []).some((reference) => reference.identifier === itemIdentifier)));
 }
-function assertAllAssessmentAssociationsDraft(rows) {
-  if (rows.some((row) => row.status !== "draft")) {
-    throw new ValidationError("QTI content cannot change while any associated assessment is live or archived");
+function resolveQtiQuestionOwnerGameSlug(item, ownerTest) {
+  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
   }
+  if ("ownerGameSlug" in item.metadata) {
+    return nonEmptyMetadataString(item.metadata.ownerGameSlug);
+  }
+  const ownerTestIdentifier = qtiQuestionOwnerTestIdentifier(item);
+  if (!ownerTestIdentifier || !ownerTest || ownerTest.identifier !== ownerTestIdentifier || !qtiTestReferencesItem(ownerTest, item.identifier) || ownerTest.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
+  }
+  return nonEmptyMetadataString(ownerTest.metadata.ownerGameSlug);
 }
-function assertAssessmentHasQuestions(questions) {
-  if (questions.length === 0) {
-    throw new ValidationError("An assessment must contain at least one question to publish");
+function isQtiQuestionOwnedByGame(item, gameSlug, ownerTest) {
+  return resolveQtiQuestionOwnerGameSlug(item, ownerTest) === gameSlug;
+}
+function isQtiQuestionOwnedByContext(item, ownership, ownerTest) {
+  const declaredOwnerTest = qtiQuestionOwnerTestIdentifier(item);
+  if (declaredOwnerTest) {
+    return declaredOwnerTest === ownership.testIdentifier && isQtiQuestionOwnedByGame(item, ownership.gameSlug, ownerTest);
   }
+  return isQtiItemOwnedByTest(item, ownership.testIdentifier);
 }
-function assertReviewAssessmentHasStandards(standardCounts) {
-  if (standardCounts.some((count) => count !== 1)) {
-    throw new ValidationError("Every question in a review assessment must have exactly one standards alignment");
+function normalizedQtiInteractionType(value) {
+  if (typeof value !== "string") {
+    return;
   }
+  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
+  return normalized || undefined;
 }
-function planAssessmentRemoval(status) {
-  if (status === "draft") {
-    return { kind: "delete", action: "discarded", operation: "discard_draft" };
+function authoringDocumentItem(value) {
+  const document2 = recordValue(value);
+  if (!document2) {
+    throw new ValidationError("Authored question data is invalid");
   }
-  if (status === "live") {
-    return { kind: "archive", action: "archived", operation: "archive" };
+  if (document2.format !== "playcademy-question" || document2.version !== 1) {
+    throw new ValidationError("Authored questions require a version 1 playcademy-question document");
   }
-  return { kind: "none", action: "archived" };
+  const item = recordValue(document2.item);
+  if (!item || typeof item.title !== "string" || !Array.isArray(item.body) || !Array.isArray(item.responseDeclarations)) {
+    throw new ValidationError("An authored question needs an item with a title, a body, and response declarations");
+  }
+  const declarations = item.responseDeclarations.map(recordValue);
+  const declaredIdentifiers = declarations.map((declaration) => typeof declaration?.identifier === "string" ? declaration.identifier : "");
+  if (declarations.length === 0) {
+    throw new ValidationError("An authored question requires at least one response declaration");
+  }
+  const declaredIdentifierSet = new Set(declaredIdentifiers);
+  if (declaredIdentifiers.some((identifier) => !identifier) || declaredIdentifierSet.size !== declaredIdentifiers.length) {
+    throw new ValidationError("Response declaration identifiers must be unique");
+  }
+  const projection = projectQtiAuthoringBody(item.body);
+  if (projection.nestedInteractions.length > 0) {
+    throw new ValidationError("Interactions nested inside another interaction cannot be compiled");
+  }
+  if (projection.interactions.length !== declarations.length) {
+    throw new ValidationError("Every response declaration must belong to exactly one interaction");
+  }
+  const interactionIdentifiers = projection.interactions.map((interaction) => interaction.responseIdentifier);
+  const interactionIdentifierSet = new Set(interactionIdentifiers);
+  if (interactionIdentifierSet.size !== interactionIdentifiers.length) {
+    throw new ValidationError("Every interaction needs its own response identifier");
+  }
+  if (interactionIdentifiers.some((identifier) => !declaredIdentifierSet.has(identifier)) || declaredIdentifiers.some((identifier) => !interactionIdentifierSet.has(identifier))) {
+    throw new ValidationError("Every interaction must declare exactly one response");
+  }
+  const unauthorable = projection.interactions.find((interaction) => !qtiAuthoringInteractionType(interaction));
+  if (unauthorable) {
+    throw new ValidationError(`Interaction type “${String(unauthorable.type)}” cannot be authored by Playcademy yet`);
+  }
+  const inline = projection.interactions.filter(isInlineQtiAuthoringInteraction);
+  if (projection.interactions.length - inline.length > 1) {
+    throw new ValidationError("A question supports any number of inline interactions but at most one block interaction");
+  }
+  if (item.body.some((node) => node.kind === "interaction" && isInlineQtiAuthoringInteraction(node))) {
+    throw new ValidationError("Every inline interaction must sit at its blank inside the question’s prose");
+  }
+  const blanks = inline.map((interaction) => projection.blankIndexes.get(interaction));
+  if (blanks.some((blank) => blank === undefined) || new Set(blanks).size !== blanks.length) {
+    throw new ValidationError("Every inline interaction needs its own blank position");
+  }
+  return item;
 }
-function buildAssessmentAssociationUpdates(row, input) {
-  const updates = {};
-  if (input.purpose !== undefined) {
-    updates.purpose = input.purpose;
-    if (input.purpose !== "mastery" && (row.purpose === "mastery" || row.standardFramework || row.standardIdentifier)) {
-      updates.standardFramework = null;
-      updates.standardIdentifier = null;
+function parsedQtiItemOrNull(rawXml) {
+  if (typeof rawXml !== "string" || !rawXml) {
+    return null;
+  }
+  try {
+    return parseQtiItemXml(rawXml);
+  } catch {
+    return null;
+  }
+}
+function isAuthorableMultiInteractionQtiItem(question) {
+  const item = parsedQtiItemOrNull(question.rawXml);
+  return item !== null && (authorableQtiInteractions(item)?.length ?? 0) > 1;
+}
+function assertPlayableQtiQuestion(question) {
+  if (!question.rawXml) {
+    assertSupportedQtiQuestionInteraction(question);
+    return;
+  }
+  const item = parsedQtiItemOrNull(question.rawXml);
+  const playable = item && playableQtiInteractions(item);
+  if (!playable || qtiItemScoringValidationMessage(item)) {
+    throw new ValidationError(`Question ${question.identifier} uses an interaction Playcademy cannot play or score.`);
+  }
+}
+function assertSupportedQtiQuestionInteraction(question) {
+  const candidate = recordValue(question);
+  if (candidate?.type === AUTHORING_DOCUMENT_QUESTION_TYPE) {
+    authoringDocumentItem(candidate.document);
+    return;
+  }
+  if (!supportedQtiQuestionInteractionType(question) && !isAuthorableMultiInteractionQtiItem(question)) {
+    throw new ValidationError("This QTI interaction type is not supported by the Playcademy question editor.");
+  }
+}
+function invalidQtiCopyXml() {
+  throw new ValidationError("The source question does not contain valid QTI item XML");
+}
+function markupEnd2(xml, start2, allowInternalSubset) {
+  let quote = null;
+  let subsetDepth = 0;
+  for (let index2 = start2;index2 < xml.length; index2 += 1) {
+    const character = xml[index2];
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (allowInternalSubset && character === "[") {
+      subsetDepth += 1;
+    } else if (allowInternalSubset && character === "]") {
+      subsetDepth = Math.max(0, subsetDepth - 1);
+    } else if (character === ">" && subsetDepth === 0) {
+      return index2;
     }
-    if (row.status === "live" && input.purpose !== row.purpose) {
-      updates.sortOrder = null;
+  }
+  return invalidQtiCopyXml();
+}
+function skipXmlWhitespace(xml, start2, end = xml.length) {
+  let cursor2 = start2;
+  while (cursor2 < end && /\s/.test(xml[cursor2] ?? "")) {
+    cursor2 += 1;
+  }
+  return cursor2;
+}
+function xmlPreambleEnd(xml, cursor2) {
+  if (xml.startsWith("<?", cursor2)) {
+    const end = xml.indexOf("?>", cursor2 + 2);
+    if (end === -1) {
+      return invalidQtiCopyXml();
     }
+    return end + 2;
   }
-  if (input.standard !== undefined) {
-    updates.standardFramework = input.standard.framework;
-    updates.standardIdentifier = input.standard.identifier;
+  if (xml.startsWith("<!--", cursor2)) {
+    const end = xml.indexOf("-->", cursor2 + 4);
+    if (end === -1) {
+      return invalidQtiCopyXml();
+    }
+    return end + 3;
   }
-  if (input.status !== undefined) {
-    updates.status = input.status;
-    if (input.status === "archived") {
-      updates.sortOrder = null;
+  if (/^<!DOCTYPE\b/i.test(xml.slice(cursor2))) {
+    return markupEnd2(xml, cursor2 + 2, true) + 1;
+  }
+  return null;
+}
+function qtiRootAttributes(xml, start2, end) {
+  const attributes2 = [];
+  let cursor2 = start2;
+  while (cursor2 < end) {
+    cursor2 = skipXmlWhitespace(xml, cursor2, end);
+    if (xml[cursor2] === "/") {
+      cursor2 += 1;
+    } else if (cursor2 < end) {
+      const nameMatch = /^[A-Za-z_][\w.:-]*/.exec(xml.slice(cursor2, end));
+      if (!nameMatch) {
+        return invalidQtiCopyXml();
+      }
+      const name3 = nameMatch[0];
+      cursor2 = skipXmlWhitespace(xml, cursor2 + name3.length, end);
+      if (xml[cursor2] !== "=") {
+        return invalidQtiCopyXml();
+      }
+      cursor2 = skipXmlWhitespace(xml, cursor2 + 1, end);
+      const quote = xml[cursor2];
+      if (quote !== '"' && quote !== "'") {
+        return invalidQtiCopyXml();
+      }
+      const valueStart = cursor2 + 1;
+      const valueEnd = xml.indexOf(quote, valueStart);
+      if (valueEnd === -1 || valueEnd > end) {
+        return invalidQtiCopyXml();
+      }
+      attributes2.push({ name: name3, quote, valueStart, valueEnd });
+      cursor2 = valueEnd + 1;
     }
   }
-  return updates;
+  return attributes2;
 }
-function assessmentStandardForRow(row) {
-  return row.standardFramework && row.standardIdentifier ? { framework: row.standardFramework, identifier: row.standardIdentifier } : null;
+function qtiItemStartTag(xml) {
+  let cursor2 = xml.charCodeAt(0) === 65279 ? 1 : 0;
+  while (cursor2 < xml.length) {
+    cursor2 = skipXmlWhitespace(xml, cursor2);
+    const preambleEnd = xmlPreambleEnd(xml, cursor2);
+    if (preambleEnd !== null) {
+      cursor2 = preambleEnd;
+    } else {
+      const root = /^<([A-Za-z_][\w.:-]*)/.exec(xml.slice(cursor2));
+      if (!root || root[1].split(":").at(-1) !== "qti-assessment-item") {
+        return invalidQtiCopyXml();
+      }
+      const attributesStart = cursor2 + root[0].length;
+      const end = markupEnd2(xml, attributesStart, false);
+      const attributes2 = qtiRootAttributes(xml, attributesStart, end);
+      let insertionPoint = skipXmlWhitespaceBackward(xml, end);
+      if (xml[insertionPoint - 1] === "/") {
+        insertionPoint -= 1;
+      }
+      return { attributes: attributes2, insertionPoint };
+    }
+  }
+  return invalidQtiCopyXml();
 }
-function validateUniqueAssessmentIdentifiers(testIdentifiers) {
-  if (new Set(testIdentifiers).size !== testIdentifiers.length) {
-    throw new ValidationError("Assessment order must contain unique identifiers");
+function skipXmlWhitespaceBackward(xml, start2) {
+  let cursor2 = start2;
+  while (/\s/.test(xml[cursor2 - 1] ?? "")) {
+    cursor2 -= 1;
   }
+  return cursor2;
 }
-function assertAssessmentOrderUpdateSucceeded(updatedRow) {
-  if (!updatedRow) {
-    throw new ValidationError("Assessment order changed while it was being saved. Refresh and try again.");
+function escapeXmlAttribute(value, quote) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(quote, quote === '"' ? "&quot;" : "&apos;");
+}
+function rewriteQtiItemIdentity(xml, identifier, title) {
+  if (!xml.trim() || !identifier.trim() || !title.trim()) {
+    return invalidQtiCopyXml();
   }
-  return updatedRow;
+  const root = qtiItemStartTag(xml);
+  const replacements = [];
+  const targetAttributes = new Map([
+    ["identifier", identifier],
+    ["title", title]
+  ]);
+  for (const [name3, value] of targetAttributes) {
+    const matches = root.attributes.filter((attribute2) => attribute2.name === name3);
+    if (matches.length > 1) {
+      return invalidQtiCopyXml();
+    }
+    const attribute = matches[0];
+    if (attribute) {
+      replacements.push({
+        start: attribute.valueStart,
+        end: attribute.valueEnd,
+        value: escapeXmlAttribute(value, attribute.quote)
+      });
+    } else {
+      replacements.push({
+        start: root.insertionPoint,
+        end: root.insertionPoint,
+        value: ` ${name3}="${escapeXmlAttribute(value, '"')}"`
+      });
+    }
+  }
+  return replacements.toSorted((left, right) => right.start - left.start).reduce((rewritten, replacement) => `${rewritten.slice(0, replacement.start)}${replacement.value}${rewritten.slice(replacement.end)}`, xml);
 }
-function lockOrderAssessmentRows(rows) {
-  return rows.toSorted((left, right) => left.id.localeCompare(right.id));
+function buildQtiQuestionCopyInput(input) {
+  assertPlayableQtiQuestion(input.source);
+  const title = input.source.title?.trim() || input.source.identifier;
+  if (!input.source.rawXml) {
+    return invalidQtiCopyXml();
+  }
+  const sourceMetadata = { ...input.source.metadata };
+  if (sourceMetadata.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    Reflect.deleteProperty(sourceMetadata, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
+  }
+  const metadata2 = buildOwnedQtiQuestionMetadata({
+    metadata: {
+      copiedFromItemIdentifier: input.source.identifier,
+      integrationId: input.integrationId
+    }
+  }, {
+    gameSlug: input.gameSlug,
+    testIdentifier: input.targetTestIdentifier
+  }, sourceMetadata);
+  return {
+    identifier: input.targetIdentifier,
+    title,
+    xml: rewriteQtiItemIdentity(input.source.rawXml, input.targetIdentifier, title),
+    metadata: metadata2
+  };
 }
-function orderLiveAssessmentRows(liveRows, purpose, testIdentifiers) {
-  const rowsByIdentifier = new Map(liveRows.map((row) => [row.qtiTestIdentifier, row]));
-  if (liveRows.length !== testIdentifiers.length || testIdentifiers.some((identifier) => !rowsByIdentifier.has(identifier))) {
-    throw new ValidationError(`Assessment order must include every live ${purpose} assessment exactly once`);
+function assertQtiQuestionEditable(item, ownership, ownerTest) {
+  if (!isQtiQuestionOwnedByContext(item, ownership, ownerTest)) {
+    throw new ValidationError("Shared question references are read-only. Copy the question to create an editable independent item.");
   }
-  return testIdentifiers.map((identifier) => rowsByIdentifier.get(identifier));
 }
-var init_timeback_assessment_rules_util = __esm(() => {
+function buildNumericQuestionXml(input, identifier, title) {
+  if (input.format === "xml") {
+    throw new ValidationError("Raw question XML is not accepted at this API boundary");
+  }
+  const candidate = input.numericTextEntry;
+  if (candidate === undefined) {
+    return null;
+  }
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    throw new ValidationError("Numeric text-entry data is invalid");
+  }
+  const prompt = "prompt" in candidate ? candidate.prompt : undefined;
+  const numeric3 = parseNumericTextEntry({
+    baseType: "baseType" in candidate ? candidate.baseType : undefined,
+    answer: "answer" in candidate ? candidate.answer : undefined,
+    comparison: "comparison" in candidate ? candidate.comparison : undefined
+  });
+  if (!numeric3.success) {
+    throw new ValidationError(numeric3.message);
+  }
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError("Numeric questions require a title and prompt");
+  }
+  return numericTextEntryXml({ identifier, title, prompt: prompt.trim(), numeric: numeric3.value });
+}
+function buildExactMatchQuestionXml(input) {
+  const responseIdentifier = escapeXml(input.responseIdentifier);
+  const correctValues = input.correctIdentifiers.map((identifier) => `      <qti-value>${escapeXml(identifier)}</qti-value>`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<qti-assessment-item xmlns="http://www.imsglobal.org/xsd/imsqtiasi_v3p0" identifier="${escapeXml(input.identifier)}" title="${escapeXml(input.title)}" adaptive="false" time-dependent="false">
+  <qti-response-declaration identifier="${responseIdentifier}" cardinality="${input.cardinality}" base-type="identifier">
+    <qti-correct-response>
+${correctValues}
+    </qti-correct-response>
+  </qti-response-declaration>
+  <qti-outcome-declaration identifier="FEEDBACK" cardinality="single" base-type="identifier" />
+  <qti-outcome-declaration identifier="SCORE" cardinality="single" base-type="float">
+    <qti-default-value><qti-value>0</qti-value></qti-default-value>
+  </qti-outcome-declaration>
+  <qti-item-body>
+${input.itemBody}
+  </qti-item-body>
+  <qti-response-processing>
+    <qti-response-condition>
+      <qti-response-if>
+        <qti-match><qti-variable identifier="${responseIdentifier}" /><qti-correct identifier="${responseIdentifier}" /></qti-match>
+        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">CORRECT</qti-base-value></qti-set-outcome-value>
+        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">1</qti-base-value></qti-set-outcome-value>
+      </qti-response-if>
+      <qti-response-else>
+        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">INCORRECT</qti-base-value></qti-set-outcome-value>
+        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">0</qti-base-value></qti-set-outcome-value>
+      </qti-response-else>
+    </qti-response-condition>
+  </qti-response-processing>
+</qti-assessment-item>`;
+}
+function parseStructuredChoices(value, options) {
+  const { label, minimum, validate: validate2 } = options;
+  if (!Array.isArray(value) || value.length < minimum) {
+    throw new ValidationError(`${label} questions require at least ${minimum === 1 ? "one choice" : `${minimum} choices`}`);
+  }
+  const choices = value.map((choice) => {
+    const record3 = recordValue(choice);
+    const identifier = record3?.identifier;
+    const content = record3?.content;
+    if (typeof identifier !== "string" || !identifier.trim() || typeof content !== "string" || !content.trim() || validate2 !== undefined && record3 !== undefined && !validate2(record3)) {
+      throw new ValidationError(`${label} options are invalid`);
+    }
+    return { identifier: identifier.trim(), content: content.trim() };
+  });
+  if (new Set(choices.map((choice) => choice.identifier)).size !== choices.length) {
+    throw new ValidationError(`${label} option identifiers must be unique`);
+  }
+  return choices;
+}
+function declaredCorrectResponse(input, responseIdentifier) {
+  const declarations = Array.isArray(input.responseDeclarations) ? input.responseDeclarations : [];
+  const declaration = declarations.map(recordValue).find((candidate) => candidate?.identifier === responseIdentifier);
+  const rawValues = recordValue(declaration?.correctResponse)?.value;
+  return {
+    cardinality: declaration?.cardinality,
+    baseType: declaration?.baseType,
+    values: Array.isArray(rawValues) ? rawValues.filter((value) => typeof value === "string") : []
+  };
+}
+function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers) {
+  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
+  if (cardinality !== "single" || baseType !== "identifier") {
+    throw new ValidationError("Inline-choice questions require a single-identifier response declaration");
+  }
+  if (values.length !== 1 || !choiceIdentifiers.has(values[0])) {
+    throw new ValidationError("Inline-choice questions require one valid correct option");
+  }
+  return values[0];
+}
+function structuredQuestionEnvelope(input, type, label, title) {
+  const interaction = recordValue(input.interaction);
+  if (normalizedQtiInteractionType(interaction?.type ?? input.type) !== type) {
+    return null;
+  }
+  const structure = recordValue(interaction?.questionStructure);
+  const responseIdentifier = interaction?.responseIdentifier;
+  const prompt = structure?.prompt;
+  if (!interaction || !structure || typeof responseIdentifier !== "string" || !responseIdentifier.trim()) {
+    throw new ValidationError(`${label} question data is invalid`);
+  }
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError(`${label} questions require a title and prompt`);
+  }
+  return {
+    interaction,
+    structure,
+    responseIdentifier: responseIdentifier.trim(),
+    prompt: prompt.trim()
+  };
+}
+function buildInlineChoiceQuestionXml(input, identifier, title) {
+  const envelope = structuredQuestionEnvelope(input, "inline-choice", "Inline-choice", title);
+  if (!envelope) {
+    return null;
+  }
+  const { 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");
+  }
+  const choices = parseStructuredChoices(structure.inlineChoices, {
+    label: "Inline-choice",
+    minimum: 2
+  });
+  const choiceIdentifiers = new Set(choices.map((choice) => choice.identifier));
+  const correctIdentifier = inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers);
+  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)}">
+${choicesXml}
+      </qti-inline-choice-interaction>${escapeXml(after)}</p>`;
+  return buildExactMatchQuestionXml({
+    identifier,
+    title,
+    responseIdentifier,
+    cardinality: "single",
+    correctIdentifiers: [correctIdentifier],
+    itemBody
+  });
+}
+function parseStructuredMatchChoices(value, label) {
+  return parseStructuredChoices(value, {
+    label: `Match ${label}`,
+    minimum: 1,
+    validate: (choice) => choice.matchMax === 1
+  });
+}
+function structuredMatchCorrectPairs(input, responseIdentifier, sources, targets) {
+  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
+  if (cardinality !== "multiple" || baseType !== "directedPair") {
+    throw new ValidationError("Match questions require a multiple directed-pair response declaration");
+  }
+  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
+  const targetIdentifiers = new Set(targets.map((choice) => choice.identifier));
+  const valid = values.length > 0 && new Set(values).size === values.length && values.every((value) => {
+    const [source, target, extra] = value.split(" ");
+    return extra === undefined && Boolean(source && target) && sourceIdentifiers.has(source) && targetIdentifiers.has(target);
+  });
+  if (!valid) {
+    throw new ValidationError("Every Match correct response must name one declared source and target choice");
+  }
+  return values;
+}
+function buildMatchQuestionXml(input, identifier, title) {
+  const envelope = structuredQuestionEnvelope(input, "match", "Match", title);
+  if (!envelope) {
+    return null;
+  }
+  const { interaction, structure, responseIdentifier, prompt } = envelope;
+  const sources = parseStructuredMatchChoices(structure.sourceChoices, "source");
+  const targets = parseStructuredMatchChoices(structure.targetChoices, "target");
+  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
+  if (targets.some((choice) => sourceIdentifiers.has(choice.identifier))) {
+    throw new ValidationError("Match source and target choice identifiers must be unique");
+  }
+  const correctValues = structuredMatchCorrectPairs(input, responseIdentifier, sources, targets);
+  const maxAssociations = interaction.maxAssociations;
+  if (typeof maxAssociations !== "number" || !Number.isInteger(maxAssociations) || maxAssociations < 0 || maxAssociations !== 0 && maxAssociations < correctValues.length) {
+    throw new ValidationError("Match max associations must fit every correct pair");
+  }
+  const item = {
+    key: identifier,
+    title,
+    body: [
+      {
+        kind: "interaction",
+        type: "match",
+        responseIdentifier,
+        attributes: {
+          shuffle: interaction.shuffle === true,
+          "max-associations": maxAssociations
+        },
+        content: [
+          {
+            kind: "element",
+            name: "qti-prompt",
+            children: [{ kind: "text", text: prompt }]
+          }
+        ],
+        choiceSets: [sources, targets].map((choices) => choices.map((choice) => ({
+          identifier: choice.identifier,
+          content: [{ kind: "text", text: choice.content }]
+        })))
+      }
+    ],
+    responseDeclarations: [
+      {
+        identifier: responseIdentifier,
+        cardinality: "multiple",
+        baseType: "directedPair",
+        correctValues
+      }
+    ]
+  };
+  try {
+    return compileQtiAuthoringItemXml(item, { identifier, title });
+  } catch (error88) {
+    throw new ValidationError(`This Match question cannot be compiled to QTI: ${errorMessage2(error88)}`);
+  }
+}
+function parseHottextSegments2(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new ValidationError("Hottext questions require passage segments");
+  }
+  const segments = value.map((segment) => {
+    const record3 = recordValue(segment);
+    const identifier = record3?.identifier;
+    const content = record3?.content;
+    const mode = record3?.mode;
+    if (typeof identifier !== "string" || typeof content !== "string" || !content.trim() || !["plain", "option", "correct"].includes(String(mode))) {
+      throw new ValidationError("Hottext passage segments are invalid");
+    }
+    return {
+      identifier: identifier.trim(),
+      content: content.trim(),
+      mode
+    };
+  });
+  const selectable = segments.filter((segment) => segment.mode !== "plain");
+  const correct = selectable.filter((segment) => segment.mode === "correct");
+  const identifiers = selectable.map((segment) => segment.identifier);
+  if (selectable.length < 2) {
+    throw new ValidationError("Hottext questions require at least two selectable phrases");
+  }
+  if (identifiers.some((identifier) => !identifier)) {
+    throw new ValidationError("Hottext selectable phrases require identifiers");
+  }
+  if (new Set(identifiers).size !== identifiers.length) {
+    throw new ValidationError("Hottext selectable phrase identifiers must be unique");
+  }
+  if (correct.length === 0) {
+    throw new ValidationError("Hottext questions require a correct phrase");
+  }
+  return { segments, selectable, correct };
+}
+function buildHottextQuestionXml(input, identifier, title) {
+  const candidate = input.hottext;
+  if (candidate === undefined) {
+    return null;
+  }
+  const hottext = recordValue(candidate);
+  if (!hottext) {
+    throw new ValidationError("Hottext question data is invalid");
+  }
+  const prompt = hottext.prompt;
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError("Hottext questions require a title and prompt");
+  }
+  const { segments, selectable, correct } = parseHottextSegments2(hottext.segments);
+  const multiple = correct.length > 1;
+  const maxChoices = hottextMaxChoices(selectable.length, multiple);
+  const passage = segments.map((segment) => segment.mode === "plain" ? escapeXml(segment.content) : `<qti-hottext identifier="${escapeXml(segment.identifier)}">${escapeXml(segment.content)}</qti-hottext>`).join(" ");
+  const itemBody = `    <qti-hottext-interaction response-identifier="RESPONSE" max-choices="${maxChoices}">
+      <qti-prompt>${escapeXml(prompt.trim())}</qti-prompt>
+      <p>${passage}</p>
+    </qti-hottext-interaction>`;
+  return buildExactMatchQuestionXml({
+    identifier,
+    title,
+    responseIdentifier: "RESPONSE",
+    cardinality: multiple ? "multiple" : "single",
+    correctIdentifiers: correct.map((segment) => segment.identifier),
+    itemBody
+  });
+}
+function buildAuthoringDocumentQuestionXml(input, identifier, title) {
+  if (input.type !== AUTHORING_DOCUMENT_QUESTION_TYPE) {
+    return null;
+  }
+  const item = authoringDocumentItem(input.document);
+  if (!title) {
+    throw new ValidationError("Authored questions require a title");
+  }
+  try {
+    return compileQtiAuthoringItemXml(item, { identifier, title });
+  } catch (error88) {
+    throw new ValidationError(`This question cannot be compiled to QTI: ${errorMessage2(error88)}`);
+  }
+}
+function buildQuestionXml(input, identifier, title) {
+  for (const build2 of QUESTION_XML_BUILDERS) {
+    const xml = build2(input, identifier, title);
+    if (xml !== null) {
+      return xml;
+    }
+  }
+  return null;
+}
+function buildCreatedQtiQuestionReference(input) {
+  return {
+    ownership: "owned",
+    reference: {
+      identifier: input.itemIdentifier,
+      href: input.href,
+      testPart: input.partIdentifier,
+      section: input.sectionIdentifier
+    },
+    question: mergeQtiQuestionItem(input.item, input.fallbackItem, input.itemIdentifier, input.metadata)
+  };
+}
+function buildHydratedQtiQuestionReference(input) {
+  const identifier = input.reference.reference.identifier;
+  const ownerGameSlug = resolveQtiQuestionOwnerGameSlug(input.item, input.ownerTest);
+  const authoritativeItem = ownerGameSlug ? {
+    ...input.item,
+    metadata: { ...input.item.metadata, ownerGameSlug }
+  } : input.item;
+  const question = mergeQtiQuestionItem(authoritativeItem, input.reference.question, identifier);
+  return {
+    ...input.reference,
+    ownership: isQtiQuestionOwnedByContext(question, { gameSlug: input.gameSlug, testIdentifier: input.testIdentifier }, input.ownerTest) ? "owned" : "shared",
+    question
+  };
+}
+function isQtiTestOwnedByGame(test, gameSlug) {
+  return test.metadata?.ownerSystem === PLAYCADEMY_QTI_OWNER_SYSTEM && test.metadata.ownerGameSlug === gameSlug;
+}
+function assertQtiTestOwnedByGame(test, gameSlug) {
+  if (!isQtiTestOwnedByGame(test, gameSlug)) {
+    throw new ValidationError("Shared assessment references are read-only. Copy the assessment to create an editable independent test.");
+  }
+}
+function qtiTestParts(test) {
+  const parts2 = test["qti-test-part"];
+  if (!Array.isArray(parts2) || parts2.length === 0) {
+    throw new ValidationError(`Assessment ${test.identifier} has no test parts`);
+  }
+  for (const [partIndex, part] of parts2.entries()) {
+    if (!part || typeof part !== "object" || Array.isArray(part)) {
+      throw new ValidationError(`Assessment ${test.identifier} contains an invalid test part at position ${partIndex + 1}`);
+    }
+    const sections = part["qti-assessment-section"];
+    if (!Array.isArray(sections)) {
+      throw new ValidationError(`Assessment ${test.identifier} test part ${partIndex + 1} has no section list`);
+    }
+  }
+  return parts2;
+}
+function qtiTestOptionalAttributes(test) {
+  return {
+    ...test.qtiVersion ? { qtiVersion: test.qtiVersion } : {},
+    ...test.timeLimit !== undefined ? { timeLimit: test.timeLimit } : {},
+    ...test.maxAttempts !== undefined ? { maxAttempts: test.maxAttempts } : {},
+    ...test.toolsEnabled !== undefined ? { toolsEnabled: test.toolsEnabled } : {}
+  };
+}
+function buildQtiAssessmentItemCopyPlan(test, targetTestIdentifier, hrefForIdentifier, createIdentifier = newPlaycademyQuestionIdentifier) {
+  const sourceIdentifiers = [];
+  const seen = new Set;
+  for (const part of qtiTestParts(test)) {
+    for (const section of part["qti-assessment-section"]) {
+      for (const reference of section["qti-assessment-item-ref"] ?? []) {
+        if (!seen.has(reference.identifier)) {
+          seen.add(reference.identifier);
+          sourceIdentifiers.push(reference.identifier);
+        }
+      }
+    }
+  }
+  return sourceIdentifiers.map((sourceIdentifier) => {
+    const targetIdentifier = createIdentifier(targetTestIdentifier);
+    return {
+      sourceIdentifier,
+      targetIdentifier,
+      href: hrefForIdentifier(targetIdentifier)
+    };
+  });
+}
+function buildQtiTestStructureInput(test, targetTestIdentifier, itemCopies) {
+  const outcomeDeclarations = test["qti-outcome-declaration"];
+  if (outcomeDeclarations !== undefined && !Array.isArray(outcomeDeclarations)) {
+    throw new ValidationError(`Assessment ${test.identifier} has an invalid outcome declaration list`);
+  }
+  return {
+    "qti-test-part": qtiTestParts(test).map((part, partIndex) => ({
+      identifier: targetTestIdentifier ? `${targetTestIdentifier}-part${partIndex + 1}` : part.identifier,
+      navigationMode: part.navigationMode,
+      submissionMode: part.submissionMode,
+      "qti-assessment-section": part["qti-assessment-section"].map((section, sectionIndex) => {
+        let sectionIdentifier = section.identifier;
+        if (targetTestIdentifier) {
+          sectionIdentifier = partIndex === 0 && sectionIndex === 0 ? `${targetTestIdentifier}-section1` : `${targetTestIdentifier}-part${partIndex + 1}-section${sectionIndex + 1}`;
+        }
+        return {
+          identifier: sectionIdentifier,
+          title: section.title,
+          visible: section.visible ?? true,
+          ...section.required !== undefined ? { required: section.required } : {},
+          ...section.fixed !== undefined ? { fixed: section.fixed } : {},
+          sequence: section.sequence ?? sectionIndex + 1,
+          ...section["qti-assessment-item-ref"] ? {
+            "qti-assessment-item-ref": section["qti-assessment-item-ref"].map((item, itemIndex) => {
+              const copy = itemCopies?.get(item.identifier);
+              if (itemCopies && !copy) {
+                throw new ValidationError(`Assessment copy is missing question ${item.identifier}`);
+              }
+              return {
+                identifier: copy?.targetIdentifier ?? item.identifier,
+                href: copy?.href ?? item.href,
+                sequence: item.sequence ?? itemIndex + 1
+              };
+            })
+          } : {}
+        };
+      })
+    })),
+    ...outcomeDeclarations ? {
+      "qti-outcome-declaration": outcomeDeclarations.map((declaration) => ({
+        identifier: declaration.identifier,
+        ...declaration.cardinality !== undefined ? { cardinality: declaration.cardinality } : {},
+        baseType: declaration.baseType,
+        ...declaration.normalMaximum !== undefined ? { normalMaximum: declaration.normalMaximum } : {},
+        ...declaration.normalMinimum !== undefined ? { normalMinimum: declaration.normalMinimum } : {},
+        ...declaration.defaultValue ? {
+          defaultValue: declaration.defaultValue.value !== undefined ? { value: declaration.defaultValue.value } : {}
+        } : {}
+      }))
+    } : {}
+  };
+}
+function buildQtiTestUpdateInput(test, title) {
+  return {
+    title,
+    ...qtiTestOptionalAttributes(test),
+    ...test.metadata ? { metadata: test.metadata } : {},
+    ...buildQtiTestStructureInput(test)
+  };
+}
+function buildQtiTestCopyInput(source, targetTestIdentifier, metadata2, itemCopies) {
+  const copiesBySourceIdentifier = new Map(itemCopies.map((copy) => [copy.sourceIdentifier, copy]));
+  return {
+    identifier: targetTestIdentifier,
+    title: `${source.title} (copy)`,
+    ...qtiTestOptionalAttributes(source),
+    metadata: metadata2,
+    ...buildQtiTestStructureInput(source, targetTestIdentifier, copiesBySourceIdentifier)
+  };
+}
+function validateUniqueQuestionIdentifiers(itemIdentifiers) {
+  if (itemIdentifiers.length === 0 || new Set(itemIdentifiers).size !== itemIdentifiers.length) {
+    throw new ValidationError("Question order must contain unique question identifiers");
+  }
+}
+function resolveQtiQuestionSection(test, qtiTestIdentifier, itemIdentifier, expectedItemIdentifiers) {
+  let selectedPart;
+  let selectedSection;
+  for (const part of qtiTestParts(test)) {
+    for (const section of part["qti-assessment-section"]) {
+      if (!itemIdentifier || section["qti-assessment-item-ref"]?.some((item) => item.identifier === itemIdentifier)) {
+        selectedPart = part;
+        selectedSection = section;
+        break;
+      }
+    }
+    if (selectedSection) {
+      break;
+    }
+  }
+  if (!selectedPart || !selectedSection) {
+    throw new ValidationError(itemIdentifier ? `Question ${itemIdentifier} is not referenced by assessment ${qtiTestIdentifier}` : `Assessment ${qtiTestIdentifier} has no section for questions`);
+  }
+  if (expectedItemIdentifiers) {
+    const sectionIdentifiers = selectedSection["qti-assessment-item-ref"]?.map((item) => item.identifier) ?? [];
+    const expectedIdentifiers = new Set(expectedItemIdentifiers);
+    if (expectedIdentifiers.size !== sectionIdentifiers.length || sectionIdentifiers.some((identifier) => !expectedIdentifiers.has(identifier))) {
+      throw new ValidationError("Questions can only be reordered within one complete assessment section");
+    }
+  }
+  return {
+    partIdentifier: selectedPart.identifier,
+    sectionIdentifier: selectedSection.identifier
+  };
+}
+var PLAYCADEMY_QTI_AUTHORING_METADATA_KEY = "playcademyAuthoring";
+var AUTHORING_DOCUMENT_QUESTION_TYPE = "authoring-document";
+var QTI_AUTHORING_FIELDS;
+var QUESTION_XML_BUILDERS;
+var init_timeback_qti_authoring_util = __esm(() => {
+  init_qti();
+  init_timeback3();
   init_errors2();
+  QTI_AUTHORING_FIELDS = [
+    "type",
+    "document",
+    "qtiVersion",
+    "timeDependent",
+    "adaptive",
+    "preInteraction",
+    "interaction",
+    "postInteraction",
+    "responseDeclarations",
+    "outcomeDeclarations",
+    "responseProcessing",
+    "modalFeedback",
+    "feedbackInline",
+    "feedbackBlock",
+    "rubrics",
+    "stimulus",
+    "content"
+  ];
+  QUESTION_XML_BUILDERS = [
+    buildNumericQuestionXml,
+    buildAuthoringDocumentQuestionXml,
+    buildHottextQuestionXml,
+    buildInlineChoiceQuestionXml,
+    buildMatchQuestionXml
+  ];
 });
 function stageAssessmentAttemptSupersession(attempt) {
   Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
@@ -124910,6 +125769,427 @@ var init_timeback_assessment_runtime_util = __esm(() => {
   init_errors2();
   PLAYABLE_SHAPE_SET = new Set(PLAYABLE_ASSESSMENT_SHAPES);
 });
+function reviewMappingIssueSummary(label, identifiers) {
+  if (identifiers.length === 0) {
+    return null;
+  }
+  const displayed = identifiers.slice(0, 10).join(", ");
+  const remainder = identifiers.length > 10 ? `, and ${identifiers.length - 10} more` : "";
+  return `${label} (${identifiers.length}): ${displayed}${remainder}`;
+}
+async function prepareReviewMappingUpdate(test, questions) {
+  const contentRevision = await assessmentContentRevision(test, questions);
+  const assessment = {
+    identifier: test.identifier,
+    contractVersion: 1,
+    contentRevision,
+    title: test.title,
+    items: questions.questions.map(({ question }) => ({
+      identifier: question.identifier,
+      title: question.title,
+      prompt: "",
+      maxScore: 1,
+      interactions: []
+    }))
+  };
+  const bank = await buildReviewBankIndex(assessment, questions, { customOnly: true });
+  const issues = reviewBankMappingIssues(bank);
+  if (issues.missingOrInvalidItemIdentifiers.length > 0 || issues.multipleStandardItemIdentifiers.length > 0) {
+    const details = [
+      reviewMappingIssueSummary("missing or invalid associations", issues.missingOrInvalidItemIdentifiers),
+      reviewMappingIssueSummary("multiple associations", issues.multipleStandardItemIdentifiers)
+    ].filter((detail) => detail !== null);
+    throw new ValidationError(`Every review question must have exactly one valid standard/node association. ${details.join("; ")}.`);
+  }
+  const manifest = await buildReviewBankManifest(bank);
+  return {
+    update: {
+      ...buildQtiTestUpdateInput(test, test.title),
+      metadata: {
+        ...test.metadata,
+        [PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY]: manifest
+      }
+    },
+    summary: {
+      itemCount: bank.items.length,
+      standardCount: Object.keys(manifest.itemsByStandard).length,
+      sourceFingerprint: manifest.sourceFingerprint
+    }
+  };
+}
+var init_timeback_review_mapping_util = __esm(() => {
+  init_assessment_runtime2();
+  init_errors2();
+  init_timeback_assessment_runtime_util();
+  init_timeback_qti_authoring_util();
+});
+function assessmentKeyFromManagedQtiIdentifier(identifier) {
+  const assessmentKey = /^playcademy-test\.(.+)\.[a-f0-9]{64}$/.exec(identifier)?.[1];
+  return assessmentKey && AssessmentKeySchema.safeParse(assessmentKey).success ? assessmentKey : null;
+}
+function assertManagedAssessmentIdentity(test, assessmentKey) {
+  const managed = managedMetadataRecord(test.metadata, PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY);
+  const sourceHash = managed?.sourceHash;
+  const publicationHash = managed?.publicationHash;
+  const hashPattern = /^[a-f0-9]{64}$/;
+  if (managed?.version !== 1 || managed.assessmentKey !== assessmentKey || typeof sourceHash !== "string" || !hashPattern.test(sourceHash) || typeof publicationHash !== "string" || !hashPattern.test(publicationHash) || test.identifier !== `playcademy-test.${assessmentKey}.${publicationHash}`) {
+    throw new ValidationError(`QTI assessment ${test.identifier} is not a managed publication for ${assessmentKey}`);
+  }
+}
+function canonicalManagedAssetUrls(source) {
+  return source.replace(MANAGED_ASSET_URL, `${CANONICAL_ASSESSMENT_ASSET_ORIGIN}/$1`);
+}
+function declarationNeutralQtiXml(source) {
+  return source.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).replace(/^\s*<\?xml\b[^?]*\?>\s*/i, "");
+}
+function managedMetadataRecord(metadata2, key) {
+  const managed = metadata2?.[key];
+  return isRecord5(managed) ? managed : null;
+}
+function sourceMetadata(metadata2) {
+  return Object.fromEntries(Object.entries(metadata2 ?? {}).filter(([key]) => !GENERATED_METADATA_KEYS.has(key)));
+}
+function normalizedQtiItemSource(item) {
+  if (!item.rawXml?.trim()) {
+    throw new ValidationError(`Question ${item.identifier} has no authoritative QTI XML`);
+  }
+  const title = item.title?.trim() || item.identifier;
+  const declarationNeutralXml = declarationNeutralQtiXml(item.rawXml);
+  const identityNeutralXml = rewriteQtiItemIdentity(declarationNeutralXml, "playcademy-item.content", title);
+  return identityNeutralXml.replace(MANAGED_ASSET_URL, "playcademy-asset://$1").trim();
+}
+function testOptionalAttributes(test) {
+  return {
+    ...test.qtiVersion ? { qtiVersion: test.qtiVersion } : {},
+    ...test.timeLimit !== undefined ? { timeLimit: test.timeLimit } : {},
+    ...test.maxAttempts !== undefined ? { maxAttempts: test.maxAttempts } : {},
+    ...test.toolsEnabled !== undefined ? { toolsEnabled: test.toolsEnabled } : {}
+  };
+}
+function normalizedTestStructure(test, itemIdentity) {
+  const structure = buildQtiTestStructureInput(test);
+  return {
+    "qti-test-part": structure["qti-test-part"].map((part) => ({
+      navigationMode: part.navigationMode,
+      submissionMode: part.submissionMode,
+      "qti-assessment-section": part["qti-assessment-section"].map((section) => ({
+        title: section.title,
+        visible: section.visible,
+        ...section.required !== undefined ? { required: section.required } : {},
+        ...section.fixed !== undefined ? { fixed: section.fixed } : {},
+        sequence: section.sequence,
+        ..."qti-assessment-item-ref" in section && section["qti-assessment-item-ref"] ? {
+          "qti-assessment-item-ref": section["qti-assessment-item-ref"].map((item) => {
+            const identity = itemIdentity.get(item.identifier);
+            if (!identity) {
+              throw new ValidationError(`Assessment ${test.identifier} references unavailable question ${item.identifier}`);
+            }
+            return { identity, sequence: item.sequence };
+          })
+        } : {}
+      }))
+    })),
+    ..."qti-outcome-declaration" in structure ? { "qti-outcome-declaration": structure["qti-outcome-declaration"] } : {}
+  };
+}
+function remapDiagnosticRouting(manifest, itemIdentity) {
+  if (!manifest) {
+    return null;
+  }
+  return {
+    ...manifest,
+    nodes: manifest.nodes.map((node) => {
+      const itemIdentifier = itemIdentity.get(node.itemIdentifier);
+      if (!itemIdentifier) {
+        throw new ValidationError(`Diagnostic routing node ${node.key} references unavailable question ${node.itemIdentifier}`);
+      }
+      return { ...node, itemIdentifier };
+    })
+  };
+}
+function canonicalManagedAssessmentArtifact(test) {
+  const structure = buildQtiTestStructureInput(test);
+  const physicalItemIdentity = new Map;
+  for (const part of structure["qti-test-part"]) {
+    for (const section of part["qti-assessment-section"]) {
+      for (const reference of section["qti-assessment-item-ref"] ?? []) {
+        physicalItemIdentity.set(reference.identifier, reference.identifier);
+      }
+    }
+  }
+  return canonicalJson2({
+    title: test.title,
+    ...testOptionalAttributes(test),
+    metadata: sourceMetadata(test.metadata),
+    structure: normalizedTestStructure(test, physicalItemIdentity)
+  });
+}
+async function prepareManagedAssessmentPublication(input) {
+  const parsedKey = AssessmentKeySchema.safeParse(input.assessmentKey);
+  if (!parsedKey.success) {
+    throw new ValidationError(parsedKey.error.issues[0]?.message ?? "Invalid assessment key");
+  }
+  const assessmentKey = parsedKey.data;
+  const items = await Promise.all(input.questions.questions.map(async ({ question }) => {
+    const metadata2 = sourceMetadata(question.metadata);
+    const normalizedSource = normalizedQtiItemSource(question);
+    const contentHash = await sha256Hex(canonicalJson2({ version: 1, xml: normalizedSource, metadata: metadata2 }));
+    const qtiItemIdentifier = `playcademy-item.${contentHash}`;
+    const title = question.title?.trim() || question.identifier;
+    return {
+      sourceItemIdentifier: question.identifier,
+      qtiItemIdentifier,
+      contentHash,
+      xml: canonicalManagedAssetUrls(rewriteQtiItemIdentity(declarationNeutralQtiXml(question.rawXml), qtiItemIdentifier, title)),
+      metadata: {
+        ...metadata2,
+        ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+        [PLAYCADEMY_MANAGED_ITEM_METADATA_KEY]: { version: 1, contentHash }
+      }
+    };
+  }));
+  const itemBySource = new Map(items.map((item) => [item.sourceItemIdentifier, item]));
+  const contentHashBySource = new Map([...itemBySource].map(([source, item]) => [source, item.contentHash]));
+  const qtiIdentifierBySource = new Map([...itemBySource].map(([source, item]) => [source, item.qtiItemIdentifier]));
+  const normalizedRouting = remapDiagnosticRouting(input.diagnosticRoutingManifest, contentHashBySource);
+  const sourceHash = await sha256Hex(canonicalJson2({
+    version: 1,
+    title: input.test.title,
+    ...testOptionalAttributes(input.test),
+    metadata: sourceMetadata(input.test.metadata),
+    structure: normalizedTestStructure(input.test, contentHashBySource),
+    diagnosticRoutingManifest: normalizedRouting
+  }));
+  const compiledRouting = remapDiagnosticRouting(input.diagnosticRoutingManifest, qtiIdentifierBySource);
+  const publicationHash = await sha256Hex(canonicalJson2({
+    version: 1,
+    sourceHash,
+    itemIdentifiers: items.map((item) => item.qtiItemIdentifier),
+    structure: normalizedTestStructure(input.test, qtiIdentifierBySource),
+    diagnosticRoutingManifest: compiledRouting
+  }));
+  const qtiTestIdentifier = `playcademy-test.${assessmentKey}.${publicationHash}`;
+  const copiesBySource = new Map(items.map((item) => [
+    item.sourceItemIdentifier,
+    {
+      sourceIdentifier: item.sourceItemIdentifier,
+      targetIdentifier: item.qtiItemIdentifier,
+      href: input.itemHref(item.qtiItemIdentifier)
+    }
+  ]));
+  let testInput = {
+    identifier: qtiTestIdentifier,
+    title: input.test.title,
+    ...testOptionalAttributes(input.test),
+    metadata: {
+      ...sourceMetadata(input.test.metadata),
+      ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+      [PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY]: {
+        version: 1,
+        assessmentKey,
+        sourceHash,
+        publicationHash,
+        ...compiledRouting ? { diagnosticRoutingManifest: compiledRouting } : {}
+      }
+    },
+    ...buildQtiTestStructureInput(input.test, qtiTestIdentifier, copiesBySource)
+  };
+  const physicalQuestions = {
+    ...input.questions,
+    assessmentTest: qtiTestIdentifier,
+    questions: input.questions.questions.map((entry2) => {
+      const item = itemBySource.get(entry2.question.identifier);
+      return {
+        reference: {
+          ...entry2.reference,
+          identifier: item.qtiItemIdentifier,
+          href: input.itemHref(item.qtiItemIdentifier)
+        },
+        question: {
+          ...entry2.question,
+          identifier: item.qtiItemIdentifier,
+          rawXml: item.xml,
+          metadata: item.metadata
+        }
+      };
+    })
+  };
+  try {
+    const prepared = await prepareReviewMappingUpdate(testInput, physicalQuestions);
+    testInput = { identifier: qtiTestIdentifier, ...prepared.update };
+  } catch (error88) {
+    if (input.purpose === "review" || !(error88 instanceof ValidationError)) {
+      throw error88;
+    }
+  }
+  return {
+    assessmentKey,
+    sourceHash,
+    publicationHash,
+    qtiTestIdentifier,
+    testInput,
+    items,
+    diagnosticRoutingManifest: compiledRouting
+  };
+}
+function assertManagedAssessmentPublication(test, expected) {
+  const managed = managedMetadataRecord(test.metadata, PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY);
+  if (test.identifier !== expected.qtiTestIdentifier || !managed || managed.assessmentKey !== expected.assessmentKey || managed.sourceHash !== expected.sourceHash || managed.publicationHash !== expected.publicationHash || canonicalJson2(managed.diagnosticRoutingManifest ?? null) !== canonicalJson2(expected.diagnosticRoutingManifest) || canonicalManagedAssessmentArtifact(test) !== canonicalManagedAssessmentArtifact(expected.testInput)) {
+    throw new ValidationError(`QTI identifier collision for managed assessment ${expected.assessmentKey}`);
+  }
+}
+function managedAssessmentDiagnosticRoutingManifest(test, assessmentKey) {
+  const managed = managedMetadataRecord(test.metadata, PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY);
+  const manifest = managed?.diagnosticRoutingManifest;
+  return managed?.assessmentKey === assessmentKey && isRecord5(manifest) ? manifest : null;
+}
+async function assertManagedAssessmentItem(item, expected) {
+  const managed = managedMetadataRecord(item.metadata, PLAYCADEMY_MANAGED_ITEM_METADATA_KEY);
+  const actualHash = await sha256Hex(canonicalJson2({
+    version: 1,
+    xml: normalizedQtiItemSource(item),
+    metadata: sourceMetadata(item.metadata)
+  }));
+  if (item.identifier !== expected.qtiItemIdentifier || actualHash !== expected.contentHash || managed?.contentHash !== expected.contentHash) {
+    throw new ValidationError(`QTI identifier collision for item ${expected.qtiItemIdentifier}`);
+  }
+}
+var PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY = "playcademyManagedAssessment";
+var PLAYCADEMY_MANAGED_ITEM_METADATA_KEY = "playcademyManagedItem";
+var GENERATED_METADATA_KEYS;
+var MANAGED_ASSET_URL;
+var CANONICAL_ASSESSMENT_ASSET_ORIGIN = "https://cdn.playcademy.net";
+var init_timeback_assessment_publication_util = __esm(() => {
+  init_src();
+  init_schemas_index();
+  init_assessment_runtime2();
+  init_timeback3();
+  init_errors2();
+  init_timeback_qti_authoring_util();
+  init_timeback_review_mapping_util();
+  init_timeback_util();
+  GENERATED_METADATA_KEYS = new Set([
+    PLAYCADEMY_QTI_AUTHORING_METADATA_KEY,
+    PLAYCADEMY_QTI_EDITOR_MODE_KEY,
+    PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY,
+    PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY,
+    PLAYCADEMY_MANAGED_ASSESSMENT_METADATA_KEY,
+    PLAYCADEMY_MANAGED_ITEM_METADATA_KEY,
+    "copiedFromItemIdentifier",
+    "copiedFromTestIdentifier",
+    "integrationId",
+    "ownerGameSlug",
+    "ownerSystem",
+    "sourceIdentifier"
+  ]);
+  MANAGED_ASSET_URL = new RegExp(`https?://[^\\s"')]+/(${ASSESSMENT_ASSET_KEY_PREFIX}v1/sha256/[a-f0-9]{64}\\.[a-z0-9]+)`, "gi");
+});
+function validateAssessmentStatusTransition(current, next) {
+  if (current === next) {
+    return;
+  }
+  const allowed = current === "draft" && next === "live" || current === "live" && next === "archived" || current === "archived" && next === "live";
+  if (!allowed) {
+    throw new ValidationError(`Assessment status cannot change from ${current} to ${next}`);
+  }
+}
+function isAssessmentPublicationTransition(current, next) {
+  return current !== "live" && next === "live";
+}
+function assertDraftAssessment(row) {
+  if (row.status !== "draft") {
+    throw new ValidationError("Only draft assessments can change QTI content or question membership");
+  }
+}
+function assertPurposeChangeDraft(row, nextPurpose) {
+  if (row.purpose !== nextPurpose && row.status !== "draft") {
+    throw new ValidationError("Only draft assessments can change purpose");
+  }
+}
+function diagnosticDefinitionForRow(row) {
+  return row.diagnosticKey && row.diagnosticRoutingManifest ? {
+    diagnosticKey: row.diagnosticKey,
+    routingManifest: row.diagnosticRoutingManifest
+  } : null;
+}
+function assertAllAssessmentAssociationsDraft(rows) {
+  if (rows.some((row) => row.status !== "draft")) {
+    throw new ValidationError("QTI content cannot change while any associated assessment is live or archived");
+  }
+}
+function assertAssessmentHasQuestions(questions) {
+  if (questions.length === 0) {
+    throw new ValidationError("An assessment must contain at least one question to publish");
+  }
+}
+function assertReviewAssessmentHasStandards(standardCounts) {
+  if (standardCounts.some((count) => count !== 1)) {
+    throw new ValidationError("Every question in a review assessment must have exactly one standards alignment");
+  }
+}
+function planAssessmentRemoval(status) {
+  if (status === "draft") {
+    return { kind: "delete", action: "discarded", operation: "discard_draft" };
+  }
+  if (status === "live") {
+    return { kind: "archive", action: "archived", operation: "archive" };
+  }
+  return { kind: "none", action: "archived" };
+}
+function buildAssessmentAssociationUpdates(row, input) {
+  const updates = {};
+  if (input.purpose !== undefined) {
+    updates.purpose = input.purpose;
+    if (input.purpose !== "mastery" && (row.purpose === "mastery" || row.standardFramework || row.standardIdentifier)) {
+      updates.standardFramework = null;
+      updates.standardIdentifier = null;
+    }
+    if (row.status === "live" && input.purpose !== row.purpose) {
+      updates.sortOrder = null;
+    }
+  }
+  if (input.standard !== undefined) {
+    updates.standardFramework = input.standard.framework;
+    updates.standardIdentifier = input.standard.identifier;
+  }
+  if (input.status !== undefined) {
+    updates.status = input.status;
+    if (input.status === "archived") {
+      updates.sortOrder = null;
+    }
+  }
+  return updates;
+}
+function assessmentStandardForRow(row) {
+  return row.standardFramework && row.standardIdentifier ? { framework: row.standardFramework, identifier: row.standardIdentifier } : null;
+}
+function validateUniqueAssessmentIdentifiers(testIdentifiers) {
+  if (new Set(testIdentifiers).size !== testIdentifiers.length) {
+    throw new ValidationError("Assessment order must contain unique identifiers");
+  }
+}
+function assertAssessmentOrderUpdateSucceeded(updatedRow) {
+  if (!updatedRow) {
+    throw new ValidationError("Assessment order changed while it was being saved. Refresh and try again.");
+  }
+  return updatedRow;
+}
+function lockOrderAssessmentRows(rows) {
+  return rows.toSorted((left, right) => left.id.localeCompare(right.id));
+}
+function orderLiveAssessmentRows(liveRows, purpose, testIdentifiers) {
+  const rowsByIdentifier = new Map(liveRows.map((row) => [row.qtiTestIdentifier, row]));
+  if (liveRows.length !== testIdentifiers.length || testIdentifiers.some((identifier) => !rowsByIdentifier.has(identifier))) {
+    throw new ValidationError(`Assessment order must include every live ${purpose} assessment exactly once`);
+  }
+  return testIdentifiers.map((identifier) => rowsByIdentifier.get(identifier));
+}
+var init_timeback_assessment_rules_util = __esm(() => {
+  init_errors2();
+});
 async function hydrateQtiTestQuestions(client2, references) {
   const questions = await runWithConcurrency(references.questions, QTI_HYDRATION_CONCURRENCY, async (reference) => ({
     ...reference,
@@ -125052,6 +126332,7 @@ class TimebackAssessmentRuntimeService {
         integrationId: context2.integration.id,
         enrollmentId: context2.enrollment.id,
         selectedTest: {
+          assessmentKey: decision.test.assessmentKey,
           identifier: assessment.identifier,
           contentRevision: assessment.contentRevision
         },
@@ -125169,6 +126450,7 @@ class TimebackAssessmentRuntimeService {
         integrationId: context2.integration.id,
         enrollmentId: context2.enrollment.id,
         selectedTest: {
+          assessmentKey: definition.assessmentKey,
           identifier: assessment.identifier,
           contentRevision: assessment.contentRevision
         },
@@ -125310,6 +126592,7 @@ class TimebackAssessmentRuntimeService {
         integrationId: context2.integration.id,
         enrollmentId: context2.enrollment.id,
         selectedTest: {
+          assessmentKey: decision.test.assessmentKey,
           identifier: source.assessment.identifier,
           contentRevision: source.assessment.contentRevision
         },
@@ -126153,7 +127436,7 @@ class TimebackAssessmentRuntimeService {
     });
     const catalogs = loadedCatalogs.filter((catalog) => catalog !== null);
     return {
-      version: 6,
+      version: ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION,
       gameId,
       exportedAt: new Date().toISOString(),
       catalogs
@@ -126187,7 +127470,7 @@ class TimebackAssessmentRuntimeService {
     const enrollmentByCourse = new Map(enrollments.map((enrollment) => [enrollment.course.id, enrollment]));
     const candidateRows = integrations.filter((integration) => enrollmentByCourse.has(integration.courseId));
     const liveTestRows = candidateRows.length === 0 ? [] : await db2.query.gameTimebackAssessmentTests.findMany({
-      where: and(inArray(gameTimebackAssessmentTests.integrationId, candidateRows.map((row) => row.id)), eq(gameTimebackAssessmentTests.purpose, input.purpose), eq(gameTimebackAssessmentTests.status, "live")),
+      where: and(inArray(gameTimebackAssessmentTests.integrationId, candidateRows.map((row) => row.id)), eq(gameTimebackAssessmentTests.purpose, input.purpose), eq(gameTimebackAssessmentTests.status, "live"), isNotNull(gameTimebackAssessmentTests.assessmentKey)),
       columns: {
         integrationId: true,
         standardFramework: true,
@@ -126243,10 +127526,11 @@ class TimebackAssessmentRuntimeService {
   async liveTests(integrationId, purpose, db2 = this.deps.db, requestedStandard, requestedDiagnosticKey) {
     const matchesMasteryStandard = requestedStandard ? masteryStandardMatcher(requestedStandard) : undefined;
     const rows = await db2.query.gameTimebackAssessmentTests.findMany({
-      where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.purpose, purpose), eq(gameTimebackAssessmentTests.status, "live"))
+      where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.purpose, purpose), eq(gameTimebackAssessmentTests.status, "live"), isNotNull(gameTimebackAssessmentTests.assessmentKey))
     });
     return rows.filter((row) => purpose !== "diagnostic" || requestedDiagnosticKey === undefined || row.diagnosticKey === requestedDiagnosticKey).map((row) => ({
       id: row.id,
+      assessmentKey: row.assessmentKey,
       qtiTestIdentifier: row.qtiTestIdentifier,
       sortOrder: row.sortOrder,
       updatedAt: row.updatedAt.toISOString(),
@@ -126288,19 +127572,23 @@ class TimebackAssessmentRuntimeService {
         reviewChildren.set(result.sourcedId, result);
       }
       if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && metadata2.courseId === scope.courseId && metadata2.integrationId === scope.integrationId && result.student.sourcedId === scope.studentId) {
-        attempts.set(result.sourcedId, {
-          result,
-          metadata: metadata2,
-          selection: {
-            attemptId: result.sourcedId,
-            selectedTestIdentifier: metadata2.selectedTest.identifier,
-            inProgress: result.inProgress ?? "",
-            scoreStatus: result.scoreStatus,
-            scoreDate: result.scoreDate,
-            updatedAt: result.dateLastModified ?? metadata2.updatedAt,
-            resumable: metadata2.enrollmentId === scope.enrollmentId
-          }
-        });
+        const selectedAssessmentKey = metadata2.selectedTest.assessmentKey ?? assessmentKeyFromManagedQtiIdentifier(metadata2.selectedTest.identifier);
+        if (selectedAssessmentKey) {
+          attempts.set(result.sourcedId, {
+            result,
+            metadata: metadata2,
+            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
+            }
+          });
+        }
       }
     }
     return { attempts, reviewChildren };
@@ -126577,14 +127865,23 @@ class TimebackAssessmentRuntimeService {
   isPlatformRoutedDiagnosticMetadata(metadata2) {
     return metadata2.purpose === "diagnostic" && metadata2.diagnostic !== undefined;
   }
-  async requireDiagnosticDefinition(definitionId, integrationId, db2 = this.deps.db, requireLive = false) {
+  async requireDiagnosticDefinition(definitionId, integrationId, db2 = this.deps.db, requireLive = false, pinnedQtiTestIdentifier) {
     const row = await db2.query.gameTimebackAssessmentTests.findFirst({
       where: and(eq(gameTimebackAssessmentTests.id, definitionId), eq(gameTimebackAssessmentTests.integrationId, integrationId))
     });
-    if (!row || row.purpose !== "diagnostic" || requireLive && row.status !== "live" || !row.diagnosticKey || !row.diagnosticRoutingManifest) {
+    if (!row || row.purpose !== "diagnostic" || requireLive && row.status !== "live" || !row.assessmentKey || !row.diagnosticKey) {
       throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `The selected diagnostic definition ${definitionId} is unavailable.`, { definitionId });
     }
-    return row;
+    const requestedQtiTestIdentifier = pinnedQtiTestIdentifier ?? row.qtiTestIdentifier;
+    const pinnedManifest = requestedQtiTestIdentifier === row.qtiTestIdentifier ? row.diagnosticRoutingManifest : managedAssessmentDiagnosticRoutingManifest(await this.requireClient().qtiApi.assessmentTests.get(requestedQtiTestIdentifier), row.assessmentKey);
+    if (!pinnedManifest) {
+      throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `The pinned diagnostic publication for ${definitionId} is unavailable.`, { definitionId, pinnedQtiTestIdentifier });
+    }
+    return {
+      ...row,
+      qtiTestIdentifier: requestedQtiTestIdentifier,
+      diagnosticRoutingManifest: pinnedManifest
+    };
   }
   async initializeHostedDiagnostic(definition, assessment) {
     const initialized = await this.initializeHostedDiagnosticManifest(definition);
@@ -126618,7 +127915,7 @@ class TimebackAssessmentRuntimeService {
     };
   }
   async loadAttemptDiagnosticManifest(metadata2, db2 = this.deps.db) {
-    const definition = await this.requireDiagnosticDefinition(metadata2.diagnostic.definitionId, metadata2.integrationId, db2);
+    const definition = await this.requireDiagnosticDefinition(metadata2.diagnostic.definitionId, metadata2.integrationId, db2, false, metadata2.selectedTest.identifier);
     const initialized = await this.initializeHostedDiagnosticManifest(definition);
     if (definition.qtiTestIdentifier !== metadata2.selectedTest.identifier || definition.diagnosticKey !== metadata2.diagnostic.diagnosticKey || initialized.routingRevision !== metadata2.diagnostic.routingRevision) {
       throw new AssessmentRuntimeError("SELECTED_TEST_VERSION_UNAVAILABLE", `The pinned definition for diagnostic ${metadata2.diagnostic.diagnosticKey} no longer matches the attempt.`, { definitionId: metadata2.diagnostic.definitionId });
@@ -127493,6 +128790,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   init_uuid();
   init_errors2();
   init_assessment_runtime_lock_util();
+  init_timeback_assessment_publication_util();
   init_timeback_assessment_rules_util();
   init_timeback_assessment_runtime_util();
   init_timeback_qti_hydration_util();
@@ -127501,947 +128799,49 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     init_errors8()
   ]);
 });
-function recordValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function persistableAuthoringDocument(value) {
-  const document2 = recordValue(value);
-  const item = recordValue(document2?.item);
-  if (!document2 || !item) {
-    return;
-  }
-  const persistableItem = { ...item };
-  Reflect.deleteProperty(persistableItem, "metadata");
-  return { ...document2, item: persistableItem };
-}
-function qtiAuthoringSnapshot(input) {
-  const document2 = persistableAuthoringDocument(input.document);
-  if (!recordValue(input.interaction) && !document2) {
-    return;
-  }
-  return Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => {
-    if (field === "document") {
-      return document2 ? [[field, document2]] : [];
-    }
-    return input[field] === undefined ? [] : [[field, input[field]]];
+function diagnosticRoutingCapabilities(assessment, scoring) {
+  return assessment.items.map((item) => ({
+    itemIdentifier: item.identifier,
+    supportsDeterminateBinaryGrading: item.interactions.length > 0 && item.interactions.every((interaction) => {
+      const responseIdentifier = interaction.responseIdentifier;
+      return Object.hasOwn(scoring.correctResponses[item.identifier] ?? {}, responseIdentifier) || (scoring.responseAreas?.[item.identifier]?.[responseIdentifier]?.length ?? 0) > 0;
+    })
   }));
 }
-function buildOwnedQtiQuestionMetadata(input, ownership, existingMetadata = {}) {
-  const inputMetadata = recordValue(input.metadata) ?? {};
-  const metadata2 = {
-    ...existingMetadata,
-    ...inputMetadata
-  };
-  const existingAuthoring = recordValue(existingMetadata[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
-  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
-  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_EDITOR_MODE_KEY);
-  const authoring = qtiAuthoringSnapshot(input);
-  const shouldReplaceAuthoring = "interaction" in input || "numericTextEntry" in input || "document" in input;
-  const persistedAuthoring = authoring ?? (shouldReplaceAuthoring ? undefined : existingAuthoring);
-  return {
-    ...metadata2,
-    ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
-    ownerGameSlug: ownership.gameSlug,
-    [PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]: ownership.testIdentifier,
-    ...persistedAuthoring ? { [PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]: persistedAuthoring } : {}
-  };
-}
-function restoreQtiQuestionAuthoringData(item) {
-  const authoring = recordValue(item.metadata?.[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
-  if (!authoring) {
-    return item;
-  }
-  const restored = Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => authoring[field] === undefined ? [] : [[field, authoring[field]]]));
-  return { ...item, ...restored };
-}
-function mergeQtiQuestionItem(item, fallbackItem, itemIdentifier, metadata2) {
-  return restoreQtiQuestionAuthoringData({
-    ...fallbackItem,
-    ...item,
-    identifier: itemIdentifier,
-    title: item.title || fallbackItem?.title || itemIdentifier,
-    type: item.type ?? fallbackItem?.type,
-    rawXml: item.rawXml ?? fallbackItem?.rawXml,
-    interaction: item.interaction ?? fallbackItem?.interaction,
-    responseDeclarations: item.responseDeclarations ?? fallbackItem?.responseDeclarations,
-    metadata: {
-      ...fallbackItem?.metadata,
-      ...item.metadata,
-      ...metadata2
-    }
-  });
-}
-function newPlaycademyQuestionIdentifier(testIdentifier) {
-  return `${testIdentifier}-q${crypto.randomUUID().slice(0, 8)}`;
-}
-function parseQtiQuestionCreationInput(input) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new ValidationError("Question creation input must be an object");
-  }
-  const rawInput = input;
-  if (rawInput.mode === undefined) {
-    return { kind: "authoring", input: rawInput };
-  }
-  if (rawInput.mode !== "copy") {
-    throw new ValidationError("Question creation mode is invalid");
-  }
-  const sourceItemIdentifier = typeof rawInput.sourceItemIdentifier === "string" ? rawInput.sourceItemIdentifier.trim() : "";
-  if (!sourceItemIdentifier) {
-    throw new ValidationError("A source question identifier is required to create a copy");
-  }
-  const unexpectedField = Object.keys(rawInput).find((field) => field !== "mode" && field !== "sourceItemIdentifier");
-  if (unexpectedField) {
-    throw new ValidationError(`Question copy input contains an unexpected “${unexpectedField}” field`);
-  }
-  return { kind: "copy", sourceItemIdentifier };
-}
-function nonEmptyMetadataString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function qtiQuestionOwnerTestIdentifier(item) {
-  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
-    return;
-  }
-  return nonEmptyMetadataString(item.metadata[PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]);
-}
-function qtiTestReferencesItem(test, itemIdentifier) {
-  return (test["qti-test-part"] ?? []).some((part) => (part["qti-assessment-section"] ?? []).some((section) => (section["qti-assessment-item-ref"] ?? []).some((reference) => reference.identifier === itemIdentifier)));
-}
-function resolveQtiQuestionOwnerGameSlug(item, ownerTest) {
-  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
-    return;
-  }
-  if ("ownerGameSlug" in item.metadata) {
-    return nonEmptyMetadataString(item.metadata.ownerGameSlug);
-  }
-  const ownerTestIdentifier = qtiQuestionOwnerTestIdentifier(item);
-  if (!ownerTestIdentifier || !ownerTest || ownerTest.identifier !== ownerTestIdentifier || !qtiTestReferencesItem(ownerTest, item.identifier) || ownerTest.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
-    return;
-  }
-  return nonEmptyMetadataString(ownerTest.metadata.ownerGameSlug);
-}
-function isQtiQuestionOwnedByGame(item, gameSlug, ownerTest) {
-  return resolveQtiQuestionOwnerGameSlug(item, ownerTest) === gameSlug;
-}
-function isQtiQuestionOwnedByContext(item, ownership, ownerTest) {
-  const declaredOwnerTest = qtiQuestionOwnerTestIdentifier(item);
-  if (declaredOwnerTest) {
-    return declaredOwnerTest === ownership.testIdentifier && isQtiQuestionOwnedByGame(item, ownership.gameSlug, ownerTest);
-  }
-  return isQtiItemOwnedByTest(item, ownership.testIdentifier);
-}
-function normalizedQtiInteractionType(value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
-  return normalized || undefined;
-}
-function authoringDocumentItem(value) {
-  const document2 = recordValue(value);
-  if (!document2) {
-    throw new ValidationError("Authored question data is invalid");
-  }
-  if (document2.format !== "playcademy-question" || document2.version !== 1) {
-    throw new ValidationError("Authored questions require a version 1 playcademy-question document");
-  }
-  const item = recordValue(document2.item);
-  if (!item || typeof item.title !== "string" || !Array.isArray(item.body) || !Array.isArray(item.responseDeclarations)) {
-    throw new ValidationError("An authored question needs an item with a title, a body, and response declarations");
-  }
-  const declarations = item.responseDeclarations.map(recordValue);
-  const declaredIdentifiers = declarations.map((declaration) => typeof declaration?.identifier === "string" ? declaration.identifier : "");
-  if (declarations.length === 0) {
-    throw new ValidationError("An authored question requires at least one response declaration");
-  }
-  const declaredIdentifierSet = new Set(declaredIdentifiers);
-  if (declaredIdentifiers.some((identifier) => !identifier) || declaredIdentifierSet.size !== declaredIdentifiers.length) {
-    throw new ValidationError("Response declaration identifiers must be unique");
-  }
-  const projection = projectQtiAuthoringBody(item.body);
-  if (projection.nestedInteractions.length > 0) {
-    throw new ValidationError("Interactions nested inside another interaction cannot be compiled");
-  }
-  if (projection.interactions.length !== declarations.length) {
-    throw new ValidationError("Every response declaration must belong to exactly one interaction");
-  }
-  const interactionIdentifiers = projection.interactions.map((interaction) => interaction.responseIdentifier);
-  const interactionIdentifierSet = new Set(interactionIdentifiers);
-  if (interactionIdentifierSet.size !== interactionIdentifiers.length) {
-    throw new ValidationError("Every interaction needs its own response identifier");
-  }
-  if (interactionIdentifiers.some((identifier) => !declaredIdentifierSet.has(identifier)) || declaredIdentifiers.some((identifier) => !interactionIdentifierSet.has(identifier))) {
-    throw new ValidationError("Every interaction must declare exactly one response");
-  }
-  const unauthorable = projection.interactions.find((interaction) => !qtiAuthoringInteractionType(interaction));
-  if (unauthorable) {
-    throw new ValidationError(`Interaction type “${String(unauthorable.type)}” cannot be authored by Playcademy yet`);
-  }
-  const inline = projection.interactions.filter(isInlineQtiAuthoringInteraction);
-  if (projection.interactions.length - inline.length > 1) {
-    throw new ValidationError("A question supports any number of inline interactions but at most one block interaction");
-  }
-  if (item.body.some((node) => node.kind === "interaction" && isInlineQtiAuthoringInteraction(node))) {
-    throw new ValidationError("Every inline interaction must sit at its blank inside the question’s prose");
-  }
-  const blanks = inline.map((interaction) => projection.blankIndexes.get(interaction));
-  if (blanks.some((blank) => blank === undefined) || new Set(blanks).size !== blanks.length) {
-    throw new ValidationError("Every inline interaction needs its own blank position");
-  }
-  return item;
-}
-function parsedQtiItemOrNull(rawXml) {
-  if (typeof rawXml !== "string" || !rawXml) {
-    return null;
-  }
-  try {
-    return parseQtiItemXml(rawXml);
-  } catch {
-    return null;
-  }
-}
-function isAuthorableMultiInteractionQtiItem(question) {
-  const item = parsedQtiItemOrNull(question.rawXml);
-  return item !== null && (authorableQtiInteractions(item)?.length ?? 0) > 1;
-}
-function assertPlayableQtiQuestion(question) {
-  if (!question.rawXml) {
-    assertSupportedQtiQuestionInteraction(question);
-    return;
-  }
-  const item = parsedQtiItemOrNull(question.rawXml);
-  const playable = item && playableQtiInteractions(item);
-  if (!playable || qtiItemScoringValidationMessage(item)) {
-    throw new ValidationError(`Question ${question.identifier} uses an interaction Playcademy cannot play or score.`);
-  }
-}
-function assertSupportedQtiQuestionInteraction(question) {
-  const candidate = recordValue(question);
-  if (candidate?.type === AUTHORING_DOCUMENT_QUESTION_TYPE) {
-    authoringDocumentItem(candidate.document);
-    return;
-  }
-  if (!supportedQtiQuestionInteractionType(question) && !isAuthorableMultiInteractionQtiItem(question)) {
-    throw new ValidationError("This QTI interaction type is not supported by the Playcademy question editor.");
-  }
-}
-function invalidQtiCopyXml() {
-  throw new ValidationError("The source question does not contain valid QTI item XML");
-}
-function markupEnd2(xml, start2, allowInternalSubset) {
-  let quote = null;
-  let subsetDepth = 0;
-  for (let index2 = start2;index2 < xml.length; index2 += 1) {
-    const character = xml[index2];
-    if (quote) {
-      if (character === quote) {
-        quote = null;
-      }
-    } else if (character === '"' || character === "'") {
-      quote = character;
-    } else if (allowInternalSubset && character === "[") {
-      subsetDepth += 1;
-    } else if (allowInternalSubset && character === "]") {
-      subsetDepth = Math.max(0, subsetDepth - 1);
-    } else if (character === ">" && subsetDepth === 0) {
-      return index2;
-    }
-  }
-  return invalidQtiCopyXml();
-}
-function skipXmlWhitespace(xml, start2, end = xml.length) {
-  let cursor2 = start2;
-  while (cursor2 < end && /\s/.test(xml[cursor2] ?? "")) {
-    cursor2 += 1;
-  }
-  return cursor2;
-}
-function xmlPreambleEnd(xml, cursor2) {
-  if (xml.startsWith("<?", cursor2)) {
-    const end = xml.indexOf("?>", cursor2 + 2);
-    if (end === -1) {
-      return invalidQtiCopyXml();
-    }
-    return end + 2;
-  }
-  if (xml.startsWith("<!--", cursor2)) {
-    const end = xml.indexOf("-->", cursor2 + 4);
-    if (end === -1) {
-      return invalidQtiCopyXml();
-    }
-    return end + 3;
-  }
-  if (/^<!DOCTYPE\b/i.test(xml.slice(cursor2))) {
-    return markupEnd2(xml, cursor2 + 2, true) + 1;
-  }
-  return null;
-}
-function qtiRootAttributes(xml, start2, end) {
-  const attributes2 = [];
-  let cursor2 = start2;
-  while (cursor2 < end) {
-    cursor2 = skipXmlWhitespace(xml, cursor2, end);
-    if (xml[cursor2] === "/") {
-      cursor2 += 1;
-    } else if (cursor2 < end) {
-      const nameMatch = /^[A-Za-z_][\w.:-]*/.exec(xml.slice(cursor2, end));
-      if (!nameMatch) {
-        return invalidQtiCopyXml();
-      }
-      const name3 = nameMatch[0];
-      cursor2 = skipXmlWhitespace(xml, cursor2 + name3.length, end);
-      if (xml[cursor2] !== "=") {
-        return invalidQtiCopyXml();
-      }
-      cursor2 = skipXmlWhitespace(xml, cursor2 + 1, end);
-      const quote = xml[cursor2];
-      if (quote !== '"' && quote !== "'") {
-        return invalidQtiCopyXml();
-      }
-      const valueStart = cursor2 + 1;
-      const valueEnd = xml.indexOf(quote, valueStart);
-      if (valueEnd === -1 || valueEnd > end) {
-        return invalidQtiCopyXml();
-      }
-      attributes2.push({ name: name3, quote, valueStart, valueEnd });
-      cursor2 = valueEnd + 1;
-    }
-  }
-  return attributes2;
-}
-function qtiItemStartTag(xml) {
-  let cursor2 = xml.charCodeAt(0) === 65279 ? 1 : 0;
-  while (cursor2 < xml.length) {
-    cursor2 = skipXmlWhitespace(xml, cursor2);
-    const preambleEnd = xmlPreambleEnd(xml, cursor2);
-    if (preambleEnd !== null) {
-      cursor2 = preambleEnd;
-    } else {
-      const root = /^<([A-Za-z_][\w.:-]*)/.exec(xml.slice(cursor2));
-      if (!root || root[1].split(":").at(-1) !== "qti-assessment-item") {
-        return invalidQtiCopyXml();
-      }
-      const attributesStart = cursor2 + root[0].length;
-      const end = markupEnd2(xml, attributesStart, false);
-      const attributes2 = qtiRootAttributes(xml, attributesStart, end);
-      let insertionPoint = skipXmlWhitespaceBackward(xml, end);
-      if (xml[insertionPoint - 1] === "/") {
-        insertionPoint -= 1;
-      }
-      return { attributes: attributes2, insertionPoint };
-    }
-  }
-  return invalidQtiCopyXml();
-}
-function skipXmlWhitespaceBackward(xml, start2) {
-  let cursor2 = start2;
-  while (/\s/.test(xml[cursor2 - 1] ?? "")) {
-    cursor2 -= 1;
-  }
-  return cursor2;
-}
-function escapeXmlAttribute(value, quote) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(quote, quote === '"' ? "&quot;" : "&apos;");
-}
-function rewriteQtiItemIdentity(xml, identifier, title) {
-  if (!xml.trim() || !identifier.trim() || !title.trim()) {
-    return invalidQtiCopyXml();
-  }
-  const root = qtiItemStartTag(xml);
-  const replacements = [];
-  const targetAttributes = new Map([
-    ["identifier", identifier],
-    ["title", title]
-  ]);
-  for (const [name3, value] of targetAttributes) {
-    const matches = root.attributes.filter((attribute2) => attribute2.name === name3);
-    if (matches.length > 1) {
-      return invalidQtiCopyXml();
-    }
-    const attribute = matches[0];
-    if (attribute) {
-      replacements.push({
-        start: attribute.valueStart,
-        end: attribute.valueEnd,
-        value: escapeXmlAttribute(value, attribute.quote)
-      });
-    } else {
-      replacements.push({
-        start: root.insertionPoint,
-        end: root.insertionPoint,
-        value: ` ${name3}="${escapeXmlAttribute(value, '"')}"`
-      });
-    }
-  }
-  return replacements.toSorted((left, right) => right.start - left.start).reduce((rewritten, replacement) => `${rewritten.slice(0, replacement.start)}${replacement.value}${rewritten.slice(replacement.end)}`, xml);
-}
-function buildQtiQuestionCopyInput(input) {
-  assertPlayableQtiQuestion(input.source);
-  const title = input.source.title?.trim() || input.source.identifier;
-  if (!input.source.rawXml) {
-    return invalidQtiCopyXml();
-  }
-  const sourceMetadata = { ...input.source.metadata };
-  if (sourceMetadata.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
-    Reflect.deleteProperty(sourceMetadata, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
-  }
-  const metadata2 = buildOwnedQtiQuestionMetadata({
-    metadata: {
-      copiedFromItemIdentifier: input.source.identifier,
-      integrationId: input.integrationId
-    }
-  }, {
-    gameSlug: input.gameSlug,
-    testIdentifier: input.targetTestIdentifier
-  }, sourceMetadata);
-  return {
-    identifier: input.targetIdentifier,
-    title,
-    xml: rewriteQtiItemIdentity(input.source.rawXml, input.targetIdentifier, title),
-    metadata: metadata2
-  };
-}
-function assertQtiQuestionEditable(item, ownership, ownerTest) {
-  if (!isQtiQuestionOwnedByContext(item, ownership, ownerTest)) {
-    throw new ValidationError("Shared question references are read-only. Copy the question to create an editable independent item.");
-  }
-}
-function buildNumericQuestionXml(input, identifier, title) {
-  if (input.format === "xml") {
-    throw new ValidationError("Raw question XML is not accepted at this API boundary");
-  }
-  const candidate = input.numericTextEntry;
-  if (candidate === undefined) {
-    return null;
-  }
-  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
-    throw new ValidationError("Numeric text-entry data is invalid");
-  }
-  const prompt = "prompt" in candidate ? candidate.prompt : undefined;
-  const numeric3 = parseNumericTextEntry({
-    baseType: "baseType" in candidate ? candidate.baseType : undefined,
-    answer: "answer" in candidate ? candidate.answer : undefined,
-    comparison: "comparison" in candidate ? candidate.comparison : undefined
-  });
-  if (!numeric3.success) {
-    throw new ValidationError(numeric3.message);
-  }
-  if (!title || typeof prompt !== "string" || !prompt.trim()) {
-    throw new ValidationError("Numeric questions require a title and prompt");
-  }
-  return numericTextEntryXml({ identifier, title, prompt: prompt.trim(), numeric: numeric3.value });
-}
-function buildExactMatchQuestionXml(input) {
-  const responseIdentifier = escapeXml(input.responseIdentifier);
-  const correctValues = input.correctIdentifiers.map((identifier) => `      <qti-value>${escapeXml(identifier)}</qti-value>`).join(`
-`);
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<qti-assessment-item xmlns="http://www.imsglobal.org/xsd/imsqtiasi_v3p0" identifier="${escapeXml(input.identifier)}" title="${escapeXml(input.title)}" adaptive="false" time-dependent="false">
-  <qti-response-declaration identifier="${responseIdentifier}" cardinality="${input.cardinality}" base-type="identifier">
-    <qti-correct-response>
-${correctValues}
-    </qti-correct-response>
-  </qti-response-declaration>
-  <qti-outcome-declaration identifier="FEEDBACK" cardinality="single" base-type="identifier" />
-  <qti-outcome-declaration identifier="SCORE" cardinality="single" base-type="float">
-    <qti-default-value><qti-value>0</qti-value></qti-default-value>
-  </qti-outcome-declaration>
-  <qti-item-body>
-${input.itemBody}
-  </qti-item-body>
-  <qti-response-processing>
-    <qti-response-condition>
-      <qti-response-if>
-        <qti-match><qti-variable identifier="${responseIdentifier}" /><qti-correct identifier="${responseIdentifier}" /></qti-match>
-        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">CORRECT</qti-base-value></qti-set-outcome-value>
-        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">1</qti-base-value></qti-set-outcome-value>
-      </qti-response-if>
-      <qti-response-else>
-        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">INCORRECT</qti-base-value></qti-set-outcome-value>
-        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">0</qti-base-value></qti-set-outcome-value>
-      </qti-response-else>
-    </qti-response-condition>
-  </qti-response-processing>
-</qti-assessment-item>`;
-}
-function parseStructuredChoices(value, options) {
-  const { label, minimum, validate: validate2 } = options;
-  if (!Array.isArray(value) || value.length < minimum) {
-    throw new ValidationError(`${label} questions require at least ${minimum === 1 ? "one choice" : `${minimum} choices`}`);
-  }
-  const choices = value.map((choice) => {
-    const record3 = recordValue(choice);
-    const identifier = record3?.identifier;
-    const content = record3?.content;
-    if (typeof identifier !== "string" || !identifier.trim() || typeof content !== "string" || !content.trim() || validate2 !== undefined && record3 !== undefined && !validate2(record3)) {
-      throw new ValidationError(`${label} options are invalid`);
-    }
-    return { identifier: identifier.trim(), content: content.trim() };
-  });
-  if (new Set(choices.map((choice) => choice.identifier)).size !== choices.length) {
-    throw new ValidationError(`${label} option identifiers must be unique`);
-  }
-  return choices;
-}
-function declaredCorrectResponse(input, responseIdentifier) {
-  const declarations = Array.isArray(input.responseDeclarations) ? input.responseDeclarations : [];
-  const declaration = declarations.map(recordValue).find((candidate) => candidate?.identifier === responseIdentifier);
-  const rawValues = recordValue(declaration?.correctResponse)?.value;
-  return {
-    cardinality: declaration?.cardinality,
-    baseType: declaration?.baseType,
-    values: Array.isArray(rawValues) ? rawValues.filter((value) => typeof value === "string") : []
-  };
-}
-function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers) {
-  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
-  if (cardinality !== "single" || baseType !== "identifier") {
-    throw new ValidationError("Inline-choice questions require a single-identifier response declaration");
-  }
-  if (values.length !== 1 || !choiceIdentifiers.has(values[0])) {
-    throw new ValidationError("Inline-choice questions require one valid correct option");
-  }
-  return values[0];
-}
-function structuredQuestionEnvelope(input, type, label, title) {
-  const interaction = recordValue(input.interaction);
-  if (normalizedQtiInteractionType(interaction?.type ?? input.type) !== type) {
-    return null;
-  }
-  const structure = recordValue(interaction?.questionStructure);
-  const responseIdentifier = interaction?.responseIdentifier;
-  const prompt = structure?.prompt;
-  if (!interaction || !structure || typeof responseIdentifier !== "string" || !responseIdentifier.trim()) {
-    throw new ValidationError(`${label} question data is invalid`);
-  }
-  if (!title || typeof prompt !== "string" || !prompt.trim()) {
-    throw new ValidationError(`${label} questions require a title and prompt`);
-  }
-  return {
-    interaction,
-    structure,
-    responseIdentifier: responseIdentifier.trim(),
-    prompt: prompt.trim()
-  };
-}
-function buildInlineChoiceQuestionXml(input, identifier, title) {
-  const envelope = structuredQuestionEnvelope(input, "inline-choice", "Inline-choice", title);
-  if (!envelope) {
-    return null;
-  }
-  const { 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");
-  }
-  const choices = parseStructuredChoices(structure.inlineChoices, {
-    label: "Inline-choice",
-    minimum: 2
-  });
-  const choiceIdentifiers = new Set(choices.map((choice) => choice.identifier));
-  const correctIdentifier = inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers);
-  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)}">
-${choicesXml}
-      </qti-inline-choice-interaction>${escapeXml(after)}</p>`;
-  return buildExactMatchQuestionXml({
-    identifier,
-    title,
-    responseIdentifier,
-    cardinality: "single",
-    correctIdentifiers: [correctIdentifier],
-    itemBody
-  });
-}
-function parseStructuredMatchChoices(value, label) {
-  return parseStructuredChoices(value, {
-    label: `Match ${label}`,
-    minimum: 1,
-    validate: (choice) => choice.matchMax === 1
-  });
-}
-function structuredMatchCorrectPairs(input, responseIdentifier, sources, targets) {
-  const { cardinality, baseType, values } = declaredCorrectResponse(input, responseIdentifier);
-  if (cardinality !== "multiple" || baseType !== "directedPair") {
-    throw new ValidationError("Match questions require a multiple directed-pair response declaration");
-  }
-  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
-  const targetIdentifiers = new Set(targets.map((choice) => choice.identifier));
-  const valid = values.length > 0 && new Set(values).size === values.length && values.every((value) => {
-    const [source, target, extra] = value.split(" ");
-    return extra === undefined && Boolean(source && target) && sourceIdentifiers.has(source) && targetIdentifiers.has(target);
-  });
-  if (!valid) {
-    throw new ValidationError("Every Match correct response must name one declared source and target choice");
-  }
-  return values;
-}
-function buildMatchQuestionXml(input, identifier, title) {
-  const envelope = structuredQuestionEnvelope(input, "match", "Match", title);
-  if (!envelope) {
-    return null;
-  }
-  const { interaction, structure, responseIdentifier, prompt } = envelope;
-  const sources = parseStructuredMatchChoices(structure.sourceChoices, "source");
-  const targets = parseStructuredMatchChoices(structure.targetChoices, "target");
-  const sourceIdentifiers = new Set(sources.map((choice) => choice.identifier));
-  if (targets.some((choice) => sourceIdentifiers.has(choice.identifier))) {
-    throw new ValidationError("Match source and target choice identifiers must be unique");
-  }
-  const correctValues = structuredMatchCorrectPairs(input, responseIdentifier, sources, targets);
-  const maxAssociations = interaction.maxAssociations;
-  if (typeof maxAssociations !== "number" || !Number.isInteger(maxAssociations) || maxAssociations < 0 || maxAssociations !== 0 && maxAssociations < correctValues.length) {
-    throw new ValidationError("Match max associations must fit every correct pair");
-  }
-  const item = {
-    key: identifier,
-    title,
-    body: [
-      {
-        kind: "interaction",
-        type: "match",
-        responseIdentifier,
-        attributes: {
-          shuffle: interaction.shuffle === true,
-          "max-associations": maxAssociations
-        },
-        content: [
-          {
-            kind: "element",
-            name: "qti-prompt",
-            children: [{ kind: "text", text: prompt }]
-          }
-        ],
-        choiceSets: [sources, targets].map((choices) => choices.map((choice) => ({
-          identifier: choice.identifier,
-          content: [{ kind: "text", text: choice.content }]
-        })))
-      }
-    ],
-    responseDeclarations: [
-      {
-        identifier: responseIdentifier,
-        cardinality: "multiple",
-        baseType: "directedPair",
-        correctValues
-      }
-    ]
-  };
-  try {
-    return compileQtiAuthoringItemXml(item, { identifier, title });
-  } catch (error88) {
-    throw new ValidationError(`This Match question cannot be compiled to QTI: ${errorMessage2(error88)}`);
-  }
-}
-function parseHottextSegments2(value) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new ValidationError("Hottext questions require passage segments");
-  }
-  const segments = value.map((segment) => {
-    const record3 = recordValue(segment);
-    const identifier = record3?.identifier;
-    const content = record3?.content;
-    const mode = record3?.mode;
-    if (typeof identifier !== "string" || typeof content !== "string" || !content.trim() || !["plain", "option", "correct"].includes(String(mode))) {
-      throw new ValidationError("Hottext passage segments are invalid");
-    }
-    return {
-      identifier: identifier.trim(),
-      content: content.trim(),
-      mode
-    };
-  });
-  const selectable = segments.filter((segment) => segment.mode !== "plain");
-  const correct = selectable.filter((segment) => segment.mode === "correct");
-  const identifiers = selectable.map((segment) => segment.identifier);
-  if (selectable.length < 2) {
-    throw new ValidationError("Hottext questions require at least two selectable phrases");
-  }
-  if (identifiers.some((identifier) => !identifier)) {
-    throw new ValidationError("Hottext selectable phrases require identifiers");
-  }
-  if (new Set(identifiers).size !== identifiers.length) {
-    throw new ValidationError("Hottext selectable phrase identifiers must be unique");
-  }
-  if (correct.length === 0) {
-    throw new ValidationError("Hottext questions require a correct phrase");
-  }
-  return { segments, selectable, correct };
-}
-function buildHottextQuestionXml(input, identifier, title) {
-  const candidate = input.hottext;
-  if (candidate === undefined) {
-    return null;
-  }
-  const hottext = recordValue(candidate);
-  if (!hottext) {
-    throw new ValidationError("Hottext question data is invalid");
-  }
-  const prompt = hottext.prompt;
-  if (!title || typeof prompt !== "string" || !prompt.trim()) {
-    throw new ValidationError("Hottext questions require a title and prompt");
-  }
-  const { segments, selectable, correct } = parseHottextSegments2(hottext.segments);
-  const multiple = correct.length > 1;
-  const maxChoices = hottextMaxChoices(selectable.length, multiple);
-  const passage = segments.map((segment) => segment.mode === "plain" ? escapeXml(segment.content) : `<qti-hottext identifier="${escapeXml(segment.identifier)}">${escapeXml(segment.content)}</qti-hottext>`).join(" ");
-  const itemBody = `    <qti-hottext-interaction response-identifier="RESPONSE" max-choices="${maxChoices}">
-      <qti-prompt>${escapeXml(prompt.trim())}</qti-prompt>
-      <p>${passage}</p>
-    </qti-hottext-interaction>`;
-  return buildExactMatchQuestionXml({
-    identifier,
-    title,
-    responseIdentifier: "RESPONSE",
-    cardinality: multiple ? "multiple" : "single",
-    correctIdentifiers: correct.map((segment) => segment.identifier),
-    itemBody
-  });
-}
-function buildAuthoringDocumentQuestionXml(input, identifier, title) {
-  if (input.type !== AUTHORING_DOCUMENT_QUESTION_TYPE) {
-    return null;
-  }
-  const item = authoringDocumentItem(input.document);
-  if (!title) {
-    throw new ValidationError("Authored questions require a title");
-  }
-  try {
-    return compileQtiAuthoringItemXml(item, { identifier, title });
-  } catch (error88) {
-    throw new ValidationError(`This question cannot be compiled to QTI: ${errorMessage2(error88)}`);
-  }
-}
-function buildQuestionXml(input, identifier, title) {
-  for (const build2 of QUESTION_XML_BUILDERS) {
-    const xml = build2(input, identifier, title);
-    if (xml !== null) {
-      return xml;
-    }
-  }
-  return null;
-}
-function buildCreatedQtiQuestionReference(input) {
-  return {
-    ownership: "owned",
-    reference: {
-      identifier: input.itemIdentifier,
-      href: input.href,
-      testPart: input.partIdentifier,
-      section: input.sectionIdentifier
-    },
-    question: mergeQtiQuestionItem(input.item, input.fallbackItem, input.itemIdentifier, input.metadata)
-  };
-}
-function buildHydratedQtiQuestionReference(input) {
-  const identifier = input.reference.reference.identifier;
-  const ownerGameSlug = resolveQtiQuestionOwnerGameSlug(input.item, input.ownerTest);
-  const authoritativeItem = ownerGameSlug ? {
-    ...input.item,
-    metadata: { ...input.item.metadata, ownerGameSlug }
-  } : input.item;
-  const question = mergeQtiQuestionItem(authoritativeItem, input.reference.question, identifier);
-  return {
-    ...input.reference,
-    ownership: isQtiQuestionOwnedByContext(question, { gameSlug: input.gameSlug, testIdentifier: input.testIdentifier }, input.ownerTest) ? "owned" : "shared",
-    question
-  };
-}
-function isQtiTestOwnedByGame(test, gameSlug) {
-  return test.metadata?.ownerSystem === PLAYCADEMY_QTI_OWNER_SYSTEM && test.metadata.ownerGameSlug === gameSlug;
-}
-function assertQtiTestOwnedByGame(test, gameSlug) {
-  if (!isQtiTestOwnedByGame(test, gameSlug)) {
-    throw new ValidationError("Shared assessment references are read-only. Copy the assessment to create an editable independent test.");
-  }
-}
-function qtiTestParts(test) {
-  const parts2 = test["qti-test-part"];
-  if (!Array.isArray(parts2) || parts2.length === 0) {
-    throw new ValidationError(`Assessment ${test.identifier} has no test parts`);
-  }
-  for (const [partIndex, part] of parts2.entries()) {
-    if (!part || typeof part !== "object" || Array.isArray(part)) {
-      throw new ValidationError(`Assessment ${test.identifier} contains an invalid test part at position ${partIndex + 1}`);
-    }
-    const sections = part["qti-assessment-section"];
-    if (!Array.isArray(sections)) {
-      throw new ValidationError(`Assessment ${test.identifier} test part ${partIndex + 1} has no section list`);
-    }
-  }
-  return parts2;
-}
-function qtiTestOptionalAttributes(test) {
-  return {
-    ...test.qtiVersion ? { qtiVersion: test.qtiVersion } : {},
-    ...test.timeLimit !== undefined ? { timeLimit: test.timeLimit } : {},
-    ...test.maxAttempts !== undefined ? { maxAttempts: test.maxAttempts } : {},
-    ...test.toolsEnabled !== undefined ? { toolsEnabled: test.toolsEnabled } : {}
-  };
-}
-function buildQtiAssessmentItemCopyPlan(test, targetTestIdentifier, hrefForIdentifier, createIdentifier = newPlaycademyQuestionIdentifier) {
-  const sourceIdentifiers = [];
-  const seen = new Set;
-  for (const part of qtiTestParts(test)) {
-    for (const section of part["qti-assessment-section"]) {
-      for (const reference of section["qti-assessment-item-ref"] ?? []) {
-        if (!seen.has(reference.identifier)) {
-          seen.add(reference.identifier);
-          sourceIdentifiers.push(reference.identifier);
-        }
-      }
-    }
+function prepareDiagnosticDefinition(input) {
+  const diagnosticKey = input.diagnosticKey.trim();
+  if (!diagnosticKey || diagnosticKey.length > 200) {
+    throw new ValidationError("Diagnostic key must contain between 1 and 200 characters");
   }
-  return sourceIdentifiers.map((sourceIdentifier) => {
-    const targetIdentifier = createIdentifier(targetTestIdentifier);
-    return {
-      sourceIdentifier,
-      targetIdentifier,
-      href: hrefForIdentifier(targetIdentifier)
-    };
+  const validation = validateDiagnosticRoutingManifest(input.routingManifest, undefined, {
+    analyzeBounds: false
   });
-}
-function buildQtiTestStructureInput(test, targetTestIdentifier, itemCopies) {
-  const outcomeDeclarations = test["qti-outcome-declaration"];
-  if (outcomeDeclarations !== undefined && !Array.isArray(outcomeDeclarations)) {
-    throw new ValidationError(`Assessment ${test.identifier} has an invalid outcome declaration list`);
-  }
-  return {
-    "qti-test-part": qtiTestParts(test).map((part, partIndex) => ({
-      identifier: targetTestIdentifier ? `${targetTestIdentifier}-part${partIndex + 1}` : part.identifier,
-      navigationMode: part.navigationMode,
-      submissionMode: part.submissionMode,
-      "qti-assessment-section": part["qti-assessment-section"].map((section, sectionIndex) => {
-        let sectionIdentifier = section.identifier;
-        if (targetTestIdentifier) {
-          sectionIdentifier = partIndex === 0 && sectionIndex === 0 ? `${targetTestIdentifier}-section1` : `${targetTestIdentifier}-part${partIndex + 1}-section${sectionIndex + 1}`;
-        }
-        return {
-          identifier: sectionIdentifier,
-          title: section.title,
-          visible: section.visible ?? true,
-          ...section.required !== undefined ? { required: section.required } : {},
-          ...section.fixed !== undefined ? { fixed: section.fixed } : {},
-          sequence: section.sequence ?? sectionIndex + 1,
-          ...section["qti-assessment-item-ref"] ? {
-            "qti-assessment-item-ref": section["qti-assessment-item-ref"].map((item, itemIndex) => {
-              const copy = itemCopies?.get(item.identifier);
-              if (itemCopies && !copy) {
-                throw new ValidationError(`Assessment copy is missing question ${item.identifier}`);
-              }
-              return {
-                identifier: copy?.targetIdentifier ?? item.identifier,
-                href: copy?.href ?? item.href,
-                sequence: item.sequence ?? itemIndex + 1
-              };
-            })
-          } : {}
-        };
-      })
-    })),
-    ...outcomeDeclarations ? {
-      "qti-outcome-declaration": outcomeDeclarations.map((declaration) => ({
-        identifier: declaration.identifier,
-        ...declaration.cardinality !== undefined ? { cardinality: declaration.cardinality } : {},
-        baseType: declaration.baseType,
-        ...declaration.normalMaximum !== undefined ? { normalMaximum: declaration.normalMaximum } : {},
-        ...declaration.normalMinimum !== undefined ? { normalMinimum: declaration.normalMinimum } : {},
-        ...declaration.defaultValue ? {
-          defaultValue: declaration.defaultValue.value !== undefined ? { value: declaration.defaultValue.value } : {}
-        } : {}
-      }))
-    } : {}
-  };
-}
-function buildQtiTestUpdateInput(test, title) {
-  return {
-    title,
-    ...qtiTestOptionalAttributes(test),
-    ...test.metadata ? { metadata: test.metadata } : {},
-    ...buildQtiTestStructureInput(test)
-  };
-}
-function buildQtiTestCopyInput(source, targetTestIdentifier, metadata2, itemCopies) {
-  const copiesBySourceIdentifier = new Map(itemCopies.map((copy) => [copy.sourceIdentifier, copy]));
-  return {
-    identifier: targetTestIdentifier,
-    title: `${source.title} (copy)`,
-    ...qtiTestOptionalAttributes(source),
-    metadata: metadata2,
-    ...buildQtiTestStructureInput(source, targetTestIdentifier, copiesBySourceIdentifier)
-  };
-}
-function validateUniqueQuestionIdentifiers(itemIdentifiers) {
-  if (itemIdentifiers.length === 0 || new Set(itemIdentifiers).size !== itemIdentifiers.length) {
-    throw new ValidationError("Question order must contain unique question identifiers");
+  if (!validation.valid || !validation.manifest) {
+    const details = validation.errors.slice(0, 3).map((issue7) => issue7.message).join(" ");
+    throw new ValidationError(`Diagnostic routing manifest is invalid.${details ? ` ${details}` : ""}`);
   }
+  return { diagnosticKey, routingManifest: validation.manifest };
 }
-function resolveQtiQuestionSection(test, qtiTestIdentifier, itemIdentifier, expectedItemIdentifiers) {
-  let selectedPart;
-  let selectedSection;
-  for (const part of qtiTestParts(test)) {
-    for (const section of part["qti-assessment-section"]) {
-      if (!itemIdentifier || section["qti-assessment-item-ref"]?.some((item) => item.identifier === itemIdentifier)) {
-        selectedPart = part;
-        selectedSection = section;
-        break;
-      }
-    }
-    if (selectedSection) {
-      break;
-    }
-  }
-  if (!selectedPart || !selectedSection) {
-    throw new ValidationError(itemIdentifier ? `Question ${itemIdentifier} is not referenced by assessment ${qtiTestIdentifier}` : `Assessment ${qtiTestIdentifier} has no section for questions`);
+async function preparePublishedDiagnosticDefinition(definition, loaded) {
+  assertAssessmentHasQuestions(loaded.questions.questions);
+  for (const { question } of loaded.questions.questions) {
+    assertPlayableQtiQuestion(question);
   }
-  if (expectedItemIdentifiers) {
-    const sectionIdentifiers = selectedSection["qti-assessment-item-ref"]?.map((item) => item.identifier) ?? [];
-    const expectedIdentifiers = new Set(expectedItemIdentifiers);
-    if (expectedIdentifiers.size !== sectionIdentifiers.length || sectionIdentifiers.some((identifier) => !expectedIdentifiers.has(identifier))) {
-      throw new ValidationError("Questions can only be reordered within one complete assessment section");
-    }
+  const assessment = await buildPlayableAssessment(loaded.test, loaded.questions);
+  const scoring = assessmentFixtureScoringKeys(assessment, loaded.questions);
+  const validation = validateDiagnosticRoutingManifest(definition.routingManifest, diagnosticRoutingCapabilities(assessment, scoring));
+  if (!validation.valid || !validation.manifest) {
+    const details = validation.errors.slice(0, 3).map((issue7) => issue7.message).join(" ");
+    throw new ValidationError(`Diagnostic routing manifest cannot be published.${details ? ` ${details}` : ""}`);
   }
-  return {
-    partIdentifier: selectedPart.identifier,
-    sectionIdentifier: selectedSection.identifier
-  };
+  return { diagnosticKey: definition.diagnosticKey, routingManifest: validation.manifest };
 }
-var PLAYCADEMY_QTI_AUTHORING_METADATA_KEY = "playcademyAuthoring";
-var AUTHORING_DOCUMENT_QUESTION_TYPE = "authoring-document";
-var QTI_AUTHORING_FIELDS;
-var QUESTION_XML_BUILDERS;
-var init_timeback_qti_authoring_util = __esm(() => {
-  init_qti();
-  init_timeback3();
+var init_timeback_assessment_diagnostic_util = __esm(() => {
+  init_assessment_runtime2();
   init_errors2();
-  QTI_AUTHORING_FIELDS = [
-    "type",
-    "document",
-    "qtiVersion",
-    "timeDependent",
-    "adaptive",
-    "preInteraction",
-    "interaction",
-    "postInteraction",
-    "responseDeclarations",
-    "outcomeDeclarations",
-    "responseProcessing",
-    "modalFeedback",
-    "feedbackInline",
-    "feedbackBlock",
-    "rubrics",
-    "stimulus",
-    "content"
-  ];
-  QUESTION_XML_BUILDERS = [
-    buildNumericQuestionXml,
-    buildAuthoringDocumentQuestionXml,
-    buildHottextQuestionXml,
-    buildInlineChoiceQuestionXml,
-    buildMatchQuestionXml
-  ];
+  init_timeback_assessment_rules_util();
+  init_timeback_assessment_runtime_util();
+  init_timeback_qti_authoring_util();
 });
 function assertPlayableAssessmentImportQuestions(targetStatus, questions) {
   if (targetStatus === "draft") {
@@ -128459,34 +128859,44 @@ function assertAssessmentImportCourseMatches(manifest, integration) {
 function associationMetadataMatches(row, entry2) {
   return row.purpose === entry2.purpose && (row.standardFramework ?? undefined) === entry2.standard?.framework && (row.standardIdentifier ?? undefined) === entry2.standard?.identifier;
 }
-function targetStatusSatisfied(row, targetStatus) {
-  return row.status === targetStatus || targetStatus === "draft" && row.status === "live";
-}
-function classifyExistingAssessmentImport(row, entry2, targetStatus) {
-  if (!associationMetadataMatches(row, entry2)) {
+function planAssessmentAssociationImport(entry2, existingByKey, existingByIdentifier) {
+  if (!existingByKey) {
+    if (!existingByIdentifier) {
+      return { kind: "insert" };
+    }
+    const existingKey = existingByIdentifier.assessmentKey;
     return {
+      kind: "fail",
       status: "failed",
-      message: "Already attached with different purpose or standard metadata."
+      message: existingKey ? `QTI publication is already attached under assessment key ${existingKey}.` : "QTI publication is already attached without a managed assessment key."
     };
   }
-  if (targetStatusSatisfied(row, targetStatus)) {
-    return { status: "skipped", message: `Already attached as ${row.status}.` };
-  }
-  if (row.status === "archived") {
+  if (existingByIdentifier && existingByIdentifier.id !== existingByKey.id) {
+    const existingKey = existingByIdentifier.assessmentKey;
     return {
+      kind: "fail",
       status: "failed",
-      message: "Already attached as archived and cannot be imported again."
+      message: existingKey ? `QTI publication is already attached under assessment key ${existingKey}.` : "QTI publication is already attached without a managed assessment key."
     };
   }
-  if (targetStatus === "live" && row.status === "draft") {
+  if (!associationMetadataMatches(existingByKey, entry2)) {
     return {
+      kind: "fail",
       status: "failed",
-      message: "Already attached as a draft. Publish it from the assessment editor before retrying."
+      message: "Assessment key is already attached with different purpose or standard metadata."
+    };
+  }
+  if (existingByKey.qtiTestIdentifier === entry2.qtiTestIdentifier) {
+    return {
+      kind: "skip",
+      status: "skipped",
+      message: "Assessment key already points to this publication."
     };
   }
   return {
+    kind: "fail",
     status: "failed",
-    message: `Already attached as ${row.status}, which does not match the requested ${targetStatus} status.`
+    message: "Assessment key is already attached to a different QTI publication."
   };
 }
 function attachedAssessmentImportMessage(targetStatus, editable) {
@@ -128546,60 +128956,6 @@ function buildQtiLibraryListPlan(params) {
 }
 var PLAYCADEMY_QTI_SOURCE_PREFIX = "playcademy-test-";
 var PLAYCADEMY_QTI_SOURCE_UPPER_BOUND = "playcademy-test.";
-function reviewMappingIssueSummary(label, identifiers) {
-  if (identifiers.length === 0) {
-    return null;
-  }
-  const displayed = identifiers.slice(0, 10).join(", ");
-  const remainder = identifiers.length > 10 ? `, and ${identifiers.length - 10} more` : "";
-  return `${label} (${identifiers.length}): ${displayed}${remainder}`;
-}
-async function prepareReviewMappingUpdate(test, questions) {
-  const contentRevision = await assessmentContentRevision(test, questions);
-  const assessment = {
-    identifier: test.identifier,
-    contractVersion: 1,
-    contentRevision,
-    title: test.title,
-    items: questions.questions.map(({ question }) => ({
-      identifier: question.identifier,
-      title: question.title,
-      prompt: "",
-      maxScore: 1,
-      interactions: []
-    }))
-  };
-  const bank = await buildReviewBankIndex(assessment, questions, { customOnly: true });
-  const issues = reviewBankMappingIssues(bank);
-  if (issues.missingOrInvalidItemIdentifiers.length > 0 || issues.multipleStandardItemIdentifiers.length > 0) {
-    const details = [
-      reviewMappingIssueSummary("missing or invalid associations", issues.missingOrInvalidItemIdentifiers),
-      reviewMappingIssueSummary("multiple associations", issues.multipleStandardItemIdentifiers)
-    ].filter((detail) => detail !== null);
-    throw new ValidationError(`Every review question must have exactly one valid standard/node association. ${details.join("; ")}.`);
-  }
-  const manifest = await buildReviewBankManifest(bank);
-  return {
-    update: {
-      ...buildQtiTestUpdateInput(test, test.title),
-      metadata: {
-        ...test.metadata,
-        [PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY]: manifest
-      }
-    },
-    summary: {
-      itemCount: bank.items.length,
-      standardCount: Object.keys(manifest.itemsByStandard).length,
-      sourceFingerprint: manifest.sourceFingerprint
-    }
-  };
-}
-var init_timeback_review_mapping_util = __esm(() => {
-  init_assessment_runtime2();
-  init_errors2();
-  init_timeback_assessment_runtime_util();
-  init_timeback_qti_authoring_util();
-});
 function databaseConstraintName(error88) {
   if (typeof error88 !== "object" || error88 === null) {
     return;
@@ -128607,15 +128963,6 @@ function databaseConstraintName(error88) {
   const name3 = error88.constraint_name;
   return typeof name3 === "string" ? name3 : undefined;
 }
-function diagnosticRoutingCapabilities(assessment, scoring) {
-  return assessment.items.map((item) => ({
-    itemIdentifier: item.identifier,
-    supportsDeterminateBinaryGrading: item.interactions.length > 0 && item.interactions.every((interaction) => {
-      const responseIdentifier = interaction.responseIdentifier;
-      return Object.hasOwn(scoring.correctResponses[item.identifier] ?? {}, responseIdentifier) || (scoring.responseAreas?.[item.identifier]?.[responseIdentifier]?.length ?? 0) > 0;
-    })
-  }));
-}
 
 class TimebackAssessmentsService {
   deps;
@@ -128679,6 +129026,7 @@ class TimebackAssessmentsService {
       metadata: {
         ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
         ownerGameSlug: ownership.gameSlug,
+        assessmentKey: input.assessmentKey,
         integrationId,
         subject: integration.subject,
         grade: String(integration.grade),
@@ -128688,6 +129036,7 @@ class TimebackAssessmentsService {
     try {
       const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
         integrationId,
+        assessmentKey: input.assessmentKey,
         qtiTestIdentifier: input.qtiTestIdentifier,
         purpose: input.purpose,
         status: "draft",
@@ -128744,12 +129093,33 @@ class TimebackAssessmentsService {
     const existingRows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
       where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
     });
+    const existingByKey = new Map(existingRows.flatMap((row) => row.assessmentKey ? [[row.assessmentKey, row]] : []));
     const existingByIdentifier = new Map(existingRows.map((row) => [row.qtiTestIdentifier, row]));
-    const validated = await runWithConcurrency(entries, QTI_HYDRATION_CONCURRENCY, async (entry2) => {
+    const validated = await this.validateAssessmentImportEntries(client2, entries, manifest.targetStatus);
+    const results = [];
+    const pendingInserts = this.planAssessmentImports({
+      validated,
+      existingByKey,
+      existingByIdentifier,
+      gameSlug,
+      results
+    });
+    const liveReviewFailures = liveReviewAssessmentImportFailures(manifest.targetStatus, pendingInserts.map(({ entry: entry2 }) => entry2), existingRows);
+    this.recordLiveReviewImportFailures(pendingInserts, liveReviewFailures, gameSlug, results);
+    const attachablePending = pendingInserts.filter(({ entry: entry2 }) => !liveReviewFailures.has(entry2.qtiTestIdentifier));
+    await this.insertImportedAssessments(integrationId, attachablePending, manifest.targetStatus, gameSlug, results);
+    setAttribute("app.assessment.operation", "bulk_attach_existing");
+    setAttribute("app.assessment.bulk_attach.target_status", manifest.targetStatus);
+    setAttribute("app.assessment.bulk_attach.created", results.filter((result) => result.status === "created").length);
+    return { results };
+  }
+  async validateAssessmentImportEntries(client2, entries, targetStatus) {
+    return runWithConcurrency(entries, QTI_HYDRATION_CONCURRENCY, async (entry2) => {
       try {
         const loaded = await loadHydratedQtiTest(client2, entry2.qtiTestIdentifier);
+        assertManagedAssessmentIdentity(loaded.test, entry2.assessmentKey);
         assertAssessmentHasQuestions(loaded.questions.questions);
-        assertPlayableAssessmentImportQuestions(manifest.targetStatus, loaded.questions.questions.map(({ question }) => question));
+        assertPlayableAssessmentImportQuestions(targetStatus, loaded.questions.questions.map(({ question }) => question));
         if (entry2.purpose === "review") {
           assertReviewAssessmentHasStandards(loaded.questions.questions.map(({ question }) => reviewRoutingStandardRefsFromMetadata(question.metadata, {
             customOnly: true
@@ -128760,77 +129130,86 @@ class TimebackAssessmentsService {
         return { entry: entry2, error: error88 };
       }
     });
-    const results = [];
-    const pending = [];
-    for (const validation of validated) {
+  }
+  associationImportResultBase(entry2, test, gameSlug) {
+    return {
+      assessmentKey: entry2.assessmentKey,
+      qtiTestIdentifier: entry2.qtiTestIdentifier,
+      ...test ? { title: test.title } : {},
+      purpose: entry2.purpose,
+      ...entry2.standard ? { standard: entry2.standard } : {},
+      sourceSortOrder: entry2.sortOrder,
+      ...test && gameSlug ? { editable: isQtiTestOwnedByGame(test, gameSlug) } : {}
+    };
+  }
+  planAssessmentImports(input) {
+    const pendingInserts = [];
+    for (const validation of input.validated) {
       const { entry: entry2 } = validation;
-      const { index: index2 } = entry2;
-      const base = {
-        qtiTestIdentifier: entry2.qtiTestIdentifier,
-        purpose: entry2.purpose,
-        ...entry2.standard ? { standard: entry2.standard } : {},
-        sourceSortOrder: entry2.sortOrder
-      };
+      const base = this.associationImportResultBase(entry2, "test" in validation ? validation.test : undefined, input.gameSlug);
       if ("error" in validation) {
-        results[index2] = {
+        input.results[entry2.index] = {
           ...base,
           status: "failed",
           message: `QTI validation failed: ${errorMessage2(validation.error)}`
         };
       } else {
-        const existing = existingByIdentifier.get(entry2.qtiTestIdentifier);
-        const editable = isQtiTestOwnedByGame(validation.test, gameSlug);
-        const hydratedBase = { ...base, title: validation.test.title, editable };
-        if (!existing) {
-          pending.push({ entry: entry2, test: validation.test });
+        const existingForKey = input.existingByKey.get(entry2.assessmentKey);
+        const decision = planAssessmentAssociationImport(entry2, existingForKey, input.existingByIdentifier.get(entry2.qtiTestIdentifier));
+        if (decision.kind === "insert") {
+          pendingInserts.push({ entry: entry2, test: validation.test });
         } else {
-          const decision = classifyExistingAssessmentImport(existing, {
-            purpose: entry2.purpose,
-            ...entry2.standard ? { standard: entry2.standard } : {}
-          }, manifest.targetStatus);
-          results[index2] = {
-            ...hydratedBase,
+          input.results[entry2.index] = {
+            ...base,
             status: decision.status,
-            association: this.associationImportSummary(existing),
+            ...existingForKey ? { association: this.associationImportSummary(existingForKey) } : {},
             message: decision.message
           };
         }
       }
     }
-    const liveReviewFailures = liveReviewAssessmentImportFailures(manifest.targetStatus, pending.map(({ entry: entry2 }) => entry2), existingRows);
+    return pendingInserts;
+  }
+  recordLiveReviewImportFailures(pending, failures, gameSlug, results) {
     for (const { entry: entry2, test } of pending) {
-      const message = liveReviewFailures.get(entry2.qtiTestIdentifier);
+      const message = failures.get(entry2.qtiTestIdentifier);
       if (message) {
         results[entry2.index] = {
-          qtiTestIdentifier: entry2.qtiTestIdentifier,
-          title: test.title,
-          purpose: entry2.purpose,
-          ...entry2.standard ? { standard: entry2.standard } : {},
-          sourceSortOrder: entry2.sortOrder,
-          editable: isQtiTestOwnedByGame(test, gameSlug),
+          ...this.associationImportResultBase(entry2, test, gameSlug),
           status: "failed",
           message
         };
       }
     }
-    const attachablePending = pending.filter(({ entry: entry2 }) => !liveReviewFailures.has(entry2.qtiTestIdentifier));
-    for (const validation of attachablePending) {
-      const { entry: entry2, test } = validation;
-      const { index: index2 } = entry2;
-      const base = {
-        qtiTestIdentifier: entry2.qtiTestIdentifier,
-        title: test.title,
-        purpose: entry2.purpose,
-        ...entry2.standard ? { standard: entry2.standard } : {},
-        sourceSortOrder: entry2.sortOrder,
-        editable: isQtiTestOwnedByGame(test, gameSlug)
+  }
+  async concurrentAssessmentImportDecision(integrationId, entry2) {
+    try {
+      const [byKey, byIdentifier] = await Promise.all([
+        this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+          where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.assessmentKey, entry2.assessmentKey))
+        }),
+        this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+          where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, entry2.qtiTestIdentifier))
+        })
+      ]);
+      return {
+        byKey,
+        decision: planAssessmentAssociationImport(entry2, byKey, byIdentifier)
       };
+    } catch {
+      return null;
+    }
+  }
+  async insertImportedAssessments(integrationId, pending, targetStatus, gameSlug, results) {
+    for (const { entry: entry2, test } of pending) {
+      const base = this.associationImportResultBase(entry2, test, gameSlug);
       try {
         const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
           integrationId,
+          assessmentKey: entry2.assessmentKey,
           qtiTestIdentifier: entry2.qtiTestIdentifier,
           purpose: entry2.purpose,
-          status: manifest.targetStatus,
+          status: targetStatus,
           sortOrder: entry2.sortOrder,
           standardFramework: entry2.standard?.framework,
           standardIdentifier: entry2.standard?.identifier
@@ -128838,51 +129217,37 @@ class TimebackAssessmentsService {
         if (!row) {
           throw new Error("Assessment association create returned no row");
         }
-        results[index2] = {
+        results[entry2.index] = {
           ...base,
           status: "created",
           association: this.associationImportSummary(row),
-          message: attachedAssessmentImportMessage(manifest.targetStatus, base.editable)
+          message: attachedAssessmentImportMessage(targetStatus, base.editable ?? false)
         };
       } catch (error88) {
-        results[index2] = {
+        results[entry2.index] = {
           ...base,
           status: "failed",
           message: `Association attach failed: ${errorMessage2(error88)}`
         };
         if (isUniqueViolation(error88)) {
-          let concurrentAssociation;
-          try {
-            concurrentAssociation = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
-              where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, entry2.qtiTestIdentifier))
-            });
-          } catch {}
-          if (concurrentAssociation) {
-            const decision = classifyExistingAssessmentImport(concurrentAssociation, {
-              purpose: entry2.purpose,
-              ...entry2.standard ? { standard: entry2.standard } : {}
-            }, manifest.targetStatus);
-            results[index2] = {
+          const concurrent = await this.concurrentAssessmentImportDecision(integrationId, entry2);
+          if (concurrent?.decision.kind === "skip" || concurrent?.decision.kind === "fail") {
+            results[entry2.index] = {
               ...base,
-              status: decision.status,
-              association: this.associationImportSummary(concurrentAssociation),
-              message: decision.message
+              status: concurrent.decision.status,
+              ...concurrent.byKey ? { association: this.associationImportSummary(concurrent.byKey) } : {},
+              message: concurrent.decision.message
             };
           }
         }
       }
     }
-    setAttribute("app.assessment.operation", "bulk_attach_existing");
-    setAttribute("app.assessment.bulk_attach.target_status", manifest.targetStatus);
-    setAttribute("app.assessment.bulk_attach.created", results.filter((result) => result.status === "created").length);
-    return { results };
   }
   async updateAssessment(integrationId, qtiTestIdentifier, input) {
     try {
       return await this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
         const nextPurpose = input.purpose ?? row.purpose;
-        assertMasteryPurposeChangeDraft(row, nextPurpose);
-        assertDiagnosticPurposeChangeDraft(row, nextPurpose);
+        assertPurposeChangeDraft(row, nextPurpose);
         const requestedStandard = input.standard ? this.canonicalAssessmentStandard(input.standard) : undefined;
         const nextStandard = requestedStandard ?? (nextPurpose === "mastery" ? assessmentStandardForRow(row) : null);
         this.assertPurposeStandard(nextPurpose, nextStandard);
@@ -128907,7 +129272,10 @@ class TimebackAssessmentsService {
         }
         if (!publishing && !activatingReview && nextPurpose === "review" && row.purpose !== "review") {
           const ownership = await this.requireQtiTestOwnershipContext(integrationId, tx);
-          await this.rebuildReviewMapping(this.requireClient(), qtiTestIdentifier, ownership.gameSlug);
+          await this.rebuildReviewMapping(this.requireClient(), qtiTestIdentifier, {
+            kind: "owned",
+            gameSlug: ownership.gameSlug
+          });
         }
         if (input.title !== undefined) {
           assertDraftAssessment(row);
@@ -128919,16 +129287,24 @@ class TimebackAssessmentsService {
           await client2.qtiApi.assessmentTests.update(qtiTestIdentifier, buildQtiTestUpdateInput(test, input.title));
         }
         if (publishing || activatingReview) {
-          if (nextPurpose === "diagnostic") {
-            if (!nextDiagnostic) {
-              throw new ValidationError("Platform-routed diagnostics require a diagnostic key and routing manifest before publication.");
-            }
-            nextDiagnostic = await this.preparePublishedDiagnosticDefinition(qtiTestIdentifier, nextDiagnostic);
+          if (nextPurpose === "diagnostic" && !nextDiagnostic) {
+            throw new ValidationError("Platform-routed diagnostics require a diagnostic key and routing manifest before publication.");
+          }
+          const loaded = await loadHydratedQtiTest(this.requireClient(), qtiTestIdentifier);
+          if (nextPurpose === "diagnostic" && nextDiagnostic) {
+            nextDiagnostic = await preparePublishedDiagnosticDefinition(nextDiagnostic, loaded);
             updates.diagnosticKey = nextDiagnostic.diagnosticKey;
             updates.diagnosticRoutingManifest = nextDiagnostic.routingManifest;
           } else {
             const reviewOwnership = nextPurpose === "review" && nextStatus === "live" ? await this.requireQtiTestOwnershipContext(integrationId, tx) : undefined;
-            await this.validateAssessmentHasQuestions(qtiTestIdentifier, reviewOwnership?.gameSlug);
+            await this.validateAssessmentHasQuestions(loaded, reviewOwnership?.gameSlug);
+          }
+          if (publishing) {
+            const publication = await this.publishManagedAssessment(row, nextPurpose, nextDiagnostic?.routingManifest ?? null, loaded);
+            updates.qtiTestIdentifier = publication.qtiTestIdentifier;
+            if (nextPurpose === "diagnostic") {
+              updates.diagnosticRoutingManifest = publication.diagnosticRoutingManifest;
+            }
           }
         }
         let updated = row;
@@ -129024,13 +129400,14 @@ class TimebackAssessmentsService {
     return { ...result, questions };
   }
   async updateReviewMapping(integrationId, qtiTestIdentifier) {
-    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (_row, _tx, associations) => {
       if (!associations.some((association) => association.purpose === "review")) {
         throw new ValidationError("Review mapping is available only for standards-review assessments.");
       }
       const client2 = this.requireClient();
-      const ownership = await this.requireQtiTestOwnershipContext(integrationId, tx);
-      const result = await this.rebuildReviewMapping(client2, qtiTestIdentifier, ownership.gameSlug);
+      const result = await this.rebuildReviewMapping(client2, qtiTestIdentifier, {
+        kind: "live-review-repair"
+      });
       setAttribute("app.assessment.operation", "update_review_mapping");
       setAttribute("app.assessment.review_mapping_item_count", result.itemCount);
       return result;
@@ -129046,7 +129423,14 @@ class TimebackAssessmentsService {
     await this.requireIntegration(integrationId);
     return this.listQtiLibrary(params, async (listParams) => await client2.qtiApi.assessmentTests.list(listParams));
   }
-  async copyAssessment(integrationId, sourceTestIdentifier, targetTestIdentifier, purpose, standardInput) {
+  async copyAssessment(integrationId, input) {
+    const {
+      sourceTestIdentifier,
+      targetTestIdentifier,
+      assessmentKey,
+      purpose,
+      standard: standardInput
+    } = input;
     if (purpose === "diagnostic") {
       throw new ValidationError("Adaptive diagnostics must be created by importing assessment JSON with a routing sidecar.");
     }
@@ -129073,6 +129457,7 @@ class TimebackAssessmentsService {
       ...source.metadata,
       ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
       ownerGameSlug: ownership.gameSlug,
+      assessmentKey,
       integrationId,
       subject: integration.subject,
       grade: String(integration.grade),
@@ -129095,6 +129480,7 @@ class TimebackAssessmentsService {
       associationCreationAttempted = true;
       const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
         integrationId,
+        assessmentKey,
         qtiTestIdentifier: targetTestIdentifier,
         purpose,
         status: "draft",
@@ -129389,6 +129775,50 @@ class TimebackAssessmentsService {
   qtiItemHref(client2, itemIdentifier) {
     return `${client2.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
   }
+  async ensureImmutableQtiResource(get, create) {
+    try {
+      return await get();
+    } catch (error88) {
+      if (!isApiError(error88) || error88.statusCode !== 404) {
+        throw error88;
+      }
+    }
+    try {
+      await create();
+    } catch (error88) {
+      if (!isApiError(error88) || error88.statusCode !== 409) {
+        throw error88;
+      }
+    }
+    return get();
+  }
+  async ensureManagedQtiPublication(client2, plan) {
+    await runWithConcurrency(plan.items, QTI_HYDRATION_CONCURRENCY, async (plannedItem) => {
+      const existing = await this.ensureImmutableQtiResource(async () => await client2.qtiApi.assessmentItems.get(plannedItem.qtiItemIdentifier), () => client2.course.createAssessmentItemXml({
+        xml: plannedItem.xml,
+        metadata: plannedItem.metadata
+      }));
+      await assertManagedAssessmentItem(existing, plannedItem);
+    });
+    const existingTest = await this.ensureImmutableQtiResource(async () => await client2.qtiApi.assessmentTests.get(plan.qtiTestIdentifier), () => client2.qtiApi.assessmentTests.create(plan.testInput));
+    assertManagedAssessmentPublication(existingTest, plan);
+  }
+  async publishManagedAssessment(row, purpose, diagnosticRoutingManifest, loaded) {
+    if (!row.assessmentKey) {
+      throw new ValidationError("This unmanaged assessment cannot be published. Republish it with an explicit assessment key.");
+    }
+    const client2 = this.requireClient();
+    const plan = await prepareManagedAssessmentPublication({
+      assessmentKey: row.assessmentKey,
+      purpose,
+      test: loaded.test,
+      questions: loaded.questions,
+      diagnosticRoutingManifest,
+      itemHref: (identifier) => this.qtiItemHref(client2, identifier)
+    });
+    await this.ensureManagedQtiPublication(client2, plan);
+    return plan;
+  }
   async cleanupQtiAssessmentCopy(client2, testIdentifier, itemIdentifiers) {
     let testDeleted = !testIdentifier;
     if (testIdentifier) {
@@ -129424,6 +129854,7 @@ class TimebackAssessmentsService {
     return {
       id: row.id,
       integrationId: row.integrationId,
+      assessmentKey: row.assessmentKey,
       qtiTestIdentifier: row.qtiTestIdentifier,
       purpose: row.purpose,
       status: row.status,
@@ -129465,20 +129896,14 @@ class TimebackAssessmentsService {
     const plan = buildQtiLibraryListPlan(params);
     return list(plan.params);
   }
-  async validateAssessmentHasQuestions(qtiTestIdentifier, reviewGameSlug) {
-    const client2 = this.requireClient();
-    const [test, result] = await Promise.all([
-      client2.qtiApi.assessmentTests.get(qtiTestIdentifier),
-      client2.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier)
-    ]);
-    assertAssessmentHasQuestions(result.questions);
-    const hydrated = await hydrateQtiTestQuestions(client2, result);
-    for (const { question } of hydrated.questions) {
+  async validateAssessmentHasQuestions(loaded, reviewGameSlug) {
+    assertAssessmentHasQuestions(loaded.questions.questions);
+    for (const { question } of loaded.questions.questions) {
       assertPlayableQtiQuestion(question);
     }
     if (reviewGameSlug) {
-      assertQtiTestOwnedByGame(test, reviewGameSlug);
-      await this.writeReviewMapping(client2, test, hydrated);
+      assertQtiTestOwnedByGame(loaded.test, reviewGameSlug);
+      await this.writeReviewMapping(this.requireClient(), loaded.test, loaded.questions);
     }
   }
   async prepareDiagnosticAssociationChanges(row, nextPurpose, requested) {
@@ -129495,7 +129920,7 @@ class TimebackAssessmentsService {
     if (requested === null || nextPurpose !== "diagnostic") {
       nextDiagnostic = null;
     } else if (requested) {
-      nextDiagnostic = await this.prepareDiagnosticDefinition(requested);
+      nextDiagnostic = prepareDiagnosticDefinition(requested);
     }
     if (requested === undefined && nextPurpose === row.purpose) {
       return { nextDiagnostic, updates: {} };
@@ -129508,47 +129933,14 @@ class TimebackAssessmentsService {
       }
     };
   }
-  prepareDiagnosticDefinition(input) {
-    const diagnosticKey = input.diagnosticKey.trim();
-    if (!diagnosticKey || diagnosticKey.length > 200) {
-      throw new ValidationError("Diagnostic key must contain between 1 and 200 characters");
-    }
-    const validation = validateDiagnosticRoutingManifest(input.routingManifest, undefined, {
-      analyzeBounds: false
-    });
-    if (!validation.valid || !validation.manifest) {
-      const details = validation.errors.slice(0, 3).map((issue7) => issue7.message).join(" ");
-      throw new ValidationError(`Diagnostic routing manifest is invalid.${details ? ` ${details}` : ""}`);
-    }
-    return {
-      diagnosticKey,
-      routingManifest: validation.manifest
-    };
-  }
-  async preparePublishedDiagnosticDefinition(qtiTestIdentifier, definition) {
-    const loaded = await loadHydratedQtiTest(this.requireClient(), qtiTestIdentifier);
-    assertAssessmentHasQuestions(loaded.questions.questions);
-    for (const { question } of loaded.questions.questions) {
-      assertPlayableQtiQuestion(question);
-    }
-    const assessment = await buildPlayableAssessment(loaded.test, loaded.questions);
-    const scoring = assessmentFixtureScoringKeys(assessment, loaded.questions);
-    const validation = validateDiagnosticRoutingManifest(definition.routingManifest, diagnosticRoutingCapabilities(assessment, scoring));
-    if (!validation.valid || !validation.manifest) {
-      const details = validation.errors.slice(0, 3).map((issue7) => issue7.message).join(" ");
-      throw new ValidationError(`Diagnostic routing manifest cannot be published.${details ? ` ${details}` : ""}`);
-    }
-    return {
-      diagnosticKey: definition.diagnosticKey,
-      routingManifest: validation.manifest
-    };
-  }
-  async rebuildReviewMapping(client2, qtiTestIdentifier, gameSlug) {
+  async rebuildReviewMapping(client2, qtiTestIdentifier, scope) {
     const [test, references] = await Promise.all([
       client2.qtiApi.assessmentTests.get(qtiTestIdentifier),
       client2.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier)
     ]);
-    assertQtiTestOwnedByGame(test, gameSlug);
+    if (scope.kind === "owned") {
+      assertQtiTestOwnedByGame(test, scope.gameSlug);
+    }
     return this.writeReviewMapping(client2, test, await hydrateQtiTestQuestions(client2, references));
   }
   async writeReviewMapping(client2, test, questions) {
@@ -129565,9 +129957,10 @@ var init_timeback_assessments_service = __esm(async () => {
   init_assessment_runtime2();
   init_timeback3();
   init_errors2();
+  init_timeback_assessment_diagnostic_util();
   init_timeback_assessment_import_util();
+  init_timeback_assessment_publication_util();
   init_timeback_assessment_rules_util();
-  init_timeback_assessment_runtime_util();
   init_timeback_qti_authoring_util();
   init_timeback_qti_hydration_util();
   init_timeback_review_mapping_util();
@@ -192875,6 +193268,7 @@ var init_timeback_controller = __esm(() => {
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
     const qtiTestIdentifier = newPlaycademyTestIdentifier();
     return ctx.services.timebackAssessments.createAssessment(integrationId, {
+      assessmentKey: body2.assessmentKey,
       title: body2.title,
       purpose: body2.purpose,
       standard: body2.standard,
@@ -192969,7 +193363,13 @@ var init_timeback_controller = __esm(() => {
     const body2 = await parseRequestBody(ctx.request, CopyAssessmentRequestSchema);
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
     const targetTestIdentifier = newPlaycademyTestIdentifier();
-    return ctx.services.timebackAssessments.copyAssessment(integrationId, body2.testIdentifier, targetTestIdentifier, body2.purpose, body2.standard);
+    return ctx.services.timebackAssessments.copyAssessment(integrationId, {
+      sourceTestIdentifier: body2.testIdentifier,
+      targetTestIdentifier,
+      assessmentKey: body2.assessmentKey,
+      purpose: body2.purpose,
+      standard: body2.standard
+    });
   });
   createQuestion = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;