@playcademy/sandbox 0.8.1-beta.3 → 0.8.1-beta.4

package/dist/server.js

@@ -1127,7 +1127,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.8.1-beta.3",
+    version: "0.8.1-beta.4",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -11564,7 +11564,7 @@ function playcademyDiagnosticAssessmentItemResultMetadata(value) {
   const normalized = metadata2.responses === undefined ? { ...metadata2, responses: {} } : metadata2;
   return isPlaycademyDiagnosticAssessmentItemResultMetadataV1(normalized) ? normalized : null;
 }
-var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_ATTEMPT_AWAITING_AWARD, ASSESSMENT_ATTEMPT_SUPERSEDED, ASSESSMENT_RUNTIME_ERROR_STATUS, ROUTING_KEY_MAX_LENGTH = 128, ROUTING_RESULT_KEY_MAX_LENGTH = 256, ROUTING_STAGE_LIMIT = 32, ROUTING_TRACK_LIMIT = 128, ROUTING_NODE_LIMIT = 1000, ROUTING_TERMINAL_LIMIT = 1000, ROUTING_GROUP_LIMIT = 128, ROUTING_PREDICATE_DEPTH_LIMIT = 8, ROUTING_EXPLORATION_STATE_LIMIT = 200000, RoutingKeySchema, RoutingResultKeySchema, DiagnosticTrackOutcomeSchema, DiagnosticActivationPredicateSchema, DiagnosticRoutingTransitionSchema, DiagnosticRoutingManifestV1Schema, GRADE_VALUES, POINT_RESPONSE_PATTERN, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank", PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1, DEFAULT_REVIEW_SELECTION_POLICY, ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 8, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema, AssessmentRuntimeIdentitySchema, ResponseKeySchema, StartAssessmentBaseSchema, AssessmentStandardRefSchema, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, SaveAssessmentBodySchema, SubmitAssessmentItemBodySchema, SubmitAssessmentBodySchema, FinalizeAssessmentBodySchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, SubmitAssessmentItemRuntimeRequestSchema, SubmitRuntimeAssessmentRequestSchema, FinalizeRuntimeAssessmentRequestSchema;
+var SCRIPT_SCHEMES, DATA_RASTER_IMAGE_PATTERN, QTI_MATHML_ALLOWED_TAGS, metadataSymbol, parser, SUPPORTED_QTI_INTERACTION_TYPES, URL_ATTRIBUTES, IMAGE_URL_ATTRIBUTES, INTERACTION_TYPES, EMPHASIS_TAGS, STRONG_TAGS, CONTENT_SKIPPED_TAGS, BLOCK_CONTENT_KINDS, GAP_MATCH_TOKEN_TAGS, STAGE_GRAPHIC_EXCLUDED_CONTAINERS, BLANK_SENTINEL = "￿", MARKED_BLANK_PATTERN, MARKED_BLANK_GLOBAL_PATTERN, MATCH_CORRECT_TEMPLATE = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES, RESPONSE_PROCESSING_TEMPLATES, VOID_BODY_ELEMENTS, URL_ATTRIBUTES2, IMAGE_URL_ATTRIBUTES2, VOID_CHOICE_ELEMENTS, NUMERIC_COMPARISON_ATTRIBUTES, RESPONSE_CARDINALITIES, RESPONSE_BASE_TYPES, POINT_INTERACTION_TYPES, INDEPENDENT_PROCESSING_TAGS, SUPPORTED_BASE_TYPES, SUPPORTED_CARDINALITIES, MATCH_CORRECT_TEMPLATES, UUID_PATTERN, COMMON_CORE_MATH_FRAMEWORK_ALIASES, COMMON_CORE_ELA_FRAMEWORK_ALIASES, COMMON_CORE_FRAMEWORK_ALIASES, ASSESSMENT_ATTEMPT_OPEN, ASSESSMENT_ATTEMPT_COMPLETED, ASSESSMENT_ATTEMPT_AWAITING_AWARD, ASSESSMENT_ATTEMPT_SUPERSEDED, ASSESSMENT_RUNTIME_ERROR_STATUS, ROUTING_KEY_MAX_LENGTH = 128, ROUTING_RESULT_KEY_MAX_LENGTH = 256, ROUTING_STAGE_LIMIT = 32, ROUTING_TRACK_LIMIT = 128, ROUTING_NODE_LIMIT = 1000, ROUTING_TERMINAL_LIMIT = 1000, ROUTING_GROUP_LIMIT = 128, ROUTING_PREDICATE_DEPTH_LIMIT = 8, ROUTING_EXPLORATION_STATE_LIMIT = 200000, RoutingKeySchema, RoutingResultKeySchema, DiagnosticTrackOutcomeSchema, DiagnosticActivationPredicateSchema, DiagnosticRoutingTransitionSchema, DiagnosticRoutingManifestV1Schema, GRADE_VALUES, POINT_RESPONSE_PATTERN, REVIEW_SELECTION_POLICY_VERSION = "unseen-first-least-recently-delivered-v1", PLAYCADEMY_REVIEW_BANK_MANIFEST_METADATA_KEY = "playcademyReviewBank", PLAYCADEMY_REVIEW_BANK_MANIFEST_VERSION = 1, DEFAULT_REVIEW_SELECTION_POLICY, ASSESSMENT_RUNTIME_FIXTURE_BUNDLE_VERSION = 8, RuntimeSubjectSchema, RuntimeGradeSchema, OptionalQueryGradeSchema, AssessmentResponseValueSchema, AssessmentRuntimeIdentitySchema, ResponseKeySchema, StartAssessmentBaseSchema, AssessmentStandardRefSchema, LatestAssessmentFilterBaseSchema, LatestAssessmentFiltersSchema, LatestRuntimeAssessmentQuerySchema, StartAssessmentBodySchema, AssessmentPreparationReceiptSchema, StartAssessmentRequestBodySchema, SaveAssessmentBodySchema, SubmitAssessmentItemBodySchema, SubmitAssessmentBodySchema, FinalizeAssessmentBodySchema, PrepareRuntimeAssessmentRequestSchema, StartRuntimeAssessmentRequestSchema, SaveRuntimeAssessmentRequestSchema, SubmitAssessmentItemRuntimeRequestSchema, SubmitRuntimeAssessmentRequestSchema, FinalizeRuntimeAssessmentRequestSchema;
 var init_assessment_runtime2 = __esm(() => {
   init_timeback3();
   init_timeback3();
@@ -11718,6 +11718,23 @@ var init_assessment_runtime2 = __esm(() => {
     "qti-sum",
     "qti-base-value"
   ]);
+  SUPPORTED_BASE_TYPES = new Set([
+    "string",
+    "identifier",
+    "integer",
+    "float",
+    "directedPair"
+  ]);
+  SUPPORTED_CARDINALITIES = new Set([
+    "single",
+    "multiple",
+    "ordered"
+  ]);
+  MATCH_CORRECT_TEMPLATES = new Set([
+    "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct",
+    "https://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct",
+    "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/match_correct"
+  ].flatMap((template) => [template, `${template}.xml`]));
   UUID_PATTERN = /^(?:urn:uuid:)?\{?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}?$/i;
   COMMON_CORE_MATH_FRAMEWORK_ALIASES = new Set([
     "ccssm",
@@ -11894,6 +11911,8 @@ var init_assessment_runtime2 = __esm(() => {
       standard: AssessmentStandardRefSchema
     })
   ]);
+  AssessmentPreparationReceiptSchema = exports_external.string().max(32000);
+  StartAssessmentRequestBodySchema = exports_external.intersection(StartAssessmentBodySchema, exports_external.object({ preparationReceipt: AssessmentPreparationReceiptSchema.optional() }));
   SaveAssessmentBodySchema = exports_external.object({
     expectedResponseVersion: exports_external.number().int().nonnegative(),
     responses: exports_external.record(ResponseKeySchema, exports_external.record(ResponseKeySchema, AssessmentResponseValueSchema.nullable()))
@@ -11921,7 +11940,8 @@ var init_assessment_runtime2 = __esm(() => {
     message: "Provide either masteredUnits or masteredUnitsAbsolute, not both",
     path: ["masteredUnits"]
   });
-  StartRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentBodySchema);
+  PrepareRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentBodySchema);
+  StartRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.and(StartAssessmentRequestBodySchema);
   SaveRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SaveAssessmentBodySchema.shape);
   SubmitAssessmentItemRuntimeRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentItemBodySchema.shape);
   SubmitRuntimeAssessmentRequestSchema = AssessmentRuntimeIdentitySchema.extend(SubmitAssessmentBodySchema.shape).extend({
@@ -12449,6 +12469,7 @@ var init_schema = __esm(() => {
     ltiTestMode: exports_external.boolean().default(false),
     platformServiceJwt: platformServiceJwtConfigSchema.optional(),
     uploadBucket: exports_external.string().optional(),
+    assessmentArtifactBucket: exports_external.string().optional(),
     cdnOrigin: exports_external.string().url().startsWith("https://").optional(),
     queueIngressSecret: exports_external.string().optional(),
     secretsManifestPepper: exports_external.string().optional()
@@ -38528,6 +38549,319 @@ var init_infra2 = __esm(() => {
   init_kv_backup_service();
 });
 
+// ../api-core/src/utils/assessment-artifact-envelope.util.ts
+function nonEmptyIdentityValue(value) {
+  return typeof value === "string" && value.length > 0 && value === value.trim();
+}
+function assessmentArtifactPairKeys(identity) {
+  assertAssessmentArtifactIdentity(identity);
+  const identitySegments = identity.kind === "assessment" ? ["qti", identity.qtiTestIdentifier] : [
+    "review",
+    identity.qtiTestIdentifier,
+    identity.sourceContentRevision,
+    identity.bankRevision
+  ];
+  const identityPath = identitySegments.map(encodeURIComponent).join("/");
+  const versionPath = `artifact-v${ASSESSMENT_ARTIFACT_SCHEMA_VERSION}/grader-v${ASSESSMENT_GRADER_PROTOCOL_VERSION}`;
+  const prefix = `${ARTIFACT_KEY_PREFIX}/${identityPath}/${versionPath}`;
+  return {
+    playable: `${prefix}/playable.json`,
+    scoring: `${prefix}/scoring.json`
+  };
+}
+function jsonValidationMessage(value, path, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return null;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? null : `${path} must contain a finite number`;
+  }
+  if (typeof value !== "object") {
+    return `${path} is not JSON-serializable`;
+  }
+  if (ancestors.has(value)) {
+    return `${path} contains a circular reference`;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    return `${path} must contain only plain JSON objects`;
+  }
+  if (Array.isArray(value) && (Object.keys(value).length !== value.length || Object.keys(value).some((key, index2) => key !== String(index2)) || Reflect.ownKeys(value).length !== value.length + 1)) {
+    return `${path} must contain a dense JSON array`;
+  }
+  if (!Array.isArray(value) && Reflect.ownKeys(value).length !== Object.keys(value).length) {
+    return `${path} contains non-JSON object properties`;
+  }
+  ancestors.add(value);
+  const entries = Array.isArray(value) ? value.map((entry, index2) => [String(index2), entry]) : Object.entries(value);
+  for (const [key, entry] of entries) {
+    const message = jsonValidationMessage(entry, `${path}.${key}`, ancestors);
+    if (message) {
+      ancestors.delete(value);
+      return message;
+    }
+  }
+  ancestors.delete(value);
+  return null;
+}
+function assertJsonValue(value, path) {
+  const message = jsonValidationMessage(value, path, new Set);
+  if (message) {
+    throw new ValidationError(message);
+  }
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactlyKeys(value, keys) {
+  const actual = Object.keys(value).toSorted();
+  const expected = [...keys].toSorted();
+  return actual.length === expected.length && actual.every((key, index2) => key === expected[index2]);
+}
+function assertAssessmentArtifactIdentity(identity) {
+  if (!isRecord6(identity) || !nonEmptyIdentityValue(identity.qtiTestIdentifier)) {
+    throw new ValidationError("Assessment artifact identity is invalid");
+  }
+  if (identity.kind === "assessment" && hasExactlyKeys(identity, ["kind", "qtiTestIdentifier", "contentRevision"]) && nonEmptyIdentityValue(identity.contentRevision)) {
+    return;
+  }
+  if (identity.kind === "review-bank" && hasExactlyKeys(identity, [
+    "kind",
+    "qtiTestIdentifier",
+    "sourceContentRevision",
+    "bankRevision"
+  ]) && nonEmptyIdentityValue(identity.sourceContentRevision) && nonEmptyIdentityValue(identity.bankRevision)) {
+    return;
+  }
+  throw new ValidationError("Assessment artifact identity is invalid");
+}
+function envelopeWithoutChecksum({
+  checksum: _checksum,
+  ...content
+}) {
+  return content;
+}
+async function prepareAssessmentArtifact(input) {
+  assertAssessmentArtifactIdentity(input.identity);
+  assertJsonValue(input.payload, "Assessment artifact payload");
+  const content = {
+    artifactKind: input.artifactKind,
+    artifactSchemaVersion: ASSESSMENT_ARTIFACT_SCHEMA_VERSION,
+    graderProtocolVersion: ASSESSMENT_GRADER_PROTOCOL_VERSION,
+    identity: input.identity,
+    payload: input.payload
+  };
+  const checksum = await sha256Hex(canonicalJson2(content));
+  const envelope = {
+    ...content,
+    checksum: { algorithm: "sha256", value: checksum }
+  };
+  return {
+    envelope,
+    bytes: textEncoder.encode(canonicalJson2(envelope)),
+    key: assessmentArtifactPairKeys(input.identity)[input.artifactKind]
+  };
+}
+function parseEnvelope(value) {
+  if (!isRecord6(value) || !hasExactlyKeys(value, [
+    "artifactKind",
+    "artifactSchemaVersion",
+    "graderProtocolVersion",
+    "identity",
+    "checksum",
+    "payload"
+  ]) || value.artifactKind !== "playable" && value.artifactKind !== "scoring" || value.artifactSchemaVersion !== ASSESSMENT_ARTIFACT_SCHEMA_VERSION || value.graderProtocolVersion !== ASSESSMENT_GRADER_PROTOCOL_VERSION) {
+    throw new ValidationError("Assessment artifact envelope is invalid or incompatible");
+  }
+  assertAssessmentArtifactIdentity(value.identity);
+  if (!isRecord6(value.checksum) || !hasExactlyKeys(value.checksum, ["algorithm", "value"]) || value.checksum.algorithm !== "sha256" || typeof value.checksum.value !== "string" || !SHA256_HEX.test(value.checksum.value)) {
+    throw new ValidationError("Assessment artifact checksum is invalid");
+  }
+  assertJsonValue(value.payload, "Assessment artifact payload");
+  return value;
+}
+async function verifyAssessmentArtifactBytes(bytes) {
+  let source;
+  let parsed;
+  try {
+    source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    parsed = JSON.parse(source);
+  } catch {
+    throw new ValidationError("Assessment artifact is not valid UTF-8 JSON");
+  }
+  const envelope = parseEnvelope(parsed);
+  const canonicalEnvelope = canonicalJson2(envelope);
+  if (source !== canonicalEnvelope) {
+    throw new ValidationError("Assessment artifact bytes are not canonically encoded");
+  }
+  const expectedChecksum = await sha256Hex(canonicalJson2(envelopeWithoutChecksum(envelope)));
+  if (envelope.checksum.value !== expectedChecksum) {
+    throw new ValidationError("Assessment artifact checksum does not match its contents");
+  }
+  return envelope;
+}
+function assessmentArtifactIdentitiesMatch(left, right) {
+  return canonicalJson2(left) === canonicalJson2(right);
+}
+function assertMatchingAssessmentArtifactPair(playable, scoring, expectedIdentity) {
+  if (playable.artifactKind !== "playable" || scoring.artifactKind !== "scoring" || playable.artifactSchemaVersion !== scoring.artifactSchemaVersion || playable.graderProtocolVersion !== scoring.graderProtocolVersion || !assessmentArtifactIdentitiesMatch(playable.identity, scoring.identity) || expectedIdentity && !assessmentArtifactIdentitiesMatch(playable.identity, expectedIdentity)) {
+    throw new ValidationError("Assessment artifact pair does not describe one revision");
+  }
+}
+var ASSESSMENT_ARTIFACT_SCHEMA_VERSION = 1, ASSESSMENT_GRADER_PROTOCOL_VERSION = 1, ARTIFACT_KEY_PREFIX = "assessment-artifacts", SHA256_HEX, textEncoder;
+var init_assessment_artifact_envelope_util = __esm(() => {
+  init_errors2();
+  SHA256_HEX = /^[a-f0-9]{64}$/;
+  textEncoder = new TextEncoder;
+});
+
+// ../api-core/src/utils/assessment-artifact-storage.util.ts
+function requireBucketName(deps) {
+  const bucketName = deps.bucketName?.trim();
+  if (!bucketName) {
+    throw new ServiceUnavailableError("Assessment artifact storage is not configured");
+  }
+  return bucketName;
+}
+function bytesEqual(left, right) {
+  return left.length === right.length && left.every((byte, index2) => byte === right[index2]);
+}
+async function holdsExpectedBytes(deps, bucketName, artifact) {
+  const stored = await deps.storage.getObject(bucketName, artifact.key);
+  if (!stored) {
+    return false;
+  }
+  if (!bytesEqual(stored.body, artifact.bytes)) {
+    throw new ConflictError("Immutable assessment artifact key contains different bytes", {
+      key: artifact.key
+    });
+  }
+  return true;
+}
+async function ensureStored(deps, bucketName, artifact, alreadyStored) {
+  const created = !alreadyStored && await deps.storage.putObjectIfAbsent(bucketName, artifact.key, artifact.bytes, {
+    contentType: "application/json"
+  });
+  if (!await holdsExpectedBytes(deps, bucketName, artifact)) {
+    throw new ServiceUnavailableError("Assessment artifact disappeared during storage", {
+      key: artifact.key
+    });
+  }
+  return created ? "created" : "existing";
+}
+async function storeAssessmentArtifactPair(deps, input) {
+  const bucketName = requireBucketName(deps);
+  const [playable, scoring] = await Promise.all([
+    prepareAssessmentArtifact({
+      artifactKind: "playable",
+      identity: input.identity,
+      payload: input.playablePayload
+    }),
+    prepareAssessmentArtifact({
+      artifactKind: "scoring",
+      identity: input.identity,
+      payload: input.scoringPayload
+    })
+  ]);
+  const [playableStored, scoringStored] = await Promise.all([
+    holdsExpectedBytes(deps, bucketName, playable),
+    holdsExpectedBytes(deps, bucketName, scoring)
+  ]);
+  const playableStatus = await ensureStored(deps, bucketName, playable, playableStored);
+  const scoringStatus = await ensureStored(deps, bucketName, scoring, scoringStored);
+  const [storedPlayable, storedScoring] = await Promise.all([
+    verifyAssessmentArtifactBytes(playable.bytes),
+    verifyAssessmentArtifactBytes(scoring.bytes)
+  ]);
+  assertMatchingAssessmentArtifactPair(storedPlayable, storedScoring, input.identity);
+  return {
+    playable: {
+      key: playable.key,
+      checksum: playable.envelope.checksum.value,
+      status: playableStatus
+    },
+    scoring: {
+      key: scoring.key,
+      checksum: scoring.envelope.checksum.value,
+      status: scoringStatus
+    }
+  };
+}
+async function loadAssessmentArtifactPair(deps, identity) {
+  const bucketName = requireBucketName(deps);
+  const keys = assessmentArtifactPairKeys(identity);
+  const [playableObject, scoringObject] = await Promise.all([
+    deps.storage.getObject(bucketName, keys.playable),
+    deps.storage.getObject(bucketName, keys.scoring)
+  ]);
+  if (!playableObject || !scoringObject) {
+    return null;
+  }
+  const [playable, scoring] = await Promise.all([
+    verifyAssessmentArtifactBytes(playableObject.body),
+    verifyAssessmentArtifactBytes(scoringObject.body)
+  ]);
+  assertMatchingAssessmentArtifactPair(playable, scoring, identity);
+  return {
+    playable,
+    scoring
+  };
+}
+async function loadVerifiedArtifact(deps, key) {
+  const bucketName = requireBucketName(deps);
+  const object = await deps.storage.getObject(bucketName, key);
+  return object ? verifyAssessmentArtifactBytes(object.body) : null;
+}
+async function loadAssessmentArtifact(deps, artifactKind, identity) {
+  const artifact = await loadVerifiedArtifact(deps, assessmentArtifactPairKeys(identity)[artifactKind]);
+  if (artifact && (artifact.artifactKind !== artifactKind || !assessmentArtifactIdentitiesMatch(artifact.identity, identity))) {
+    throw new ValidationError("Assessment artifact does not describe the requested revision");
+  }
+  return artifact;
+}
+async function loadManagedPlayableArtifact(deps, qtiTestIdentifier) {
+  const key = assessmentArtifactPairKeys({
+    kind: "assessment",
+    qtiTestIdentifier,
+    contentRevision: "unbound-managed-lookup"
+  }).playable;
+  const artifact = await loadVerifiedArtifact(deps, key);
+  if (artifact && (artifact.artifactKind !== "playable" || artifact.identity.kind !== "assessment" || artifact.identity.qtiTestIdentifier !== qtiTestIdentifier)) {
+    throw new ValidationError("Assessment artifact does not describe the requested assessment");
+  }
+  return artifact;
+}
+var init_assessment_artifact_storage_util = __esm(() => {
+  init_errors2();
+  init_assessment_artifact_envelope_util();
+});
+
+// ../api-core/src/services/assessment-artifacts.service.ts
+class AssessmentArtifactsService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  storePair(input) {
+    return storeAssessmentArtifactPair(this.deps, input);
+  }
+  loadPair(identity) {
+    return loadAssessmentArtifactPair(this.deps, identity);
+  }
+  loadPlayable(identity) {
+    return loadAssessmentArtifact(this.deps, "playable", identity);
+  }
+  loadScoring(identity) {
+    return loadAssessmentArtifact(this.deps, "scoring", identity);
+  }
+  loadManagedPlayable(qtiTestIdentifier) {
+    return loadManagedPlayableArtifact(this.deps, qtiTestIdentifier);
+  }
+}
+var init_assessment_artifacts_service = __esm(() => {
+  init_assessment_artifact_storage_util();
+});
+
 // ../../node_modules/.bun/sharp@0.34.2/node_modules/sharp/lib/is.js
 var require_is = __commonJS((exports, module2) => {
   var defined = function(val) {
@@ -95656,6 +95990,365 @@ function supportedQtiQuestionInteractionType(question) {
     return null;
   }
 }
+function childElements(node, localName2) {
+  return node.children.filter((child) => child.kind === "element" && (!localName2 || child.localName === localName2));
+}
+function onlyWhitespaceText(nodes) {
+  return nodes.every((node) => node.kind === "element" || node.value.trim() === "");
+}
+function onlyAttributes(node, allowed) {
+  const names = Object.keys(node.attributes);
+  return names.length === allowed.length && names.every((name3) => allowed.includes(name3));
+}
+function directText(node) {
+  if (childElements(node).length > 0) {
+    return null;
+  }
+  return node.children.map((child) => child.kind === "text" ? child.value : "").join("").trim();
+}
+function itemElement(root) {
+  return root.localName === "qti-assessment-item" ? root : xmlDescendants(root, (candidate) => candidate.localName === "qti-assessment-item")[0];
+}
+function fallback(itemIdentifier, maxScore, reason) {
+  return {
+    strategy: "qti",
+    itemIdentifier,
+    maxScore,
+    reason
+  };
+}
+function parsedNumericValue(value, baseType) {
+  const syntax = baseType === "integer" ? /^[+-]?\d+$/ : /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+  if (!syntax.test(value.trim())) {
+    return null;
+  }
+  const numeric3 = Number(value);
+  return Number.isFinite(numeric3) && (baseType !== "integer" || Number.isSafeInteger(numeric3)) ? numeric3 : null;
+}
+function numericCorrectValue(declaration) {
+  if (declaration.cardinality !== "single" || declaration.correctValues.length !== 1 || declaration.baseType !== "integer" && declaration.baseType !== "float") {
+    return null;
+  }
+  return parsedNumericValue(declaration.correctValues[0], declaration.baseType);
+}
+function declarationResult(raw, normalized) {
+  const identifier = raw.attributes.identifier?.trim();
+  if (!normalized || !identifier || normalized.identifier !== identifier) {
+    return { reason: "invalid-correct-response" };
+  }
+  const cardinality = (raw.attributes.cardinality || "single").trim();
+  if (!SUPPORTED_CARDINALITIES2.has(cardinality)) {
+    return { reason: "unsupported-cardinality" };
+  }
+  const baseType = (raw.attributes["base-type"] || "string").trim();
+  if (!SUPPORTED_BASE_TYPES2.has(baseType)) {
+    return { reason: "unsupported-base-type" };
+  }
+  if (baseType === "directedPair" && cardinality !== "multiple") {
+    return { reason: "unsupported-cardinality" };
+  }
+  const declaration = {
+    identifier,
+    cardinality,
+    baseType,
+    correctValues: [...normalized.correctValues]
+  };
+  if (declaration.correctValues.length === 0 || declaration.correctValues.some((value) => value.trim() === "") || declaration.cardinality === "single" && declaration.correctValues.length !== 1 && declaration.baseType !== "string") {
+    return { reason: "invalid-correct-response" };
+  }
+  if (declaration.baseType === "directedPair" && (declaration.correctValues.some((value) => !DIRECTED_PAIR_VALUE.test(value)) || new Set(declaration.correctValues).size !== declaration.correctValues.length)) {
+    return { reason: "invalid-correct-response" };
+  }
+  if ((declaration.baseType === "integer" || declaration.baseType === "float") && declaration.correctValues.some((value) => parsedNumericValue(value, declaration.baseType) === null)) {
+    return { reason: "invalid-correct-response" };
+  }
+  return { declaration };
+}
+function scoringDeclarations(rawDeclarations, normalizedDeclarations) {
+  const rawIdentifiers = rawDeclarations.map((declaration) => declaration.attributes.identifier?.trim());
+  if (rawDeclarations.length !== normalizedDeclarations.length || rawIdentifiers.some((identifier) => !identifier) || new Set(rawIdentifiers).size !== rawIdentifiers.length) {
+    return { reason: "invalid-correct-response" };
+  }
+  const declarations = new Map;
+  for (const [index2, rawDeclaration] of rawDeclarations.entries()) {
+    const normalized = normalizedDeclarations[index2];
+    if (normalized?.correctValues.length) {
+      const result = declarationResult(rawDeclaration, normalized);
+      if ("reason" in result) {
+        return result;
+      }
+      if (declarations.has(result.declaration.identifier)) {
+        return { reason: "invalid-correct-response" };
+      }
+      declarations.set(result.declaration.identifier, result.declaration);
+    }
+  }
+  return declarations.size > 0 ? { declarations } : { reason: "no-scorable-response" };
+}
+function declarationConstructReason(declarations) {
+  if (declarations.some((declaration) => childElements(declaration, "qti-mapping").length > 0)) {
+    return "response-mapping";
+  }
+  return declarations.some((declaration) => childElements(declaration, "qti-area-mapping").length > 0) ? "area-mapping" : null;
+}
+function sameScore(left, right) {
+  return Math.abs(left - right) <= Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function platformResult(itemIdentifier, parsedMaxScore, rules) {
+  const ruleMaximum = rules.reduce((sum, rule) => sum + rule.points, 0);
+  if (!Number.isFinite(ruleMaximum) || ruleMaximum <= 0) {
+    return fallback(itemIdentifier, parsedMaxScore, "no-scorable-response");
+  }
+  if (!sameScore(parsedMaxScore, ruleMaximum)) {
+    return fallback(itemIdentifier, parsedMaxScore, "inconsistent-max-score");
+  }
+  return {
+    strategy: "platform",
+    itemIdentifier,
+    maxScore: ruleMaximum,
+    rules
+  };
+}
+function matchRule(declaration, points) {
+  return {
+    responseIdentifier: declaration.identifier,
+    cardinality: declaration.cardinality,
+    baseType: declaration.baseType,
+    points,
+    comparison: {
+      kind: "match",
+      correctValues: [...declaration.correctValues]
+    }
+  };
+}
+function operandIdentifiers(comparison) {
+  const operands = childElements(comparison);
+  if (operands.length !== 2 || !onlyWhitespaceText(comparison.children) || operands.some((operand) => !onlyAttributes(operand, ["identifier"]))) {
+    return null;
+  }
+  const variable = operands.find((operand) => operand.localName === "qti-variable");
+  const correct = operands.find((operand) => operand.localName === "qti-correct");
+  if (!variable || !correct || childElements(variable).length > 0 || childElements(correct).length > 0) {
+    return null;
+  }
+  if (!onlyWhitespaceText(variable.children) || !onlyWhitespaceText(correct.children)) {
+    return null;
+  }
+  const variableIdentifier = variable.attributes.identifier?.trim();
+  const correctIdentifier = correct.attributes.identifier?.trim();
+  return variableIdentifier && correctIdentifier ? { variable: variableIdentifier, correct: correctIdentifier } : null;
+}
+function comparisonResult(comparison, declaration) {
+  const identifiers = operandIdentifiers(comparison);
+  if (!identifiers || identifiers.variable !== declaration.identifier || identifiers.correct !== declaration.identifier) {
+    return null;
+  }
+  if (comparison.localName === "qti-match" && onlyAttributes(comparison, [])) {
+    return {
+      kind: "match",
+      correctValues: [...declaration.correctValues]
+    };
+  }
+  const correctValue = numericCorrectValue(declaration);
+  if (correctValue === null) {
+    return null;
+  }
+  if (comparison.localName === "qti-equal" && onlyAttributes(comparison, [])) {
+    return { kind: "numeric-equal", correctValue };
+  }
+  if (comparison.localName !== "qti-equal-rounded" || !onlyAttributes(comparison, ["rounding-mode", "figures"])) {
+    return null;
+  }
+  const roundingMode = comparison.attributes["rounding-mode"];
+  const figures = Number(comparison.attributes.figures);
+  const validFigures = Number.isInteger(figures) && (roundingMode === "decimalPlaces" ? figures >= 0 : figures > 0);
+  if (roundingMode !== "decimalPlaces" && roundingMode !== "significantFigures" || !validFigures) {
+    return null;
+  }
+  return {
+    kind: "numeric-equal-rounded",
+    correctValue,
+    roundingMode,
+    figures
+  };
+}
+function responseReferences(node, responseIdentifiers) {
+  return new Set(xmlDescendants(node, (candidate) => candidate.localName === "qti-variable" || candidate.localName === "qti-correct").map((candidate) => candidate.attributes.identifier?.trim()).filter((identifier) => Boolean(identifier) && responseIdentifiers.has(identifier)));
+}
+function additivePoints(setOutcome) {
+  if (!onlyAttributes(setOutcome, ["identifier"]) || setOutcome.attributes.identifier !== "SCORE" || !onlyWhitespaceText(setOutcome.children)) {
+    return null;
+  }
+  const outcomeChildren = childElements(setOutcome);
+  if (outcomeChildren.length !== 1 || outcomeChildren[0]?.localName !== "qti-sum") {
+    return null;
+  }
+  const sum = outcomeChildren[0];
+  if (!onlyAttributes(sum, []) || !onlyWhitespaceText(sum.children)) {
+    return null;
+  }
+  const operands = childElements(sum);
+  const scoreVariable = operands.find((operand) => operand.localName === "qti-variable" && operand.attributes.identifier === "SCORE");
+  const pointValue = operands.find((operand) => operand.localName === "qti-base-value");
+  if (operands.length !== 2 || !scoreVariable || !pointValue || !onlyAttributes(scoreVariable, ["identifier"]) || !onlyWhitespaceText(scoreVariable.children) || childElements(scoreVariable).length > 0 || !onlyAttributes(pointValue, ["base-type"]) || pointValue.attributes["base-type"] !== "float") {
+    return null;
+  }
+  const rawPoints = directText(pointValue);
+  const points = rawPoints === null ? Number.NaN : Number(rawPoints);
+  return Number.isFinite(points) && points > 0 ? points : null;
+}
+function additiveRule(condition, declarations) {
+  const responseIdentifiers = new Set(declarations.keys());
+  const references = responseReferences(condition, responseIdentifiers);
+  if (references.size > 1) {
+    return { reason: "cross-response-processing" };
+  }
+  if (references.size !== 1 || !onlyAttributes(condition, []) || !onlyWhitespaceText(condition.children)) {
+    return { reason: "unsupported-response-processing" };
+  }
+  const conditionChildren = childElements(condition);
+  if (conditionChildren.length !== 1 || conditionChildren[0]?.localName !== "qti-response-if") {
+    return { reason: "unsupported-response-processing" };
+  }
+  const responseIf = conditionChildren[0];
+  if (!onlyAttributes(responseIf, []) || !onlyWhitespaceText(responseIf.children)) {
+    return { reason: "unsupported-response-processing" };
+  }
+  const responseIfChildren = childElements(responseIf);
+  if (responseIfChildren.length !== 2) {
+    return { reason: "unsupported-response-processing" };
+  }
+  const [comparison, setOutcome] = responseIfChildren;
+  if (!comparison || !setOutcome || !["qti-match", "qti-equal", "qti-equal-rounded"].includes(comparison.localName) || setOutcome.localName !== "qti-set-outcome-value") {
+    return { reason: "unsupported-response-processing" };
+  }
+  const responseIdentifier = [...references][0];
+  const declaration = declarations.get(responseIdentifier);
+  const points = additivePoints(setOutcome);
+  const comparisonPayload = declaration ? comparisonResult(comparison, declaration) : null;
+  if (!declaration || points === null || !comparisonPayload) {
+    return { reason: "unsupported-response-processing" };
+  }
+  return {
+    rule: {
+      responseIdentifier,
+      cardinality: declaration.cardinality,
+      baseType: declaration.baseType,
+      points,
+      comparison: comparisonPayload
+    }
+  };
+}
+function additiveRules(processingRules, declarations) {
+  const rules = [];
+  const scored = new Set;
+  for (const condition of processingRules) {
+    const result = additiveRule(condition, declarations);
+    if ("reason" in result) {
+      return result;
+    }
+    if (scored.has(result.rule.responseIdentifier)) {
+      return { reason: "unsupported-response-processing" };
+    }
+    scored.add(result.rule.responseIdentifier);
+    rules.push(result.rule);
+  }
+  if (scored.size !== declarations.size || [...declarations.keys()].some((identifier) => !scored.has(identifier))) {
+    return { reason: "unsupported-response-processing" };
+  }
+  return { rules };
+}
+function scoreDefaultIsZero(item) {
+  const scoreOutcomes = childElements(item, "qti-outcome-declaration").filter((outcome) => outcome.attributes.identifier === "SCORE");
+  if (scoreOutcomes.length !== 1) {
+    return false;
+  }
+  const scoreOutcome = scoreOutcomes[0];
+  if (!onlyAttributes(scoreOutcome, ["identifier", "cardinality", "base-type"]) || scoreOutcome.attributes.cardinality !== "single" || scoreOutcome.attributes["base-type"] !== "float") {
+    return false;
+  }
+  const defaults = childElements(scoreOutcome, "qti-default-value");
+  if (defaults.length !== 1) {
+    return false;
+  }
+  const values = childElements(defaults[0], "qti-value");
+  const defaultText = values.length === 1 ? directText(values[0]) : null;
+  return defaultText !== null && defaultText !== "" && Number(defaultText) === 0;
+}
+function compileResponseProcessing(item, itemIdentifier, maxScore, declarations) {
+  const processingElements = childElements(item, "qti-response-processing");
+  if (processingElements.length === 0) {
+    return platformResult(itemIdentifier, maxScore, [...declarations.values()].map((declaration) => matchRule(declaration, 1)));
+  }
+  if (processingElements.length !== 1) {
+    return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+  }
+  const processing = processingElements[0];
+  const template = processing.attributes.template;
+  const processingRules = childElements(processing);
+  if (template !== undefined) {
+    if (!MATCH_CORRECT_TEMPLATES2.has(template.trim())) {
+      return fallback(itemIdentifier, maxScore, "unsupported-processing-template");
+    }
+    if (processingRules.length > 0 || !onlyWhitespaceText(processing.children) || !onlyAttributes(processing, ["template"])) {
+      return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+    }
+    const response = declarations.get("RESPONSE");
+    return response && declarations.size === 1 ? platformResult(itemIdentifier, maxScore, [matchRule(response, 1)]) : fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+  }
+  if (!onlyAttributes(processing, []) || !onlyWhitespaceText(processing.children) || processingRules.length === 0 || processingRules.some((rule) => rule.localName !== "qti-response-condition") || !scoreDefaultIsZero(item)) {
+    return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+  }
+  const compiled = additiveRules(processingRules, declarations);
+  return "reason" in compiled ? fallback(itemIdentifier, maxScore, compiled.reason) : platformResult(itemIdentifier, maxScore, compiled.rules);
+}
+function compileQtiScoringArtifactItem(rawXml) {
+  let root;
+  let parsed;
+  try {
+    root = parseXmlDocument(rawXml);
+    parsed = parseQtiItemXml(rawXml);
+  } catch {
+    throw new QtiScoringArtifactValidationError("QTI assessment item contains invalid XML");
+  }
+  const item = itemElement(root);
+  if (!item) {
+    throw new QtiScoringArtifactValidationError("QTI XML is missing a qti-assessment-item document element");
+  }
+  const itemIdentifier = parsed.identifier.trim();
+  if (!itemIdentifier) {
+    throw new QtiScoringArtifactValidationError("QTI assessment item is missing an identifier");
+  }
+  const maxScore = qtiItemMaxScore(parsed);
+  const rawDeclarations = childElements(item, "qti-response-declaration");
+  const constructReason = declarationConstructReason(rawDeclarations);
+  if (constructReason) {
+    return fallback(itemIdentifier, maxScore, constructReason);
+  }
+  if (childElements(item, "qti-template-processing").length > 0 || childElements(item, "qti-template-declaration").length > 0) {
+    return fallback(itemIdentifier, maxScore, "unsupported-response-processing");
+  }
+  const compiledDeclarations = scoringDeclarations(rawDeclarations, parsed.responseDeclarations);
+  return "reason" in compiledDeclarations ? fallback(itemIdentifier, maxScore, compiledDeclarations.reason) : compileResponseProcessing(item, itemIdentifier, maxScore, compiledDeclarations.declarations);
+}
+function compileQtiScoringArtifact(questions) {
+  const identifiers = new Set;
+  const items = questions.questions.map(({ question, reference }) => {
+    if (!question.rawXml) {
+      throw new QtiScoringArtifactValidationError(`QTI question ${reference.identifier} is missing raw XML`);
+    }
+    const item = compileQtiScoringArtifactItem(question.rawXml);
+    if (item.itemIdentifier !== question.identifier) {
+      throw new QtiScoringArtifactValidationError(`Hydrated QTI question ${question.identifier} contains item ${item.itemIdentifier}`);
+    }
+    if (identifiers.has(item.itemIdentifier)) {
+      throw new QtiScoringArtifactValidationError(`QTI questions contain duplicate item ${item.itemIdentifier}`);
+    }
+    identifiers.add(item.itemIdentifier);
+    return item;
+  });
+  return { items };
+}
 function isRecord22(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -95811,7 +96504,7 @@ function qtiStandardsFromMetadata(metadata2) {
   standards.push(...qtiAlignmentStandardsFromMetadata2(metadata2));
   return dedupeStandards2(standards);
 }
-var EVENT_HANDLER_ATTRIBUTE, SCRIPT_SCHEMES2, DATA_RASTER_IMAGE_PATTERN2, QTI_MATHML_ALLOWED_TAGS2, metadataSymbol2, parser2, SUPPORTED_QTI_INTERACTION_TYPES2, URL_ATTRIBUTES3, IMAGE_URL_ATTRIBUTES3, INTERACTION_TYPES2, XML_NAMED_ENTITIES, EMPHASIS_TAGS2, STRONG_TAGS2, CONTENT_SKIPPED_TAGS2, BLOCK_CONTENT_KINDS2, GAP_MATCH_TOKEN_TAGS2, STAGE_GRAPHIC_EXCLUDED_CONTAINERS2, BLANK_SENTINEL2 = "￿", MARKED_BLANK_PATTERN2, MARKED_BLANK_GLOBAL_PATTERN2, REGION_SHAPE_COORDS, QTI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0", QTI_AUTHORING_BLANK_MARKER = "___", MATCH_CORRECT_TEMPLATE2 = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE2 = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES2, RESPONSE_PROCESSING_TEMPLATES2, GLOBAL_BODY_ATTRIBUTES, BODY_ELEMENT_ATTRIBUTES, MATHML_ATTRIBUTES, VOID_BODY_ELEMENTS2, URL_ATTRIBUTES22, IMAGE_URL_ATTRIBUTES22, INTERACTION_ATTRIBUTES, CHOICE_ATTRIBUTES, CHOICE_ELEMENT_ATTRIBUTES, VOID_CHOICE_ELEMENTS2, NUMERIC_COMPARISON_ATTRIBUTES2, RESPONSE_CARDINALITIES2, RESPONSE_BASE_TYPES2, BLANK_SENTINEL22 = "￿", PLAYABLE_POINT_VALUE, POINT_INTERACTION_TYPES2, INDEPENDENT_PROCESSING_TAGS2, COMMON_CORE_MATH_FRAMEWORK_ALIASES2, COMMON_CORE_ELA_FRAMEWORK_ALIASES2, COMMON_CORE_FRAMEWORK_ALIASES2;
+var EVENT_HANDLER_ATTRIBUTE, SCRIPT_SCHEMES2, DATA_RASTER_IMAGE_PATTERN2, QTI_MATHML_ALLOWED_TAGS2, metadataSymbol2, parser2, SUPPORTED_QTI_INTERACTION_TYPES2, URL_ATTRIBUTES3, IMAGE_URL_ATTRIBUTES3, INTERACTION_TYPES2, XML_NAMED_ENTITIES, EMPHASIS_TAGS2, STRONG_TAGS2, CONTENT_SKIPPED_TAGS2, BLOCK_CONTENT_KINDS2, GAP_MATCH_TOKEN_TAGS2, STAGE_GRAPHIC_EXCLUDED_CONTAINERS2, BLANK_SENTINEL2 = "￿", MARKED_BLANK_PATTERN2, MARKED_BLANK_GLOBAL_PATTERN2, REGION_SHAPE_COORDS, QTI_NAMESPACE = "http://www.imsglobal.org/xsd/imsqtiasi_v3p0", QTI_AUTHORING_BLANK_MARKER = "___", MATCH_CORRECT_TEMPLATE2 = "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct", MAP_RESPONSE_TEMPLATE2 = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response", MAP_RESPONSE_TEMPLATES2, RESPONSE_PROCESSING_TEMPLATES2, GLOBAL_BODY_ATTRIBUTES, BODY_ELEMENT_ATTRIBUTES, MATHML_ATTRIBUTES, VOID_BODY_ELEMENTS2, URL_ATTRIBUTES22, IMAGE_URL_ATTRIBUTES22, INTERACTION_ATTRIBUTES, CHOICE_ATTRIBUTES, CHOICE_ELEMENT_ATTRIBUTES, VOID_CHOICE_ELEMENTS2, NUMERIC_COMPARISON_ATTRIBUTES2, RESPONSE_CARDINALITIES2, RESPONSE_BASE_TYPES2, BLANK_SENTINEL22 = "￿", PLAYABLE_POINT_VALUE, POINT_INTERACTION_TYPES2, INDEPENDENT_PROCESSING_TAGS2, SUPPORTED_BASE_TYPES2, SUPPORTED_CARDINALITIES2, MATCH_CORRECT_TEMPLATES2, DIRECTED_PAIR_VALUE, QtiScoringArtifactValidationError, COMMON_CORE_MATH_FRAMEWORK_ALIASES2, COMMON_CORE_ELA_FRAMEWORK_ALIASES2, COMMON_CORE_FRAMEWORK_ALIASES2;
 var init_qti = __esm(() => {
   init_timeback3();
   init_timeback3();
@@ -96061,6 +96754,30 @@ var init_qti = __esm(() => {
     "qti-sum",
     "qti-base-value"
   ]);
+  SUPPORTED_BASE_TYPES2 = new Set([
+    "string",
+    "identifier",
+    "integer",
+    "float",
+    "directedPair"
+  ]);
+  SUPPORTED_CARDINALITIES2 = new Set([
+    "single",
+    "multiple",
+    "ordered"
+  ]);
+  MATCH_CORRECT_TEMPLATES2 = new Set([
+    "http://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct",
+    "https://www.imsglobal.org/question/qti_v3p0/rptemplates/match_correct",
+    "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/match_correct"
+  ].flatMap((template) => [template, `${template}.xml`]));
+  DIRECTED_PAIR_VALUE = /^[A-Za-z_][\w.-]* [A-Za-z_][\w.-]*$/;
+  QtiScoringArtifactValidationError = class QtiScoringArtifactValidationError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "QtiScoringArtifactValidationError";
+    }
+  };
   COMMON_CORE_MATH_FRAMEWORK_ALIASES2 = new Set([
     "ccssm",
     "ccssmath",
@@ -96086,11 +96803,11 @@ var init_qti = __esm(() => {
 });
 
 // ../api-core/src/utils/timeback-grade-level-results.util.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function metadataOf(record3) {
-  return isRecord6(record3) && isRecord6(record3.metadata) ? record3.metadata : {};
+  return isRecord7(record3) && isRecord7(record3.metadata) ? record3.metadata : {};
 }
 function stringField3(value) {
   return typeof value === "string" ? value : "";
@@ -96102,7 +96819,7 @@ function numberField(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function sourceIdFromRef(value) {
-  return isRecord6(value) ? stringField3(value.sourcedId) : "";
+  return isRecord7(value) ? stringField3(value.sourcedId) : "";
 }
 function buildGradeLevelTestResultWhere(options) {
   return {
@@ -96178,7 +96895,7 @@ function mapGradeLevelTestSummary(result, options) {
   };
 }
 function readLearningObjectiveSets(record3) {
-  if (!isRecord6(record3)) {
+  if (!isRecord7(record3)) {
     return [];
   }
   const metadata2 = metadataOf(record3);
@@ -96208,7 +96925,7 @@ function dedupeStandards3(standards) {
 function standardsFromLineItem(lineItem) {
   const standards = [];
   for (const set3 of readLearningObjectiveSets(lineItem)) {
-    if (isRecord6(set3)) {
+    if (isRecord7(set3)) {
       const source = stringField3(set3.source) || "OneRoster";
       const ids = Array.isArray(set3.learningObjectiveIds) ? set3.learningObjectiveIds : [];
       for (const id of ids) {
@@ -96224,11 +96941,11 @@ function standardsFromLineItem(lineItem) {
 function standardsFromResult(result) {
   const standards = [];
   for (const set3 of readLearningObjectiveSets(result)) {
-    if (isRecord6(set3)) {
+    if (isRecord7(set3)) {
       const source = stringField3(set3.source) || "OneRoster";
       const values = Array.isArray(set3.learningObjectiveResults) ? set3.learningObjectiveResults : [];
       for (const item of values) {
-        if (isRecord6(item)) {
+        if (isRecord7(item)) {
           const id = stringField3(item.learningObjectiveId).trim();
           if (id) {
             standards.push({ source, id });
@@ -96240,7 +96957,7 @@ function standardsFromResult(result) {
   return dedupeStandards3(standards);
 }
 function standardsFromQtiQuestion(questionRef) {
-  const question = isRecord6(questionRef) && isRecord6(questionRef.question) ? questionRef.question : null;
+  const question = isRecord7(questionRef) && isRecord7(questionRef.question) ? questionRef.question : null;
   return qtiStandardsFromMetadata(metadataOf(question));
 }
 function enrichStandardsFromQti(standards, qtiStandards) {
@@ -96377,8 +97094,8 @@ function mapGradeLevelReviewQuestions(options) {
   return options.questionLineItems.toSorted((a, b) => naturalTitleSort.compare(a.title, b.title)).map((lineItem) => {
     const result = options.latestResultsByLineItem.get(lineItem.sourcedId ?? "");
     const resultMetadata = metadataOf(result);
-    const attemptedQuestionData = isRecord6(resultMetadata.attemptedQuestionData) ? resultMetadata.attemptedQuestionData : null;
-    const attemptedResult = isRecord6(attemptedQuestionData?.result) ? attemptedQuestionData.result : null;
+    const attemptedQuestionData = isRecord7(resultMetadata.attemptedQuestionData) ? resultMetadata.attemptedQuestionData : null;
+    const attemptedResult = isRecord7(attemptedQuestionData?.result) ? attemptedQuestionData.result : null;
     const index2 = parseQuestionIndex(lineItem.title);
     const qtiQuestion = index2 ? qtiQuestionByIndex.get(index2) ?? options.qtiQuestions[index2 - 1] : undefined;
     const qtiStandards = standardsFromQtiQuestion(qtiQuestion);
@@ -98421,6 +99138,452 @@ var init_timeback_admin_service = __esm(async () => {
   ]);
 });
 
+// ../api-core/src/utils/assessment-artifact-runtime.util.ts
+function normalizedKey(key) {
+  return key.replaceAll(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function containsPrivatePlayableKey(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsPrivatePlayableKey);
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.entries(value).some(([key, entry]) => PRIVATE_PLAYABLE_KEYS.has(normalizedKey(key)) || containsPrivatePlayableKey(entry));
+}
+function playableSchema(identity) {
+  return exports_external.object({
+    contractVersion: exports_external.literal(PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION),
+    identifier: exports_external.literal(identity.qtiTestIdentifier),
+    contentRevision: exports_external.literal(identity.kind === "assessment" ? identity.contentRevision : identity.sourceContentRevision),
+    title: trimmedNonEmptyString,
+    items: exports_external.array(playableItemSchema)
+  }).strict();
+}
+function scoringSchema(identity) {
+  if (identity.kind === "assessment") {
+    return exports_external.object({
+      items: uniqueScoringItemsSchema,
+      reviewBank: exports_external.undefined(),
+      diagnostic: diagnosticContextSchema.optional()
+    });
+  }
+  return exports_external.object({
+    items: uniqueScoringItemsSchema,
+    reviewBank: exports_external.object({
+      sourceContentRevision: exports_external.literal(identity.sourceContentRevision),
+      bankRevision: exports_external.literal(identity.bankRevision),
+      items: exports_external.array(exports_external.object({
+        itemIdentifier: trimmedNonEmptyString,
+        standards: exports_external.array(exports_external.unknown())
+      }))
+    }),
+    diagnostic: exports_external.undefined()
+  }).refine((payload) => payload.reviewBank.items.length === payload.items.length && payload.reviewBank.items.every((item, index2) => item.itemIdentifier === payload.items[index2]?.itemIdentifier));
+}
+function assertPlayableAssessmentArtifact(payload, identity) {
+  if (!playableSchema(identity).safeParse(payload).success || containsPrivatePlayableKey(payload)) {
+    throw new ValidationError("Playable assessment artifact payload is invalid or private");
+  }
+}
+function assertScoringAssessmentArtifact(payload, identity) {
+  if (!scoringSchema(identity).safeParse(payload).success) {
+    throw new ValidationError("Scoring assessment artifact payload is invalid or incompatible");
+  }
+}
+function assertScoringArtifactMatchesPlayable(assessment, scoring, identity) {
+  const scoringByIdentifier = new Map(scoring.items.map((item) => [item.itemIdentifier, item.maxScore]));
+  const playableMatches = assessment.items.every((item) => scoringByIdentifier.get(item.identifier) === item.maxScore);
+  const hasExactManagedMembership = identity.kind === "review-bank" || scoring.items.length === assessment.items.length;
+  if (!playableMatches || !hasExactManagedMembership) {
+    throw new ValidationError("Scoring artifact does not match the playable assessment");
+  }
+}
+function assertPlayableArtifactContainsItems(assessment, itemIdentifiers) {
+  const available = new Set(assessment.items.map((item) => item.identifier));
+  const missing = [...new Set(itemIdentifiers)].filter((identifier) => !available.has(identifier));
+  if (missing.length > 0) {
+    throw new ValidationError("Playable assessment artifact is missing required items", {
+      missingItemIdentifiers: missing
+    });
+  }
+}
+function assessmentArtifactIdentityFromAttempt(metadata2) {
+  return metadata2.purpose === "review" ? {
+    kind: "review-bank",
+    qtiTestIdentifier: metadata2.selectedTest.identifier,
+    sourceContentRevision: metadata2.selectedTest.contentRevision,
+    bankRevision: metadata2.review.bankRevision
+  } : {
+    kind: "assessment",
+    qtiTestIdentifier: metadata2.selectedTest.identifier,
+    contentRevision: metadata2.selectedTest.contentRevision
+  };
+}
+function pinnedReviewBankFromAttempt(metadata2, bankIdentifier) {
+  return {
+    bankIdentifier,
+    sourceContentRevision: metadata2.selectedTest.contentRevision,
+    bankRevision: metadata2.review.bankRevision,
+    items: metadata2.review.selections.map((selection) => ({
+      itemIdentifier: selection.itemIdentifier,
+      standards: [selection.standard]
+    }))
+  };
+}
+var PRIVATE_PLAYABLE_KEYS, trimmedNonEmptyString, finiteNumber2, nonnegativeInteger, playableContentNodesSchema, playableChoiceSchema, playableMatchChoiceSchema, playableGraphicSchema, playableHotspotSchema, playableGapTextSchema, playableGapImageSchema, playableInteractionBase, playableInteractionSchema, playableItemSchema, scoringRuleSchema, scoringItemSchema, uniqueScoringItemsSchema, diagnosticContextSchema;
+var init_assessment_artifact_runtime_util = __esm(() => {
+  init_esm();
+  init_src();
+  init_errors2();
+  PRIVATE_PLAYABLE_KEYS = new Set([
+    "answer",
+    "answerkey",
+    "correctanswer",
+    "correctresponse",
+    "correctresponses",
+    "correct",
+    "correctvalue",
+    "correctvalues",
+    "iscorrect",
+    "responseprocessing",
+    "rule",
+    "rules",
+    "scoring",
+    "scoringrules",
+    "solution",
+    "expected",
+    "expectedanswer",
+    "expectedvalue",
+    "expectedvalues"
+  ]);
+  trimmedNonEmptyString = exports_external.string().min(1).refine((value) => value === value.trim());
+  finiteNumber2 = exports_external.number().finite();
+  nonnegativeInteger = exports_external.number().int().nonnegative();
+  playableContentNodesSchema = exports_external.array(exports_external.unknown());
+  playableChoiceSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    content: exports_external.string(),
+    contentNodes: playableContentNodesSchema.optional()
+  }).strict();
+  playableMatchChoiceSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    content: exports_external.string(),
+    contentNodes: playableContentNodesSchema.optional(),
+    matchMax: nonnegativeInteger
+  }).strict();
+  playableGraphicSchema = exports_external.object({
+    src: trimmedNonEmptyString,
+    width: finiteNumber2.optional(),
+    height: finiteNumber2.optional(),
+    description: exports_external.string().optional()
+  }).strict();
+  playableHotspotSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    shape: exports_external.enum(["circle", "ellipse", "rect", "poly", "default"]),
+    coords: exports_external.array(finiteNumber2),
+    matchMax: nonnegativeInteger.optional(),
+    description: exports_external.string().optional()
+  }).strict();
+  playableGapTextSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    content: exports_external.string(),
+    matchMax: nonnegativeInteger
+  }).strict();
+  playableGapImageSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    image: playableGraphicSchema.optional(),
+    matchMax: nonnegativeInteger,
+    description: exports_external.string().optional()
+  }).strict();
+  playableInteractionBase = {
+    responseIdentifier: trimmedNonEmptyString,
+    prompt: exports_external.string().optional()
+  };
+  playableInteractionSchema = exports_external.discriminatedUnion("type", [
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("choice"),
+      choices: exports_external.array(playableChoiceSchema),
+      minChoices: nonnegativeInteger,
+      maxChoices: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("inline-choice"),
+      choices: exports_external.array(playableChoiceSchema)
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("text-entry"),
+      expectedLength: nonnegativeInteger.optional(),
+      placeholder: exports_external.string().optional()
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("order"),
+      choices: exports_external.array(playableChoiceSchema),
+      shuffle: exports_external.boolean()
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("match"),
+      sourceChoices: exports_external.array(playableMatchChoiceSchema),
+      targetChoices: exports_external.array(playableMatchChoiceSchema),
+      maxAssociations: nonnegativeInteger,
+      shuffle: exports_external.boolean()
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("hottext"),
+      segments: exports_external.array(exports_external.object({
+        identifier: trimmedNonEmptyString.optional(),
+        content: exports_external.string(),
+        selectable: exports_external.boolean()
+      }).strict()),
+      maxChoices: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("hotspot"),
+      image: playableGraphicSchema,
+      hotspots: exports_external.array(playableHotspotSchema),
+      minChoices: nonnegativeInteger,
+      maxChoices: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("gap-match"),
+      content: exports_external.string(),
+      contentNodes: playableContentNodesSchema,
+      gapTexts: exports_external.array(playableGapTextSchema),
+      gaps: exports_external.array(trimmedNonEmptyString),
+      maxAssociations: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("graphic-gap-match"),
+      image: playableGraphicSchema,
+      gapImages: exports_external.array(playableGapImageSchema),
+      hotspots: exports_external.array(playableHotspotSchema),
+      maxAssociations: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("select-point"),
+      image: playableGraphicSchema,
+      minChoices: nonnegativeInteger,
+      maxChoices: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("graphic-associate"),
+      image: playableGraphicSchema,
+      hotspots: exports_external.array(playableHotspotSchema),
+      maxAssociations: nonnegativeInteger
+    }).strict(),
+    exports_external.object({
+      ...playableInteractionBase,
+      type: exports_external.literal("position-object"),
+      stage: playableGraphicSchema,
+      object: playableGraphicSchema,
+      maxPlacements: nonnegativeInteger
+    }).strict()
+  ]);
+  playableItemSchema = exports_external.object({
+    identifier: trimmedNonEmptyString,
+    title: exports_external.string(),
+    prompt: exports_external.string(),
+    promptContent: playableContentNodesSchema.optional(),
+    maxScore: finiteNumber2,
+    interactions: exports_external.array(playableInteractionSchema)
+  }).strict();
+  scoringRuleSchema = exports_external.object({
+    responseIdentifier: trimmedNonEmptyString,
+    cardinality: exports_external.enum(["single", "multiple", "ordered"]),
+    baseType: exports_external.enum(["string", "identifier", "integer", "float", "directedPair"]),
+    points: finiteNumber2,
+    comparison: exports_external.discriminatedUnion("kind", [
+      exports_external.object({ kind: exports_external.literal("match"), correctValues: exports_external.array(exports_external.string()) }),
+      exports_external.object({ kind: exports_external.literal("numeric-equal"), correctValue: finiteNumber2 }),
+      exports_external.object({
+        kind: exports_external.literal("numeric-equal-rounded"),
+        correctValue: finiteNumber2,
+        roundingMode: exports_external.enum(["decimalPlaces", "significantFigures"]),
+        figures: exports_external.number().int().nonnegative()
+      })
+    ])
+  });
+  scoringItemSchema = exports_external.discriminatedUnion("strategy", [
+    exports_external.object({
+      strategy: exports_external.literal("qti"),
+      itemIdentifier: trimmedNonEmptyString,
+      maxScore: finiteNumber2,
+      reason: exports_external.enum([
+        "response-mapping",
+        "area-mapping",
+        "unsupported-base-type",
+        "unsupported-cardinality",
+        "invalid-correct-response",
+        "no-scorable-response",
+        "unsupported-processing-template",
+        "unsupported-response-processing",
+        "cross-response-processing",
+        "inconsistent-max-score"
+      ])
+    }),
+    exports_external.object({
+      strategy: exports_external.literal("platform"),
+      itemIdentifier: trimmedNonEmptyString,
+      maxScore: finiteNumber2,
+      rules: exports_external.array(scoringRuleSchema)
+    })
+  ]);
+  uniqueScoringItemsSchema = exports_external.array(scoringItemSchema).refine((items) => new Set(items.map((item) => item.itemIdentifier)).size === items.length);
+  diagnosticContextSchema = exports_external.object({
+    routingRevision: trimmedNonEmptyString,
+    routingManifest: exports_external.record(exports_external.unknown())
+  });
+});
+
+// ../api-core/src/utils/assessment-artifact-loader.util.ts
+class AssessmentArtifactRuntimeLoader {
+  artifacts;
+  playableCache;
+  scoringCache;
+  playableLoads = new Map;
+  scoringLoads = new Map;
+  constructor(artifacts, options) {
+    this.artifacts = artifacts;
+    this.playableCache = this.immutableCache(options.maxSize);
+    this.scoringCache = this.immutableCache(options.maxSize);
+  }
+  loadPlayable(identity) {
+    return this.load({
+      artifactKind: "playable",
+      identity,
+      key: this.cacheKey(identity),
+      cache: this.playableCache,
+      loads: this.playableLoads,
+      load: () => this.artifacts.loadPlayable(identity),
+      assert: assertPlayableAssessmentArtifact
+    });
+  }
+  async loadPlayableContainingItems(identity, itemIdentifiers) {
+    const startedAt = Date.now();
+    const assessment = await this.loadPlayable(identity);
+    if (assessment) {
+      try {
+        assertPlayableArtifactContainsItems(assessment, itemIdentifiers);
+        return assessment;
+      } catch (error88) {
+        this.recordLoad("playable", identity.kind, "validation_failure", startedAt, error88);
+      }
+    }
+    this.recordFallback("playable", identity.kind);
+    return null;
+  }
+  loadManagedPlayable(qtiTestIdentifier) {
+    return this.load({
+      artifactKind: "playable",
+      key: `managed\x00${qtiTestIdentifier}`,
+      cache: this.playableCache,
+      loads: this.playableLoads,
+      load: () => this.artifacts.loadManagedPlayable(qtiTestIdentifier),
+      assert: assertPlayableAssessmentArtifact
+    });
+  }
+  loadScoring(identity) {
+    return this.load({
+      artifactKind: "scoring",
+      identity,
+      key: this.cacheKey(identity),
+      cache: this.scoringCache,
+      loads: this.scoringLoads,
+      load: () => this.artifacts.loadScoring(identity),
+      assert: assertScoringAssessmentArtifact
+    });
+  }
+  async loadMatchedScoring(assessment, identity) {
+    const scoring = await this.loadScoring(identity);
+    if (scoring) {
+      try {
+        assertScoringArtifactMatchesPlayable(assessment, scoring, identity);
+        return scoring;
+      } catch (error88) {
+        this.recordLoad("scoring", identity.kind, "validation_failure", Date.now(), error88);
+      }
+    }
+    this.recordFallback("scoring", identity.kind);
+    return null;
+  }
+  recordFallback(artifactKind, identityKind) {
+    addEvent("assessment.artifact_fallback", {
+      "app.assessment.artifact_kind": artifactKind,
+      "app.assessment.artifact_identity_kind": identityKind
+    });
+  }
+  immutableCache(maxSize) {
+    return new TimebackCache({ defaultTTL: Number.POSITIVE_INFINITY, maxSize });
+  }
+  cacheKey(identity) {
+    return canonicalJson2(identity);
+  }
+  recordLoad(artifactKind, identityKind, outcome, startedAt, error88) {
+    addEvent("assessment.artifact_load", {
+      "app.assessment.artifact_kind": artifactKind,
+      "app.assessment.artifact_identity_kind": identityKind,
+      "app.assessment.artifact_outcome": outcome,
+      "app.assessment.artifact_duration_ms": Date.now() - startedAt,
+      ...error88 ? { "exception.type": errorType(error88) } : {}
+    });
+  }
+  async load(input) {
+    const startedAt = Date.now();
+    const identityKind = input.identity?.kind ?? "assessment";
+    const record3 = (outcome, error88) => this.recordLoad(input.artifactKind, identityKind, outcome, startedAt, error88);
+    const cached3 = input.cache.get(input.key);
+    if (cached3) {
+      record3("cache_hit");
+      return cached3;
+    }
+    const inFlight = input.loads.get(input.key);
+    if (inFlight) {
+      record3("coalesced");
+      return inFlight;
+    }
+    const pending = (async () => {
+      try {
+        const stored = await input.load();
+        if (!stored) {
+          record3("missing");
+          return null;
+        }
+        input.assert(stored.payload, input.identity ?? stored.identity);
+        input.cache.set(input.key, stored.payload);
+        if (!input.identity) {
+          input.cache.set(this.cacheKey(stored.identity), stored.payload);
+        }
+        record3("loaded");
+        return stored.payload;
+      } catch (error88) {
+        record3(error88 instanceof ValidationError ? "validation_failure" : "load_failure", error88);
+        return null;
+      } finally {
+        input.loads.delete(input.key);
+      }
+    })();
+    input.loads.set(input.key, pending);
+    return pending;
+  }
+}
+var init_assessment_artifact_loader_util = __esm(async () => {
+  init_spans();
+  init_errors2();
+  init_assessment_artifact_runtime_util();
+  await init_dist5();
+});
+
 // ../data/src/locks.ts
 function createInMemoryDatabaseLock() {
   const tails = new Map;
@@ -98541,6 +99704,810 @@ var init_assessment_runtime_lock_util = __esm(() => {
   };
 });
 
+// ../api-core/src/utils/timeback-assessment-runtime.util.ts
+function assessmentPreparationContentionError(expectedResponseVersion, responseVersion, kind) {
+  if (expectedResponseVersion === responseVersion) {
+    return new ServiceUnavailableError(`The ${kind} response state changed repeatedly while this item was being prepared. Try again shortly.`, {
+      retryable: true,
+      reason: "PREPARATION_CONTENTION",
+      expectedResponseVersion,
+      responseVersion
+    });
+  }
+  return AssessmentRuntimeError.from(assessmentResponseVersionConflict(expectedResponseVersion, responseVersion));
+}
+function assessmentTrackableCourse(integration) {
+  if (!isTimebackGrade2(integration.grade) || !isTimebackSubject(integration.subject)) {
+    return null;
+  }
+  return { grade: integration.grade, subject: integration.subject };
+}
+function buildAssessmentActivityData(input) {
+  if (!input.course) {
+    return;
+  }
+  return {
+    activityId: input.activityId,
+    activityName: input.activityName,
+    ...input.course,
+    courseId: input.courseId
+  };
+}
+function buildDiagnosticAssessmentSnapshot(input) {
+  return {
+    attemptId: input.attemptId,
+    responseVersion: input.metadata.responseVersion,
+    status: "in_progress",
+    flow: "platform-routed-item-submit",
+    ...input.activityData ? { activityData: input.activityData } : {},
+    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
+    selection: {
+      kind: "platform-routed-diagnostic",
+      purpose: "diagnostic",
+      definitionId: input.metadata.diagnostic.definitionId,
+      diagnosticKey: input.metadata.diagnostic.diagnosticKey,
+      routingRevision: input.metadata.diagnostic.routingRevision
+    },
+    routing: projectDiagnosticRoutingSnapshot(input.metadata.diagnostic.routingRevision, input.state),
+    completion: null
+  };
+}
+function buildConventionalAssessmentSnapshot(input) {
+  const metadata2 = input.metadata;
+  let selection;
+  if (metadata2.purpose === "review") {
+    selection = {
+      kind: "standards-review",
+      purpose: metadata2.purpose,
+      standards: [...metadata2.review.standards],
+      candidateItemsPerStandard: metadata2.review.candidateItemsPerStandard,
+      selections: [...metadata2.review.selections],
+      fulfillment: metadata2.review.fulfillment
+    };
+  } else if (metadata2.purpose === "mastery") {
+    selection = {
+      kind: "standard-quiz",
+      purpose: metadata2.purpose,
+      standard: metadata2.mastery.standard
+    };
+  } else {
+    selection = { kind: "fixed-test", purpose: metadata2.purpose };
+  }
+  return {
+    attemptId: input.attemptId,
+    responseVersion: metadata2.responseVersion,
+    status: "in_progress",
+    flow: assessmentFlowForPurpose(metadata2.purpose),
+    ...input.activityData ? { activityData: input.activityData } : {},
+    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
+    responses: metadata2.responses,
+    itemSubmissions: metadata2.itemSubmissions,
+    score: null,
+    selection
+  };
+}
+function buildAssessmentAwardRecord(input, mastery) {
+  return {
+    xpAwarded: input.xpAwarded,
+    ...input.masteredUnits !== undefined ? { masteredUnits: input.masteredUnits } : {},
+    ...input.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: input.masteredUnitsAbsolute } : {},
+    masteredUnitsApplied: mastery.masteredUnitsApplied,
+    ...mastery.pctCompleteApp !== undefined ? { pctCompleteApp: mastery.pctCompleteApp } : {},
+    ...mastery.warnings ? { warnings: mastery.warnings } : {}
+  };
+}
+function stageAssessmentAttemptSupersession(attempt) {
+  Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
+  Object.assign(attempt.selection, ASSESSMENT_ATTEMPT_SUPERSEDED);
+}
+function shouldConfirmAssessmentVersionUnavailable(details) {
+  return typeof details === "object" && details !== null && "expectedRevision" in details && typeof details.expectedRevision === "string" && !("currentRevision" in details);
+}
+function buildAssessmentAttemptSupersessionUpdate(result) {
+  if (result.status !== "active" || !isAssessmentAttemptOpen({
+    inProgress: result.inProgress ?? "",
+    scoreStatus: result.scoreStatus
+  })) {
+    return null;
+  }
+  return {
+    status: "active",
+    assessmentLineItem: result.assessmentLineItem,
+    student: result.student,
+    score: result.score ?? 0,
+    scoreDate: result.scoreDate,
+    ...ASSESSMENT_ATTEMPT_SUPERSEDED,
+    metadata: result.metadata ?? {}
+  };
+}
+async function resolveAvailableAssessmentAttempt(initialDecision, select3, resume) {
+  let decision = initialDecision;
+  while (decision?.kind === "resume") {
+    const snapshot = await resume(decision);
+    if (snapshot !== null) {
+      return { kind: "resumed", snapshot };
+    }
+    decision = select3();
+  }
+  return { kind: "continue", decision };
+}
+function buildReviewItemResultMetadata(input) {
+  const administration = itemAdministration(input.metadata.itemSubmissions, input.selection.itemIdentifier);
+  if (!administration) {
+    throw new Error(`Cannot create a review result for unadministered candidate ${input.selection.itemIdentifier}`);
+  }
+  return {
+    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
+    parentAttemptId: input.parentAttemptId,
+    activityId: input.metadata.activityId,
+    integrationId: input.metadata.integrationId,
+    enrollmentId: input.metadata.enrollmentId,
+    bankRevision: input.metadata.review.bankRevision,
+    itemIdentifier: input.selection.itemIdentifier,
+    standard: input.selection.standard,
+    deliveredAt: administration.submittedAt,
+    responseVersion: input.responseVersion ?? input.metadata.responseVersion,
+    responses: input.metadata.responses[input.selection.itemIdentifier] ?? {},
+    ...input.submissionId ? { submissionId: input.submissionId } : {},
+    ...input.isCorrect === undefined ? {} : { isCorrect: input.isCorrect }
+  };
+}
+function buildOpenReviewChildResult(input) {
+  return {
+    status: "active",
+    assessmentLineItem: { sourcedId: input.childLineItemId },
+    student: input.student,
+    score: 0,
+    scoreDate: input.metadata.deliveredAt,
+    ...ASSESSMENT_ATTEMPT_OPEN,
+    metadata: {
+      [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: input.metadata
+    }
+  };
+}
+function diagnosticQuestionLineItemId(parentLineItemId, itemIdentifier) {
+  return deterministicUUID(["playcademy:diagnostic-question-line-item:v1", parentLineItemId, itemIdentifier].join("\x00"));
+}
+function diagnosticQuestionResultId(parentAttemptId, childLineItemId) {
+  return deterministicUUID(["playcademy:diagnostic-question-result:v1", parentAttemptId, childLineItemId].join("\x00"));
+}
+function diagnosticAdministration(input) {
+  const ledgerIndex = input.metadata.diagnostic.ledger.findIndex((entry) => entry.routingNodeKey === input.ledgerEntry.routingNodeKey);
+  const persistedEntry = input.metadata.diagnostic.ledger[ledgerIndex];
+  const administration = input.metadata.itemSubmissions[ledgerIndex];
+  if (ledgerIndex === -1 || !persistedEntry || !administration || persistedEntry.stageKey !== input.ledgerEntry.stageKey || persistedEntry.trackKey !== input.ledgerEntry.trackKey || persistedEntry.itemIdentifier !== input.ledgerEntry.itemIdentifier || persistedEntry.isCorrect !== input.ledgerEntry.isCorrect || administration.itemIdentifier !== input.ledgerEntry.itemIdentifier || administration.isCorrect !== input.ledgerEntry.isCorrect) {
+    throw new Error(`Cannot create a diagnostic result for uncommitted routing node ${input.ledgerEntry.routingNodeKey}`);
+  }
+  return administration;
+}
+function buildDiagnosticItemResultMetadata(input) {
+  const administration = diagnosticAdministration(input);
+  return {
+    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
+    parentAttemptId: input.parentAttemptId,
+    activityId: input.metadata.activityId,
+    integrationId: input.metadata.integrationId,
+    enrollmentId: input.metadata.enrollmentId,
+    definitionId: input.metadata.diagnostic.definitionId,
+    diagnosticKey: input.metadata.diagnostic.diagnosticKey,
+    routingRevision: input.metadata.diagnostic.routingRevision,
+    contentRevision: input.metadata.selectedTest.contentRevision,
+    stageKey: input.ledgerEntry.stageKey,
+    trackKey: input.ledgerEntry.trackKey,
+    routingNodeKey: input.ledgerEntry.routingNodeKey,
+    itemIdentifier: input.ledgerEntry.itemIdentifier,
+    deliveredAt: administration.submittedAt,
+    responseVersion: administration.responseVersion,
+    responses: input.metadata.responses[input.ledgerEntry.itemIdentifier] ?? {},
+    submissionId: administration.submissionId,
+    isCorrect: input.ledgerEntry.isCorrect
+  };
+}
+function resolveDiagnosticChildResult(input) {
+  if (!input.childResult) {
+    return { action: "create" };
+  }
+  const childMetadata = playcademyDiagnosticAssessmentItemResultMetadata(input.childResult.metadata);
+  const expectedMetadata = buildDiagnosticItemResultMetadata({
+    metadata: input.parentMetadata,
+    ledgerEntry: input.ledgerEntry,
+    parentAttemptId: input.parentResult.sourcedId
+  });
+  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || canonicalJson2(childMetadata) !== canonicalJson2(expectedMetadata)) {
+    return { action: "restore", reason: "incompatible" };
+  }
+  return input.childResult.status === "active" ? { action: "reuse", metadata: expectedMetadata } : { action: "restore", reason: "inactive" };
+}
+function buildFinalizedDiagnosticChildResult(input) {
+  const administration = diagnosticAdministration(input);
+  const metadata2 = buildDiagnosticItemResultMetadata(input);
+  return {
+    resultUpdate: {
+      status: "active",
+      assessmentLineItem: { sourcedId: input.childLineItemId },
+      student: input.student,
+      score: administration.score.earned,
+      scoreDate: administration.submittedAt,
+      ...ASSESSMENT_ATTEMPT_COMPLETED,
+      metadata: {
+        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
+      }
+    }
+  };
+}
+function buildFinalizedReviewChildResult(input) {
+  const metadata2 = buildReviewItemResultMetadata({
+    metadata: input.metadata,
+    selection: input.selection,
+    parentAttemptId: input.parentAttemptId,
+    submissionId: input.submissionId,
+    isCorrect: input.itemResult.isCorrect
+  });
+  return {
+    resultUpdate: {
+      status: "active",
+      assessmentLineItem: { sourcedId: input.childLineItemId },
+      student: input.student,
+      score: input.itemResult.score.earned,
+      scoreDate: input.timestamp,
+      ...ASSESSMENT_ATTEMPT_COMPLETED,
+      metadata: {
+        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
+      }
+    },
+    outcome: {
+      itemIdentifier: input.selection.itemIdentifier,
+      standard: input.selection.standard,
+      answered: Object.keys(input.metadata.responses[input.selection.itemIdentifier] ?? {}).length > 0,
+      score: input.itemResult.score,
+      isCorrect: input.itemResult.isCorrect
+    }
+  };
+}
+function resolveReviewChildResult(input) {
+  if (!input.childResult) {
+    return { action: "create" };
+  }
+  const childMetadata = playcademyAssessmentItemResultMetadata(input.childResult.metadata);
+  const expectedResponses = input.parentMetadata.responses[input.selection.itemIdentifier] ?? {};
+  const administration = itemAdministration(input.parentMetadata.itemSubmissions, input.selection.itemIdentifier);
+  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || childMetadata.parentAttemptId !== input.parentResult.sourcedId || childMetadata.activityId !== input.parentMetadata.activityId || childMetadata.integrationId !== input.parentMetadata.integrationId || childMetadata.enrollmentId !== input.parentMetadata.enrollmentId || childMetadata.bankRevision !== input.parentMetadata.review.bankRevision || childMetadata.itemIdentifier !== input.selection.itemIdentifier || childMetadata.standard.framework !== input.selection.standard.framework || childMetadata.standard.identifier !== input.selection.standard.identifier || childMetadata.deliveredAt !== administration?.submittedAt || childMetadata.responseVersion > input.parentMetadata.responseVersion || canonicalJson2(childMetadata.responses) !== canonicalJson2(expectedResponses)) {
+    return { action: "restore", reason: "incompatible" };
+  }
+  return input.childResult.status === "active" ? { action: "reuse", metadata: childMetadata } : { action: "restore", reason: "inactive" };
+}
+function buildAssessmentSubmitResult(input) {
+  if (!input.metadata.score || !input.metadata.submissionId) {
+    return null;
+  }
+  if (input.metadata.purpose === "diagnostic" && input.metadata.diagnostic) {
+    const tracks = input.metadata.completion?.diagnosticTracks;
+    return tracks ? {
+      purpose: input.metadata.purpose,
+      attemptId: input.attemptId,
+      submissionId: input.metadata.submissionId,
+      diagnosticKey: input.metadata.diagnostic.diagnosticKey,
+      responseVersion: input.metadata.responseVersion,
+      status: "awaiting_award",
+      tracks
+    } : null;
+  }
+  const base = {
+    attemptId: input.attemptId,
+    submissionId: input.metadata.submissionId,
+    responseVersion: input.metadata.responseVersion,
+    status: "awaiting_award",
+    responses: input.metadata.responses,
+    score: input.metadata.score
+  };
+  if (input.metadata.purpose === "review") {
+    const itemOutcomes = input.metadata.completion?.itemOutcomes;
+    return itemOutcomes ? { ...base, purpose: input.metadata.purpose, itemOutcomes } : null;
+  }
+  return { ...base, purpose: input.metadata.purpose };
+}
+function assessmentAwardFromResult(result, metadata2) {
+  if (metadata2.award) {
+    return metadata2.award;
+  }
+  const xp = result.metadata?.xp;
+  return typeof xp === "number" && Number.isFinite(xp) && xp >= 0 ? { xpAwarded: xp, masteredUnitsApplied: 0 } : null;
+}
+function buildCompletedAssessmentSubmitResult(input) {
+  const attemptId = input.result.sourcedId;
+  const award = assessmentAwardFromResult(input.result, input.metadata);
+  if (award === null) {
+    throw new GoneError("This completed assessment is missing its recorded XP.", {
+      attemptId
+    });
+  }
+  const submitted = buildAssessmentSubmitResult({ attemptId, metadata: input.metadata });
+  if (!submitted) {
+    throw new GoneError("This completed assessment has incomplete persisted results.", {
+      attemptId
+    });
+  }
+  return {
+    ...submitted,
+    status: "completed",
+    xpAwarded: award.xpAwarded,
+    masteredUnitsApplied: award.masteredUnitsApplied,
+    ...award.pctCompleteApp !== undefined ? { pctCompleteApp: award.pctCompleteApp } : {},
+    ...award.warnings ? { warnings: award.warnings } : {}
+  };
+}
+function assessmentAttemptId(input) {
+  return deterministicUUID([
+    "playcademy:assessment-attempt",
+    input.gameId,
+    input.studentId,
+    input.courseId,
+    input.activityId,
+    input.purpose,
+    String(input.attemptNumber)
+  ].join("\x00"));
+}
+async function findLatestAssessmentResult(results, match) {
+  let latest = null;
+  let latestTimestamp = 0;
+  for await (const result of results) {
+    const resultTimestamp = assessmentAttemptTimestamp(result.scoreDate);
+    if (latest && resultTimestamp < latestTimestamp) {
+      break;
+    }
+    const matched = match(result);
+    if (matched !== null && (!latest || compareNewestCompletedAssessmentAttempt({ attemptId: result.sourcedId, scoreDate: result.scoreDate }, {
+      attemptId: latest.result.sourcedId,
+      scoreDate: latest.result.scoreDate
+    }) < 0)) {
+      latest = { result, match: matched };
+      latestTimestamp = resultTimestamp;
+    }
+  }
+  return latest;
+}
+function playableChoice(choice) {
+  return {
+    identifier: choice.identifier,
+    content: choice.content,
+    ...choice.contentNodes ? { contentNodes: choice.contentNodes } : {}
+  };
+}
+function playableAssociableChoice(choice) {
+  const matchMax = qtiAttributeCapacity(choice.attributes, "match-max", 0);
+  if (matchMax === null) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an invalid Match capacity.");
+  }
+  return {
+    ...playableChoice(choice),
+    matchMax
+  };
+}
+function requireChoices2(choices) {
+  if (choices.length === 0 || choices.some((candidate) => !candidate.identifier)) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an interaction Playcademy cannot render.");
+  }
+  return choices;
+}
+function isPlayableAssessmentShape(value) {
+  return PLAYABLE_SHAPE_SET.has(value);
+}
+function playableGraphic(graphic) {
+  return {
+    src: graphic.src,
+    ...graphic.width === undefined ? {} : { width: graphic.width },
+    ...graphic.height === undefined ? {} : { height: graphic.height },
+    ...graphic.description ? { description: graphic.description } : {}
+  };
+}
+function requireGraphic(questionIdentifier, graphic) {
+  if (!graphic) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} is missing a required graphic.`);
+  }
+  return playableGraphic(graphic);
+}
+function requireHotspots(questionIdentifier, hotspots) {
+  if (hotspots.length === 0) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} declares no graphic regions.`);
+  }
+  return hotspots.map((hotspot) => ({
+    identifier: hotspot.identifier,
+    shape: isPlayableAssessmentShape(hotspot.shape) ? hotspot.shape : "default",
+    coords: [...hotspot.coords],
+    ...hotspot.matchMax === undefined ? {} : { matchMax: hotspot.matchMax },
+    ...hotspot.description ? { description: hotspot.description } : {}
+  }));
+}
+function parseInteraction2(questionIdentifier, interaction) {
+  const { type } = interaction;
+  const responseIdentifier = interaction.attributes["response-identifier"];
+  if (!responseIdentifier) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has no response identifier.`);
+  }
+  const prompt = interaction.embeddedPrompt ? { prompt: interaction.embeddedPrompt } : {};
+  if (type === "choice") {
+    const choices = requireChoices2(interaction.choices.map(playableChoice));
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      choices,
+      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 1),
+      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, choices.length)
+    };
+  }
+  if (type === "inline-choice") {
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      choices: requireChoices2(interaction.choices.map(playableChoice))
+    };
+  }
+  if (type === "text-entry") {
+    const expectedLength = qtiAttributeNumber(interaction.attributes, "expected-length", 0);
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      ...Number.isInteger(expectedLength) && expectedLength > 0 ? { expectedLength } : {},
+      ...interaction.attributes.placeholder ? { placeholder: interaction.attributes.placeholder } : {}
+    };
+  }
+  if (type === "order") {
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      choices: requireChoices2(interaction.choices.map(playableChoice)),
+      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle")
+    };
+  }
+  if (type === "match") {
+    const sets = interaction.choiceSets;
+    if (sets.length !== 2) {
+      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "Match interactions require exactly two choice sets.");
+    }
+    const sourceChoices = requireChoices2(sets[0].map(playableAssociableChoice));
+    const targetChoices = requireChoices2(sets[1].map(playableAssociableChoice));
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      sourceChoices,
+      targetChoices,
+      maxAssociations: qtiAttributeMaximum(interaction.attributes, "max-associations", 1, sourceChoices.length * targetChoices.length),
+      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle")
+    };
+  }
+  if (type === "hotspot") {
+    const image = requireGraphic(questionIdentifier, interaction.graphic);
+    const hotspots = requireHotspots(questionIdentifier, interaction.hotspots);
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      image,
+      hotspots,
+      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 1),
+      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, hotspots.length)
+    };
+  }
+  if (type === "gap-match") {
+    if (interaction.gapTexts.length === 0 || interaction.gaps.length === 0 || interaction.textWithGaps === undefined || !interaction.gapContent || !qtiGapContentMatchesGaps(interaction.gapContent, interaction.gaps)) {
+      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has an incomplete gap-match interaction.`);
+    }
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      content: interaction.textWithGaps,
+      contentNodes: interaction.gapContent,
+      gapTexts: interaction.gapTexts.map((gapText) => ({
+        identifier: gapText.identifier,
+        content: gapText.content,
+        matchMax: gapText.matchMax
+      })),
+      gaps: [...interaction.gaps],
+      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 0)
+    };
+  }
+  if (type === "graphic-gap-match") {
+    const image = requireGraphic(questionIdentifier, interaction.graphic);
+    const hotspots = requireHotspots(questionIdentifier, interaction.hotspots);
+    if (interaction.gapImages.length === 0) {
+      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has no draggable gap images.`);
+    }
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      image,
+      gapImages: interaction.gapImages.map((gapImage) => ({
+        identifier: gapImage.identifier,
+        ...gapImage.graphic ? { image: playableGraphic(gapImage.graphic) } : {},
+        matchMax: gapImage.matchMax,
+        ...gapImage.description ? { description: gapImage.description } : {}
+      })),
+      hotspots,
+      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 0)
+    };
+  }
+  if (type === "select-point") {
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      image: requireGraphic(questionIdentifier, interaction.graphic),
+      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 0),
+      maxChoices: qtiAttributeNumber(interaction.attributes, "max-choices", 0)
+    };
+  }
+  if (type === "graphic-associate") {
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      image: requireGraphic(questionIdentifier, interaction.graphic),
+      hotspots: requireHotspots(questionIdentifier, interaction.hotspots),
+      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 1)
+    };
+  }
+  if (type === "position-object") {
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      stage: requireGraphic(questionIdentifier, interaction.graphic),
+      object: requireGraphic(questionIdentifier, interaction.objectGraphic),
+      maxPlacements: qtiAttributeNumber(interaction.attributes, "max-choices", 1)
+    };
+  }
+  if (type === "hottext") {
+    const segments = interaction.textSegments;
+    if (!segments.some((segment) => segment.selectable) || segments.some((segment) => segment.selectable && (!segment.identifier || !segment.content))) {
+      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "Hottext interactions require identified selectable content.");
+    }
+    return {
+      type,
+      responseIdentifier,
+      ...prompt,
+      segments,
+      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, segments.filter((segment) => segment.selectable).length)
+    };
+  }
+  const unsupported = type;
+  throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} uses unsupported interaction ${unsupported}.`);
+}
+function normalizedQtiItem(question) {
+  if (!question.rawXml) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} has no authoritative QTI XML.`);
+  }
+  try {
+    return parseQtiItemXml(question.rawXml);
+  } catch (error88) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} contains invalid QTI XML.`, { reason: errorMessage(error88) });
+  }
+}
+function parsePlayableItem(question) {
+  const parsed = normalizedQtiItem(question);
+  const interactions = playableQtiInteractions(parsed);
+  if (!interactions) {
+    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} must contain only supported interactions with unique response identifiers.`);
+  }
+  return {
+    identifier: question.identifier,
+    title: question.title,
+    prompt: parsed.bodyTextWithBlanks,
+    ...parsed.bodyContent ? { promptContent: parsed.bodyContent } : {},
+    maxScore: qtiItemMaxScore(parsed),
+    interactions: interactions.map((interaction) => parseInteraction2(question.identifier, interaction))
+  };
+}
+function assessmentContentRevision(test, questions) {
+  return sha256Hex(canonicalJson2({
+    identifier: test.identifier,
+    title: test.title,
+    qtiVersion: test.qtiVersion,
+    parts: test["qti-test-part"],
+    questions: questions.questions.map(({ reference, question }) => ({
+      identifier: reference.identifier,
+      rawXml: question.rawXml
+    }))
+  }));
+}
+async function buildPlayableAssessment(test, questions) {
+  return {
+    identifier: test.identifier,
+    contractVersion: PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION,
+    contentRevision: await assessmentContentRevision(test, questions),
+    title: test.title,
+    items: questions.questions.map(({ question }) => parsePlayableItem(question))
+  };
+}
+function assessmentFixtureScoringKeys(assessment, questions) {
+  const questionByIdentifier = new Map(questions.questions.map(({ question }) => [question.identifier, question]));
+  const correctResponses = {};
+  const responseAreas = {};
+  for (const item of assessment.items) {
+    const question = questionByIdentifier.get(item.identifier);
+    const normalizedDeclarations = question ? normalizedQtiItem(question).responseDeclarations : [];
+    const itemResponses = {};
+    for (const interaction of item.interactions) {
+      const responseIdentifier = interaction.responseIdentifier;
+      const declaration = question?.responseDeclarations?.find((candidate) => candidate.identifier === responseIdentifier);
+      const declaredValues = declaration?.correctResponse?.value ?? [];
+      const normalizedDeclaration = normalizedDeclarations.find((candidate) => candidate.identifier === responseIdentifier);
+      const values = declaredValues.length > 0 ? declaredValues : normalizedDeclaration?.correctValues ?? [];
+      const areas = interaction.type === "select-point" || interaction.type === "position-object" ? normalizedDeclaration?.areaMapping?.entries.filter((entry) => entry.value > 0 && isPlayableAssessmentShape(entry.shape)) : undefined;
+      if (areas?.length) {
+        (responseAreas[item.identifier] ??= {})[responseIdentifier] = areas.map((entry) => ({
+          shape: entry.shape,
+          coords: [...entry.coords],
+          value: entry.value
+        }));
+      }
+      if (values.length > 0) {
+        const cardinality = declaration?.cardinality ?? normalizedDeclaration?.cardinality;
+        itemResponses[responseIdentifier] = cardinality === "single" && values.length === 1 ? values[0] : values;
+      } else if (!areas?.length) {
+        throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${item.identifier} has no fixture scoring key.`);
+      }
+    }
+    correctResponses[item.identifier] = itemResponses;
+  }
+  return {
+    correctResponses,
+    ...Object.keys(responseAreas).length > 0 ? { responseAreas } : {}
+  };
+}
+function prepareDiagnosticAssessmentResponses(assessment, current, input) {
+  const update2 = { [input.itemIdentifier]: input.responses };
+  validateAssessmentResponseUpdate(assessment, update2);
+  const responses = applyAssessmentResponseUpdate(current, update2);
+  const item = assessment.items.find((candidate) => candidate.identifier === input.itemIdentifier);
+  const itemResponses = responses[input.itemIdentifier];
+  const missingResponse = item?.interactions.find((interaction) => itemResponses?.[interaction.responseIdentifier] === undefined);
+  if (!item || !itemResponses || missingResponse) {
+    throw new AssessmentRuntimeError("INVALID_RESPONSE", `Diagnostic item ${input.itemIdentifier} requires a response for every interaction.`, {
+      itemIdentifier: input.itemIdentifier,
+      ...missingResponse ? { responseIdentifier: missingResponse.responseIdentifier } : {}
+    });
+  }
+  validateAssessmentResponses(assessment, { [input.itemIdentifier]: itemResponses });
+  return responses;
+}
+function validateAssessmentResponseUpdate(assessment, update2) {
+  const message = assessmentResponseUpdateValidationMessage(assessment, update2);
+  if (message) {
+    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
+  }
+}
+function validateAssessmentResponses(assessment, responses) {
+  const message = assessmentResponseValidationMessage(assessment, responses);
+  if (message) {
+    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
+  }
+}
+function validateAssessmentDraftResponses(assessment, responses) {
+  const message = assessmentDraftResponseValidationMessage(assessment, responses);
+  if (message) {
+    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
+  }
+}
+function assessmentScoringRequests(assessment, responses) {
+  return assessment.items.map((item) => ({
+    itemIdentifier: item.identifier,
+    maxScore: item.maxScore,
+    requests: item.interactions.map((interaction) => ({
+      identifier: interaction.responseIdentifier,
+      response: responses[item.identifier]?.[interaction.responseIdentifier] ?? ""
+    }))
+  }));
+}
+function buildAssessmentResultMetadata(input) {
+  return {
+    [PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY]: input.metadata,
+    assessmentPurpose: input.metadata.purpose,
+    ...assessmentPurposeClassificationFields2(input.metadata.purpose, input)
+  };
+}
+function mergeAssessmentRuntimeMetadata(resultMetadata, metadata2) {
+  return {
+    ...resultMetadata,
+    [PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY]: metadata2
+  };
+}
+function aggregateAssessmentScore(itemScores, possible) {
+  const earned = itemScores.reduce((sum, itemScore) => sum + (Number.isFinite(itemScore) ? itemScore : 0), 0);
+  return {
+    earned,
+    possible,
+    normalized: possible === 0 ? 0 : Math.min(1, Math.max(0, earned / possible))
+  };
+}
+function countCorrectQuestions(verdicts) {
+  return verdicts.filter((verdict) => verdict === true).length;
+}
+function assessmentScoreFromPercentage(percentage, possible) {
+  const normalized = Math.min(1, Math.max(0, (percentage ?? 0) / 100));
+  const earned = Math.round(normalized * possible * 1e6) / 1e6;
+  return { earned, possible, normalized };
+}
+function buildAssessmentResultSubmission(input) {
+  const metadata2 = {
+    ...input.metadata,
+    submissionId: input.submissionId,
+    score: input.score,
+    completion: {
+      testName: input.testName,
+      courseName: input.courseName,
+      totalQuestions: input.totalQuestions,
+      correctQuestions: input.correctQuestions,
+      ...input.session ? { session: input.session } : {},
+      ...input.itemOutcomes ? { itemOutcomes: input.itemOutcomes } : {},
+      ...input.diagnosticTracks ? { diagnosticTracks: input.diagnosticTracks } : {}
+    },
+    updatedAt: input.timestamp
+  };
+  return {
+    metadata: metadata2,
+    resultUpdate: {
+      status: input.result.status,
+      assessmentLineItem: input.result.assessmentLineItem,
+      student: input.result.student,
+      score: input.score.normalized * 100,
+      scoreDate: input.timestamp,
+      ...ASSESSMENT_ATTEMPT_AWAITING_AWARD,
+      metadata: mergeAssessmentRuntimeMetadata(input.result.metadata, metadata2)
+    }
+  };
+}
+function buildAssessmentResultAwardFinalization(input) {
+  const completion = input.metadata.completion;
+  if (!completion || completion.totalQuestions === undefined) {
+    throw new Error("A scored assessment must retain its completion facts before finalization");
+  }
+  const metadata2 = {
+    ...input.metadata,
+    finalizedAt: input.timestamp,
+    updatedAt: input.timestamp,
+    award: input.award
+  };
+  const masteryRequested = input.award.masteredUnits !== undefined || input.award.masteredUnitsAbsolute !== undefined;
+  return {
+    metadata: metadata2,
+    resultUpdate: {
+      status: input.result.status,
+      assessmentLineItem: input.result.assessmentLineItem,
+      student: input.result.student,
+      score: input.result.score ?? 0,
+      scoreDate: input.result.scoreDate,
+      ...ASSESSMENT_ATTEMPT_COMPLETED,
+      metadata: {
+        ...mergeAssessmentRuntimeMetadata(input.result.metadata, metadata2),
+        xp: input.award.xpAwarded,
+        ...masteryRequested ? { masteredUnits: input.award.masteredUnitsApplied } : {},
+        totalQuestions: completion.totalQuestions,
+        correctQuestions: completion.correctQuestions,
+        appName: input.appName
+      }
+    }
+  };
+}
+var PLAYABLE_SHAPE_SET;
+var init_timeback_assessment_runtime_util = __esm(() => {
+  init_src();
+  init_assessment_runtime2();
+  init_qti();
+  init_types2();
+  init_utils6();
+  init_timeback4();
+  init_uuid();
+  init_errors2();
+  PLAYABLE_SHAPE_SET = new Set(PLAYABLE_ASSESSMENT_SHAPES);
+});
+
 // ../api-core/src/utils/timeback-qti-authoring.util.ts
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
@@ -99482,810 +101449,6 @@ var init_timeback_qti_authoring_util = __esm(() => {
   ];
 });
 
-// ../api-core/src/utils/timeback-assessment-runtime.util.ts
-function assessmentPreparationContentionError(expectedResponseVersion, responseVersion, kind) {
-  if (expectedResponseVersion === responseVersion) {
-    return new ServiceUnavailableError(`The ${kind} response state changed repeatedly while this item was being prepared. Try again shortly.`, {
-      retryable: true,
-      reason: "PREPARATION_CONTENTION",
-      expectedResponseVersion,
-      responseVersion
-    });
-  }
-  return AssessmentRuntimeError.from(assessmentResponseVersionConflict(expectedResponseVersion, responseVersion));
-}
-function assessmentTrackableCourse(integration) {
-  if (!isTimebackGrade2(integration.grade) || !isTimebackSubject(integration.subject)) {
-    return null;
-  }
-  return { grade: integration.grade, subject: integration.subject };
-}
-function buildAssessmentActivityData(input) {
-  if (!input.course) {
-    return;
-  }
-  return {
-    activityId: input.activityId,
-    activityName: input.activityName,
-    ...input.course,
-    courseId: input.courseId
-  };
-}
-function buildDiagnosticAssessmentSnapshot(input) {
-  return {
-    attemptId: input.attemptId,
-    responseVersion: input.metadata.responseVersion,
-    status: "in_progress",
-    flow: "platform-routed-item-submit",
-    ...input.activityData ? { activityData: input.activityData } : {},
-    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
-    selection: {
-      kind: "platform-routed-diagnostic",
-      purpose: "diagnostic",
-      definitionId: input.metadata.diagnostic.definitionId,
-      diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-      routingRevision: input.metadata.diagnostic.routingRevision
-    },
-    routing: projectDiagnosticRoutingSnapshot(input.metadata.diagnostic.routingRevision, input.state),
-    completion: null
-  };
-}
-function buildConventionalAssessmentSnapshot(input) {
-  const metadata2 = input.metadata;
-  let selection;
-  if (metadata2.purpose === "review") {
-    selection = {
-      kind: "standards-review",
-      purpose: metadata2.purpose,
-      standards: [...metadata2.review.standards],
-      candidateItemsPerStandard: metadata2.review.candidateItemsPerStandard,
-      selections: [...metadata2.review.selections],
-      fulfillment: metadata2.review.fulfillment
-    };
-  } else if (metadata2.purpose === "mastery") {
-    selection = {
-      kind: "standard-quiz",
-      purpose: metadata2.purpose,
-      standard: metadata2.mastery.standard
-    };
-  } else {
-    selection = { kind: "fixed-test", purpose: metadata2.purpose };
-  }
-  return {
-    attemptId: input.attemptId,
-    responseVersion: metadata2.responseVersion,
-    status: "in_progress",
-    flow: assessmentFlowForPurpose(metadata2.purpose),
-    ...input.activityData ? { activityData: input.activityData } : {},
-    assessment: assessmentPresentationForAttempt(input.assessment, input.attemptId),
-    responses: metadata2.responses,
-    itemSubmissions: metadata2.itemSubmissions,
-    score: null,
-    selection
-  };
-}
-function buildAssessmentAwardRecord(input, mastery) {
-  return {
-    xpAwarded: input.xpAwarded,
-    ...input.masteredUnits !== undefined ? { masteredUnits: input.masteredUnits } : {},
-    ...input.masteredUnitsAbsolute !== undefined ? { masteredUnitsAbsolute: input.masteredUnitsAbsolute } : {},
-    masteredUnitsApplied: mastery.masteredUnitsApplied,
-    ...mastery.pctCompleteApp !== undefined ? { pctCompleteApp: mastery.pctCompleteApp } : {},
-    ...mastery.warnings ? { warnings: mastery.warnings } : {}
-  };
-}
-function stageAssessmentAttemptSupersession(attempt) {
-  Object.assign(attempt.result, ASSESSMENT_ATTEMPT_SUPERSEDED);
-  Object.assign(attempt.selection, ASSESSMENT_ATTEMPT_SUPERSEDED);
-}
-function shouldConfirmAssessmentVersionUnavailable(details) {
-  return typeof details === "object" && details !== null && "expectedRevision" in details && typeof details.expectedRevision === "string" && !("currentRevision" in details);
-}
-function buildAssessmentAttemptSupersessionUpdate(result) {
-  if (result.status !== "active" || !isAssessmentAttemptOpen({
-    inProgress: result.inProgress ?? "",
-    scoreStatus: result.scoreStatus
-  })) {
-    return null;
-  }
-  return {
-    status: "active",
-    assessmentLineItem: result.assessmentLineItem,
-    student: result.student,
-    score: result.score ?? 0,
-    scoreDate: result.scoreDate,
-    ...ASSESSMENT_ATTEMPT_SUPERSEDED,
-    metadata: result.metadata ?? {}
-  };
-}
-async function resolveAvailableAssessmentAttempt(initialDecision, select3, resume) {
-  let decision = initialDecision;
-  while (decision?.kind === "resume") {
-    const snapshot = await resume(decision);
-    if (snapshot !== null) {
-      return { kind: "resumed", snapshot };
-    }
-    decision = select3();
-  }
-  return { kind: "continue", decision };
-}
-function buildReviewItemResultMetadata(input) {
-  const administration = itemAdministration(input.metadata.itemSubmissions, input.selection.itemIdentifier);
-  if (!administration) {
-    throw new Error(`Cannot create a review result for unadministered candidate ${input.selection.itemIdentifier}`);
-  }
-  return {
-    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
-    parentAttemptId: input.parentAttemptId,
-    activityId: input.metadata.activityId,
-    integrationId: input.metadata.integrationId,
-    enrollmentId: input.metadata.enrollmentId,
-    bankRevision: input.metadata.review.bankRevision,
-    itemIdentifier: input.selection.itemIdentifier,
-    standard: input.selection.standard,
-    deliveredAt: administration.submittedAt,
-    responseVersion: input.responseVersion ?? input.metadata.responseVersion,
-    responses: input.metadata.responses[input.selection.itemIdentifier] ?? {},
-    ...input.submissionId ? { submissionId: input.submissionId } : {},
-    ...input.isCorrect === undefined ? {} : { isCorrect: input.isCorrect }
-  };
-}
-function buildOpenReviewChildResult(input) {
-  return {
-    status: "active",
-    assessmentLineItem: { sourcedId: input.childLineItemId },
-    student: input.student,
-    score: 0,
-    scoreDate: input.metadata.deliveredAt,
-    ...ASSESSMENT_ATTEMPT_OPEN,
-    metadata: {
-      [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: input.metadata
-    }
-  };
-}
-function diagnosticQuestionLineItemId(parentLineItemId, itemIdentifier) {
-  return deterministicUUID(["playcademy:diagnostic-question-line-item:v1", parentLineItemId, itemIdentifier].join("\x00"));
-}
-function diagnosticQuestionResultId(parentAttemptId, childLineItemId) {
-  return deterministicUUID(["playcademy:diagnostic-question-result:v1", parentAttemptId, childLineItemId].join("\x00"));
-}
-function diagnosticAdministration(input) {
-  const ledgerIndex = input.metadata.diagnostic.ledger.findIndex((entry) => entry.routingNodeKey === input.ledgerEntry.routingNodeKey);
-  const persistedEntry = input.metadata.diagnostic.ledger[ledgerIndex];
-  const administration = input.metadata.itemSubmissions[ledgerIndex];
-  if (ledgerIndex === -1 || !persistedEntry || !administration || persistedEntry.stageKey !== input.ledgerEntry.stageKey || persistedEntry.trackKey !== input.ledgerEntry.trackKey || persistedEntry.itemIdentifier !== input.ledgerEntry.itemIdentifier || persistedEntry.isCorrect !== input.ledgerEntry.isCorrect || administration.itemIdentifier !== input.ledgerEntry.itemIdentifier || administration.isCorrect !== input.ledgerEntry.isCorrect) {
-    throw new Error(`Cannot create a diagnostic result for uncommitted routing node ${input.ledgerEntry.routingNodeKey}`);
-  }
-  return administration;
-}
-function buildDiagnosticItemResultMetadata(input) {
-  const administration = diagnosticAdministration(input);
-  return {
-    version: PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_VERSION,
-    parentAttemptId: input.parentAttemptId,
-    activityId: input.metadata.activityId,
-    integrationId: input.metadata.integrationId,
-    enrollmentId: input.metadata.enrollmentId,
-    definitionId: input.metadata.diagnostic.definitionId,
-    diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-    routingRevision: input.metadata.diagnostic.routingRevision,
-    contentRevision: input.metadata.selectedTest.contentRevision,
-    stageKey: input.ledgerEntry.stageKey,
-    trackKey: input.ledgerEntry.trackKey,
-    routingNodeKey: input.ledgerEntry.routingNodeKey,
-    itemIdentifier: input.ledgerEntry.itemIdentifier,
-    deliveredAt: administration.submittedAt,
-    responseVersion: administration.responseVersion,
-    responses: input.metadata.responses[input.ledgerEntry.itemIdentifier] ?? {},
-    submissionId: administration.submissionId,
-    isCorrect: input.ledgerEntry.isCorrect
-  };
-}
-function resolveDiagnosticChildResult(input) {
-  if (!input.childResult) {
-    return { action: "create" };
-  }
-  const childMetadata = playcademyDiagnosticAssessmentItemResultMetadata(input.childResult.metadata);
-  const expectedMetadata = buildDiagnosticItemResultMetadata({
-    metadata: input.parentMetadata,
-    ledgerEntry: input.ledgerEntry,
-    parentAttemptId: input.parentResult.sourcedId
-  });
-  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || canonicalJson2(childMetadata) !== canonicalJson2(expectedMetadata)) {
-    return { action: "restore", reason: "incompatible" };
-  }
-  return input.childResult.status === "active" ? { action: "reuse", metadata: expectedMetadata } : { action: "restore", reason: "inactive" };
-}
-function buildFinalizedDiagnosticChildResult(input) {
-  const administration = diagnosticAdministration(input);
-  const metadata2 = buildDiagnosticItemResultMetadata(input);
-  return {
-    resultUpdate: {
-      status: "active",
-      assessmentLineItem: { sourcedId: input.childLineItemId },
-      student: input.student,
-      score: administration.score.earned,
-      scoreDate: administration.submittedAt,
-      ...ASSESSMENT_ATTEMPT_COMPLETED,
-      metadata: {
-        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
-      }
-    }
-  };
-}
-function buildFinalizedReviewChildResult(input) {
-  const metadata2 = buildReviewItemResultMetadata({
-    metadata: input.metadata,
-    selection: input.selection,
-    parentAttemptId: input.parentAttemptId,
-    submissionId: input.submissionId,
-    isCorrect: input.itemResult.isCorrect
-  });
-  return {
-    resultUpdate: {
-      status: "active",
-      assessmentLineItem: { sourcedId: input.childLineItemId },
-      student: input.student,
-      score: input.itemResult.score.earned,
-      scoreDate: input.timestamp,
-      ...ASSESSMENT_ATTEMPT_COMPLETED,
-      metadata: {
-        [PLAYCADEMY_ASSESSMENT_ITEM_RESULT_METADATA_KEY]: metadata2
-      }
-    },
-    outcome: {
-      itemIdentifier: input.selection.itemIdentifier,
-      standard: input.selection.standard,
-      answered: Object.keys(input.metadata.responses[input.selection.itemIdentifier] ?? {}).length > 0,
-      score: input.itemResult.score,
-      isCorrect: input.itemResult.isCorrect
-    }
-  };
-}
-function resolveReviewChildResult(input) {
-  if (!input.childResult) {
-    return { action: "create" };
-  }
-  const childMetadata = playcademyAssessmentItemResultMetadata(input.childResult.metadata);
-  const expectedResponses = input.parentMetadata.responses[input.selection.itemIdentifier] ?? {};
-  const administration = itemAdministration(input.parentMetadata.itemSubmissions, input.selection.itemIdentifier);
-  if (input.childResult.assessmentLineItem.sourcedId !== input.childLineItemId || input.childResult.student.sourcedId !== input.parentResult.student.sourcedId || !childMetadata || childMetadata.parentAttemptId !== input.parentResult.sourcedId || childMetadata.activityId !== input.parentMetadata.activityId || childMetadata.integrationId !== input.parentMetadata.integrationId || childMetadata.enrollmentId !== input.parentMetadata.enrollmentId || childMetadata.bankRevision !== input.parentMetadata.review.bankRevision || childMetadata.itemIdentifier !== input.selection.itemIdentifier || childMetadata.standard.framework !== input.selection.standard.framework || childMetadata.standard.identifier !== input.selection.standard.identifier || childMetadata.deliveredAt !== administration?.submittedAt || childMetadata.responseVersion > input.parentMetadata.responseVersion || canonicalJson2(childMetadata.responses) !== canonicalJson2(expectedResponses)) {
-    return { action: "restore", reason: "incompatible" };
-  }
-  return input.childResult.status === "active" ? { action: "reuse", metadata: childMetadata } : { action: "restore", reason: "inactive" };
-}
-function buildAssessmentSubmitResult(input) {
-  if (!input.metadata.score || !input.metadata.submissionId) {
-    return null;
-  }
-  if (input.metadata.purpose === "diagnostic" && input.metadata.diagnostic) {
-    const tracks = input.metadata.completion?.diagnosticTracks;
-    return tracks ? {
-      purpose: input.metadata.purpose,
-      attemptId: input.attemptId,
-      submissionId: input.metadata.submissionId,
-      diagnosticKey: input.metadata.diagnostic.diagnosticKey,
-      responseVersion: input.metadata.responseVersion,
-      status: "awaiting_award",
-      tracks
-    } : null;
-  }
-  const base = {
-    attemptId: input.attemptId,
-    submissionId: input.metadata.submissionId,
-    responseVersion: input.metadata.responseVersion,
-    status: "awaiting_award",
-    responses: input.metadata.responses,
-    score: input.metadata.score
-  };
-  if (input.metadata.purpose === "review") {
-    const itemOutcomes = input.metadata.completion?.itemOutcomes;
-    return itemOutcomes ? { ...base, purpose: input.metadata.purpose, itemOutcomes } : null;
-  }
-  return { ...base, purpose: input.metadata.purpose };
-}
-function assessmentAwardFromResult(result, metadata2) {
-  if (metadata2.award) {
-    return metadata2.award;
-  }
-  const xp = result.metadata?.xp;
-  return typeof xp === "number" && Number.isFinite(xp) && xp >= 0 ? { xpAwarded: xp, masteredUnitsApplied: 0 } : null;
-}
-function buildCompletedAssessmentSubmitResult(input) {
-  const attemptId = input.result.sourcedId;
-  const award = assessmentAwardFromResult(input.result, input.metadata);
-  if (award === null) {
-    throw new GoneError("This completed assessment is missing its recorded XP.", {
-      attemptId
-    });
-  }
-  const submitted = buildAssessmentSubmitResult({ attemptId, metadata: input.metadata });
-  if (!submitted) {
-    throw new GoneError("This completed assessment has incomplete persisted results.", {
-      attemptId
-    });
-  }
-  return {
-    ...submitted,
-    status: "completed",
-    xpAwarded: award.xpAwarded,
-    masteredUnitsApplied: award.masteredUnitsApplied,
-    ...award.pctCompleteApp !== undefined ? { pctCompleteApp: award.pctCompleteApp } : {},
-    ...award.warnings ? { warnings: award.warnings } : {}
-  };
-}
-function assessmentAttemptId(input) {
-  return deterministicUUID([
-    "playcademy:assessment-attempt",
-    input.gameId,
-    input.studentId,
-    input.courseId,
-    input.activityId,
-    input.purpose,
-    String(input.attemptNumber)
-  ].join("\x00"));
-}
-async function findLatestAssessmentResult(results, match) {
-  let latest = null;
-  let latestTimestamp = 0;
-  for await (const result of results) {
-    const resultTimestamp = assessmentAttemptTimestamp(result.scoreDate);
-    if (latest && resultTimestamp < latestTimestamp) {
-      break;
-    }
-    const matched = match(result);
-    if (matched !== null && (!latest || compareNewestCompletedAssessmentAttempt({ attemptId: result.sourcedId, scoreDate: result.scoreDate }, {
-      attemptId: latest.result.sourcedId,
-      scoreDate: latest.result.scoreDate
-    }) < 0)) {
-      latest = { result, match: matched };
-      latestTimestamp = resultTimestamp;
-    }
-  }
-  return latest;
-}
-function playableChoice(choice) {
-  return {
-    identifier: choice.identifier,
-    content: choice.content,
-    ...choice.contentNodes ? { contentNodes: choice.contentNodes } : {}
-  };
-}
-function playableAssociableChoice(choice) {
-  const matchMax = qtiAttributeCapacity(choice.attributes, "match-max", 0);
-  if (matchMax === null) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an invalid Match capacity.");
-  }
-  return {
-    ...playableChoice(choice),
-    matchMax
-  };
-}
-function requireChoices2(choices) {
-  if (choices.length === 0 || choices.some((candidate) => !candidate.identifier)) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "The selected assessment contains an interaction Playcademy cannot render.");
-  }
-  return choices;
-}
-function isPlayableAssessmentShape(value) {
-  return PLAYABLE_SHAPE_SET.has(value);
-}
-function playableGraphic(graphic) {
-  return {
-    src: graphic.src,
-    ...graphic.width === undefined ? {} : { width: graphic.width },
-    ...graphic.height === undefined ? {} : { height: graphic.height },
-    ...graphic.description ? { description: graphic.description } : {}
-  };
-}
-function requireGraphic(questionIdentifier, graphic) {
-  if (!graphic) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} is missing a required graphic.`);
-  }
-  return playableGraphic(graphic);
-}
-function requireHotspots(questionIdentifier, hotspots) {
-  if (hotspots.length === 0) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} declares no graphic regions.`);
-  }
-  return hotspots.map((hotspot) => ({
-    identifier: hotspot.identifier,
-    shape: isPlayableAssessmentShape(hotspot.shape) ? hotspot.shape : "default",
-    coords: [...hotspot.coords],
-    ...hotspot.matchMax === undefined ? {} : { matchMax: hotspot.matchMax },
-    ...hotspot.description ? { description: hotspot.description } : {}
-  }));
-}
-function parseInteraction2(questionIdentifier, interaction) {
-  const { type } = interaction;
-  const responseIdentifier = interaction.attributes["response-identifier"];
-  if (!responseIdentifier) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has no response identifier.`);
-  }
-  const prompt = interaction.embeddedPrompt ? { prompt: interaction.embeddedPrompt } : {};
-  if (type === "choice") {
-    const choices = requireChoices2(interaction.choices.map(playableChoice));
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      choices,
-      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 1),
-      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, choices.length)
-    };
-  }
-  if (type === "inline-choice") {
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      choices: requireChoices2(interaction.choices.map(playableChoice))
-    };
-  }
-  if (type === "text-entry") {
-    const expectedLength = qtiAttributeNumber(interaction.attributes, "expected-length", 0);
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      ...Number.isInteger(expectedLength) && expectedLength > 0 ? { expectedLength } : {},
-      ...interaction.attributes.placeholder ? { placeholder: interaction.attributes.placeholder } : {}
-    };
-  }
-  if (type === "order") {
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      choices: requireChoices2(interaction.choices.map(playableChoice)),
-      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle")
-    };
-  }
-  if (type === "match") {
-    const sets = interaction.choiceSets;
-    if (sets.length !== 2) {
-      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "Match interactions require exactly two choice sets.");
-    }
-    const sourceChoices = requireChoices2(sets[0].map(playableAssociableChoice));
-    const targetChoices = requireChoices2(sets[1].map(playableAssociableChoice));
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      sourceChoices,
-      targetChoices,
-      maxAssociations: qtiAttributeMaximum(interaction.attributes, "max-associations", 1, sourceChoices.length * targetChoices.length),
-      shuffle: qtiAttributeBoolean(interaction.attributes, "shuffle")
-    };
-  }
-  if (type === "hotspot") {
-    const image = requireGraphic(questionIdentifier, interaction.graphic);
-    const hotspots = requireHotspots(questionIdentifier, interaction.hotspots);
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      image,
-      hotspots,
-      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 1),
-      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, hotspots.length)
-    };
-  }
-  if (type === "gap-match") {
-    if (interaction.gapTexts.length === 0 || interaction.gaps.length === 0 || interaction.textWithGaps === undefined || !interaction.gapContent || !qtiGapContentMatchesGaps(interaction.gapContent, interaction.gaps)) {
-      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has an incomplete gap-match interaction.`);
-    }
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      content: interaction.textWithGaps,
-      contentNodes: interaction.gapContent,
-      gapTexts: interaction.gapTexts.map((gapText) => ({
-        identifier: gapText.identifier,
-        content: gapText.content,
-        matchMax: gapText.matchMax
-      })),
-      gaps: [...interaction.gaps],
-      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 0)
-    };
-  }
-  if (type === "graphic-gap-match") {
-    const image = requireGraphic(questionIdentifier, interaction.graphic);
-    const hotspots = requireHotspots(questionIdentifier, interaction.hotspots);
-    if (interaction.gapImages.length === 0) {
-      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} has no draggable gap images.`);
-    }
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      image,
-      gapImages: interaction.gapImages.map((gapImage) => ({
-        identifier: gapImage.identifier,
-        ...gapImage.graphic ? { image: playableGraphic(gapImage.graphic) } : {},
-        matchMax: gapImage.matchMax,
-        ...gapImage.description ? { description: gapImage.description } : {}
-      })),
-      hotspots,
-      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 0)
-    };
-  }
-  if (type === "select-point") {
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      image: requireGraphic(questionIdentifier, interaction.graphic),
-      minChoices: qtiAttributeNumber(interaction.attributes, "min-choices", 0),
-      maxChoices: qtiAttributeNumber(interaction.attributes, "max-choices", 0)
-    };
-  }
-  if (type === "graphic-associate") {
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      image: requireGraphic(questionIdentifier, interaction.graphic),
-      hotspots: requireHotspots(questionIdentifier, interaction.hotspots),
-      maxAssociations: qtiAttributeNumber(interaction.attributes, "max-associations", 1)
-    };
-  }
-  if (type === "position-object") {
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      stage: requireGraphic(questionIdentifier, interaction.graphic),
-      object: requireGraphic(questionIdentifier, interaction.objectGraphic),
-      maxPlacements: qtiAttributeNumber(interaction.attributes, "max-choices", 1)
-    };
-  }
-  if (type === "hottext") {
-    const segments = interaction.textSegments;
-    if (!segments.some((segment) => segment.selectable) || segments.some((segment) => segment.selectable && (!segment.identifier || !segment.content))) {
-      throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", "Hottext interactions require identified selectable content.");
-    }
-    return {
-      type,
-      responseIdentifier,
-      ...prompt,
-      segments,
-      maxChoices: qtiAttributeMaximum(interaction.attributes, "max-choices", 1, segments.filter((segment) => segment.selectable).length)
-    };
-  }
-  const unsupported = type;
-  throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${questionIdentifier} uses unsupported interaction ${unsupported}.`);
-}
-function normalizedQtiItem(question) {
-  if (!question.rawXml) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} has no authoritative QTI XML.`);
-  }
-  try {
-    return parseQtiItemXml(question.rawXml);
-  } catch (error88) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} contains invalid QTI XML.`, { reason: errorMessage(error88) });
-  }
-}
-function parsePlayableItem(question) {
-  const parsed = normalizedQtiItem(question);
-  const interactions = playableQtiInteractions(parsed);
-  if (!interactions) {
-    throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${question.identifier} must contain only supported interactions with unique response identifiers.`);
-  }
-  return {
-    identifier: question.identifier,
-    title: question.title,
-    prompt: parsed.bodyTextWithBlanks,
-    ...parsed.bodyContent ? { promptContent: parsed.bodyContent } : {},
-    maxScore: qtiItemMaxScore(parsed),
-    interactions: interactions.map((interaction) => parseInteraction2(question.identifier, interaction))
-  };
-}
-function assessmentContentRevision(test, questions) {
-  return sha256Hex(canonicalJson2({
-    identifier: test.identifier,
-    title: test.title,
-    qtiVersion: test.qtiVersion,
-    parts: test["qti-test-part"],
-    questions: questions.questions.map(({ reference, question }) => ({
-      identifier: reference.identifier,
-      rawXml: question.rawXml
-    }))
-  }));
-}
-async function buildPlayableAssessment(test, questions) {
-  return {
-    identifier: test.identifier,
-    contractVersion: PLAYCADEMY_ASSESSMENT_CONTRACT_VERSION,
-    contentRevision: await assessmentContentRevision(test, questions),
-    title: test.title,
-    items: questions.questions.map(({ question }) => parsePlayableItem(question))
-  };
-}
-function assessmentFixtureScoringKeys(assessment, questions) {
-  const questionByIdentifier = new Map(questions.questions.map(({ question }) => [question.identifier, question]));
-  const correctResponses = {};
-  const responseAreas = {};
-  for (const item of assessment.items) {
-    const question = questionByIdentifier.get(item.identifier);
-    const normalizedDeclarations = question ? normalizedQtiItem(question).responseDeclarations : [];
-    const itemResponses = {};
-    for (const interaction of item.interactions) {
-      const responseIdentifier = interaction.responseIdentifier;
-      const declaration = question?.responseDeclarations?.find((candidate) => candidate.identifier === responseIdentifier);
-      const declaredValues = declaration?.correctResponse?.value ?? [];
-      const normalizedDeclaration = normalizedDeclarations.find((candidate) => candidate.identifier === responseIdentifier);
-      const values = declaredValues.length > 0 ? declaredValues : normalizedDeclaration?.correctValues ?? [];
-      const areas = interaction.type === "select-point" || interaction.type === "position-object" ? normalizedDeclaration?.areaMapping?.entries.filter((entry) => entry.value > 0 && isPlayableAssessmentShape(entry.shape)) : undefined;
-      if (areas?.length) {
-        (responseAreas[item.identifier] ??= {})[responseIdentifier] = areas.map((entry) => ({
-          shape: entry.shape,
-          coords: [...entry.coords],
-          value: entry.value
-        }));
-      }
-      if (values.length > 0) {
-        const cardinality = declaration?.cardinality ?? normalizedDeclaration?.cardinality;
-        itemResponses[responseIdentifier] = cardinality === "single" && values.length === 1 ? values[0] : values;
-      } else if (!areas?.length) {
-        throw new AssessmentRuntimeError("UNSUPPORTED_INTERACTION", `Assessment item ${item.identifier} has no fixture scoring key.`);
-      }
-    }
-    correctResponses[item.identifier] = itemResponses;
-  }
-  return {
-    correctResponses,
-    ...Object.keys(responseAreas).length > 0 ? { responseAreas } : {}
-  };
-}
-function prepareDiagnosticAssessmentResponses(assessment, current, input) {
-  const update2 = { [input.itemIdentifier]: input.responses };
-  validateAssessmentResponseUpdate(assessment, update2);
-  const responses = applyAssessmentResponseUpdate(current, update2);
-  const item = assessment.items.find((candidate) => candidate.identifier === input.itemIdentifier);
-  const itemResponses = responses[input.itemIdentifier];
-  const missingResponse = item?.interactions.find((interaction) => itemResponses?.[interaction.responseIdentifier] === undefined);
-  if (!item || !itemResponses || missingResponse) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", `Diagnostic item ${input.itemIdentifier} requires a response for every interaction.`, {
-      itemIdentifier: input.itemIdentifier,
-      ...missingResponse ? { responseIdentifier: missingResponse.responseIdentifier } : {}
-    });
-  }
-  validateAssessmentResponses(assessment, { [input.itemIdentifier]: itemResponses });
-  return responses;
-}
-function validateAssessmentResponseUpdate(assessment, update2) {
-  const message = assessmentResponseUpdateValidationMessage(assessment, update2);
-  if (message) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
-  }
-}
-function validateAssessmentResponses(assessment, responses) {
-  const message = assessmentResponseValidationMessage(assessment, responses);
-  if (message) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
-  }
-}
-function validateAssessmentDraftResponses(assessment, responses) {
-  const message = assessmentDraftResponseValidationMessage(assessment, responses);
-  if (message) {
-    throw new AssessmentRuntimeError("INVALID_RESPONSE", message);
-  }
-}
-function assessmentScoringRequests(assessment, responses) {
-  return assessment.items.map((item) => ({
-    itemIdentifier: item.identifier,
-    maxScore: item.maxScore,
-    requests: item.interactions.map((interaction) => ({
-      identifier: interaction.responseIdentifier,
-      response: responses[item.identifier]?.[interaction.responseIdentifier] ?? ""
-    }))
-  }));
-}
-function buildAssessmentResultMetadata(input) {
-  return {
-    [PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY]: input.metadata,
-    assessmentPurpose: input.metadata.purpose,
-    ...assessmentPurposeClassificationFields2(input.metadata.purpose, input)
-  };
-}
-function mergeAssessmentRuntimeMetadata(resultMetadata, metadata2) {
-  return {
-    ...resultMetadata,
-    [PLAYCADEMY_ASSESSMENT_RESULT_METADATA_KEY]: metadata2
-  };
-}
-function aggregateAssessmentScore(itemScores, possible) {
-  const earned = itemScores.reduce((sum, itemScore) => sum + (Number.isFinite(itemScore) ? itemScore : 0), 0);
-  return {
-    earned,
-    possible,
-    normalized: possible === 0 ? 0 : Math.min(1, Math.max(0, earned / possible))
-  };
-}
-function countCorrectQuestions(verdicts) {
-  return verdicts.filter((verdict) => verdict === true).length;
-}
-function assessmentScoreFromPercentage(percentage, possible) {
-  const normalized = Math.min(1, Math.max(0, (percentage ?? 0) / 100));
-  const earned = Math.round(normalized * possible * 1e6) / 1e6;
-  return { earned, possible, normalized };
-}
-function buildAssessmentResultSubmission(input) {
-  const metadata2 = {
-    ...input.metadata,
-    submissionId: input.submissionId,
-    score: input.score,
-    completion: {
-      testName: input.testName,
-      courseName: input.courseName,
-      totalQuestions: input.totalQuestions,
-      correctQuestions: input.correctQuestions,
-      ...input.session ? { session: input.session } : {},
-      ...input.itemOutcomes ? { itemOutcomes: input.itemOutcomes } : {},
-      ...input.diagnosticTracks ? { diagnosticTracks: input.diagnosticTracks } : {}
-    },
-    updatedAt: input.timestamp
-  };
-  return {
-    metadata: metadata2,
-    resultUpdate: {
-      status: input.result.status,
-      assessmentLineItem: input.result.assessmentLineItem,
-      student: input.result.student,
-      score: input.score.normalized * 100,
-      scoreDate: input.timestamp,
-      ...ASSESSMENT_ATTEMPT_AWAITING_AWARD,
-      metadata: mergeAssessmentRuntimeMetadata(input.result.metadata, metadata2)
-    }
-  };
-}
-function buildAssessmentResultAwardFinalization(input) {
-  const completion = input.metadata.completion;
-  if (!completion || completion.totalQuestions === undefined) {
-    throw new Error("A scored assessment must retain its completion facts before finalization");
-  }
-  const metadata2 = {
-    ...input.metadata,
-    finalizedAt: input.timestamp,
-    updatedAt: input.timestamp,
-    award: input.award
-  };
-  const masteryRequested = input.award.masteredUnits !== undefined || input.award.masteredUnitsAbsolute !== undefined;
-  return {
-    metadata: metadata2,
-    resultUpdate: {
-      status: input.result.status,
-      assessmentLineItem: input.result.assessmentLineItem,
-      student: input.result.student,
-      score: input.result.score ?? 0,
-      scoreDate: input.result.scoreDate,
-      ...ASSESSMENT_ATTEMPT_COMPLETED,
-      metadata: {
-        ...mergeAssessmentRuntimeMetadata(input.result.metadata, metadata2),
-        xp: input.award.xpAwarded,
-        ...masteryRequested ? { masteredUnits: input.award.masteredUnitsApplied } : {},
-        totalQuestions: completion.totalQuestions,
-        correctQuestions: completion.correctQuestions,
-        appName: input.appName
-      }
-    }
-  };
-}
-var PLAYABLE_SHAPE_SET;
-var init_timeback_assessment_runtime_util = __esm(() => {
-  init_src();
-  init_assessment_runtime2();
-  init_qti();
-  init_types2();
-  init_utils6();
-  init_timeback4();
-  init_uuid();
-  init_errors2();
-  PLAYABLE_SHAPE_SET = new Set(PLAYABLE_ASSESSMENT_SHAPES);
-});
-
 // ../api-core/src/utils/timeback-review-mapping.util.ts
 function reviewBankTestItemIdentifiers(test) {
   return qtiTestParts(test).flatMap((part) => part["qti-assessment-section"].flatMap((section) => (section["qti-assessment-item-ref"] ?? []).map((reference) => reference.identifier)));
@@ -100539,7 +101702,7 @@ async function prepareReviewMappingUpdate(test, questions) {
     }
   };
 }
-var PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink", PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1, StoredSinkWarningSchema, ReviewBankSinkMarkerSchema;
+var PLAYCADEMY_REVIEW_BANK_TITLE = "Review Bank", PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink", PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1, StoredSinkWarningSchema, ReviewBankSinkMarkerSchema;
 var init_timeback_review_mapping_util = __esm(() => {
   init_esm();
   init_assessment_runtime2();
@@ -100582,6 +101745,259 @@ var init_timeback_review_mapping_util = __esm(() => {
   });
 });
 
+// ../api-core/src/utils/timeback-assessment-artifacts.util.ts
+async function storeAndVerifyCompiledAssessmentArtifacts(input) {
+  await input.store(input.compiled);
+  const assessment = await input.loadPlayable(input.compiled.identity);
+  const scoring = assessment ? await input.loadMatchedScoring(assessment, input.compiled.identity) : null;
+  if (!assessment || !scoring) {
+    throw new ServiceUnavailableError(`Prepared ${input.label} could not be verified.`);
+  }
+  return assessment;
+}
+function assertSourceIdentity(source) {
+  if (source.test.identifier !== source.questions.assessmentTest) {
+    throw new ValidationError(`QTI questions for ${source.questions.assessmentTest} do not describe ${source.test.identifier}`);
+  }
+}
+function sourceItemIdentifiers(source) {
+  return source.questions.questions.map(({ question }) => question.identifier);
+}
+function compileScoringArtifact(questions) {
+  try {
+    return compileQtiScoringArtifact(questions);
+  } catch (error88) {
+    if (error88 instanceof QtiScoringArtifactValidationError) {
+      throw new ValidationError(error88.message);
+    }
+    throw error88;
+  }
+}
+function qtiFallbackItemCount(compiled) {
+  return compiled.scoringPayload.items.filter((item) => item.strategy === "qti").length;
+}
+async function compileManagedAssessmentArtifacts(input) {
+  assertSourceIdentity(input.source);
+  const playablePayload = await buildPlayableAssessment(input.source.test, input.source.questions);
+  const scoring = compileScoringArtifact(input.source.questions);
+  const diagnostic = input.diagnosticRoutingManifest ? {
+    routingRevision: await diagnosticRoutingRevision(input.diagnosticRoutingManifest),
+    routingManifest: input.diagnosticRoutingManifest
+  } : undefined;
+  return {
+    identity: {
+      kind: "assessment",
+      qtiTestIdentifier: input.source.test.identifier,
+      contentRevision: playablePayload.contentRevision
+    },
+    playablePayload,
+    scoringPayload: {
+      ...scoring,
+      ...diagnostic ? { diagnostic } : {}
+    }
+  };
+}
+async function compileReviewBankArtifacts(input) {
+  assertSourceIdentity(input.source);
+  if (input.source.test.identifier !== input.bank.bankIdentifier) {
+    throw new ValidationError(`Review bank ${input.bank.bankIdentifier} does not describe ${input.source.test.identifier}`);
+  }
+  const itemIdentifiers = sourceItemIdentifiers(input.source);
+  const indexedItemIdentifiers = input.bank.items.map((item) => item.itemIdentifier);
+  if (itemIdentifiers.length !== indexedItemIdentifiers.length || itemIdentifiers.some((identifier, index2) => identifier !== indexedItemIdentifiers[index2])) {
+    throw new ValidationError("Review artifact content does not match its revisioned index");
+  }
+  const compiledPlayable = await buildPlayableAssessment({ ...input.source.test, title: PLAYCADEMY_REVIEW_BANK_TITLE }, input.source.questions);
+  const playablePayload = {
+    ...compiledPlayable,
+    contentRevision: input.bank.sourceContentRevision
+  };
+  return {
+    identity: {
+      kind: "review-bank",
+      qtiTestIdentifier: input.bank.bankIdentifier,
+      sourceContentRevision: input.bank.sourceContentRevision,
+      bankRevision: input.bank.bankRevision
+    },
+    playablePayload,
+    scoringPayload: {
+      ...compileScoringArtifact(input.source.questions),
+      reviewBank: {
+        sourceContentRevision: input.bank.sourceContentRevision,
+        bankRevision: input.bank.bankRevision,
+        items: input.bank.items
+      }
+    }
+  };
+}
+var init_timeback_assessment_artifacts_util = __esm(() => {
+  init_assessment_runtime2();
+  init_qti();
+  init_errors2();
+  init_timeback_assessment_runtime_util();
+  init_timeback_review_mapping_util();
+});
+
+// ../api-core/src/utils/timeback-assessment-preparation.util.ts
+class AssessmentPreparationFlights {
+  limit;
+  pending = new Map;
+  constructor(limit) {
+    if (!Number.isInteger(limit) || limit <= 0) {
+      throw new Error("Assessment preparation flight limit must be a positive integer");
+    }
+    this.limit = limit;
+  }
+  claim(key, operation) {
+    const existing = this.pending.get(key);
+    if (existing) {
+      return { status: "coalesced", promise: existing };
+    }
+    if (this.pending.size >= this.limit) {
+      return { status: "at_capacity" };
+    }
+    const pending = Promise.resolve().then(operation).finally(() => {
+      if (this.pending.get(key) === pending) {
+        this.pending.delete(key);
+      }
+    });
+    this.pending.set(key, pending);
+    return { status: "started", promise: pending };
+  }
+}
+function assessmentPreparationRequestHash(input) {
+  return sha256Hex(canonicalJson2(input));
+}
+function assessmentPreparationFlightKey(input) {
+  return canonicalJson2(input);
+}
+async function assessmentPreparationReceiptMatches(plan, request) {
+  return plan.gameId === request.gameId && plan.studentId === request.studentId && plan.activityId === request.input.activityId && plan.purpose === request.input.purpose && plan.requestHash === await assessmentPreparationRequestHash(request.input);
+}
+function resolveAssessmentPreparationSelection(decision, candidateCourseCount) {
+  if (decision?.kind === "resume") {
+    return {
+      status: "blocked",
+      result: { status: "canonical_required", reason: "resumable_attempt" }
+    };
+  }
+  if (candidateCourseCount !== 1) {
+    return {
+      status: "blocked",
+      result: { status: "unprepared", reason: "prerequisite_unavailable" }
+    };
+  }
+  return decision ? { status: "ready", decision } : { status: "unavailable" };
+}
+function preparedAssessmentIntegration(plan, candidates) {
+  if (candidates.rows.length !== 1) {
+    return null;
+  }
+  const integration = candidates.rows[0];
+  const enrollment = candidates.enrollmentByCourse.get(integration.courseId);
+  if (integration.id !== plan.integrationId || integration.courseId !== plan.courseId || enrollment?.id !== plan.enrollmentId) {
+    return null;
+  }
+  return integration;
+}
+function preparedAssessmentTestIsLive(plan, tests) {
+  if (plan.purpose === "review" && tests.length !== 1) {
+    return false;
+  }
+  return tests.some((test) => test.assessmentKey === plan.selectedTest.assessmentKey && test.qtiTestIdentifier === plan.selectedTest.identifier && (plan.purpose !== "diagnostic" || test.id === plan.diagnostic.definitionId));
+}
+function preparedAssessmentArtifactIdentity(plan) {
+  return plan.purpose === "review" ? {
+    kind: "review-bank",
+    qtiTestIdentifier: plan.selectedTest.identifier,
+    sourceContentRevision: plan.selectedTest.contentRevision,
+    bankRevision: plan.review.bankRevision
+  } : {
+    kind: "assessment",
+    qtiTestIdentifier: plan.selectedTest.identifier,
+    contentRevision: plan.selectedTest.contentRevision
+  };
+}
+function preparedAssessmentScoringIsCompatible(plan, scoring) {
+  return Boolean(scoring && (plan.purpose !== "diagnostic" || scoring.diagnostic?.routingRevision === plan.diagnostic.routingRevision));
+}
+function preparedReviewBankIndex(plan) {
+  return {
+    bankIdentifier: plan.selectedTest.identifier,
+    sourceContentRevision: plan.selectedTest.contentRevision,
+    bankRevision: plan.review.bankRevision,
+    items: plan.review.selections.map((selection) => ({
+      itemIdentifier: selection.itemIdentifier,
+      standards: [selection.standard]
+    }))
+  };
+}
+function nextAssessmentAttemptNumber(attempts) {
+  return Math.max(0, ...[...attempts].map((entry) => entry.metadata.attemptNumber)) + 1;
+}
+function buildPreparedAssessmentMetadata(plan, timestamp6, testName) {
+  const base = {
+    version: PLAYCADEMY_ASSESSMENT_RESULT_METADATA_VERSION,
+    activityId: plan.activityId,
+    courseId: plan.courseId,
+    integrationId: plan.integrationId,
+    enrollmentId: plan.enrollmentId,
+    selectedTest: plan.selectedTest,
+    attemptNumber: plan.attemptNumber,
+    responseVersion: 0,
+    responses: {},
+    itemSubmissions: [],
+    startedAt: timestamp6,
+    updatedAt: timestamp6
+  };
+  if (plan.purpose === "mastery") {
+    return {
+      ...base,
+      purpose: plan.purpose,
+      mastery: {
+        requestFingerprint: masteryRequestFingerprint(plan.mastery),
+        standard: plan.mastery.standard
+      }
+    };
+  }
+  if (plan.purpose === "diagnostic") {
+    return {
+      ...base,
+      purpose: plan.purpose,
+      diagnostic: {
+        definitionId: plan.diagnostic.definitionId,
+        diagnosticKey: plan.diagnostic.diagnosticKey,
+        testName,
+        routingRevision: plan.diagnostic.routingRevision,
+        ledger: [],
+        state: plan.diagnostic.initialState
+      }
+    };
+  }
+  if (plan.purpose === "review") {
+    return {
+      ...base,
+      purpose: plan.purpose,
+      review: {
+        requestFingerprint: reviewRequestFingerprint({
+          standards: plan.review.standards,
+          candidateItemsPerStandard: plan.review.candidateItemsPerStandard
+        }, DEFAULT_REVIEW_SELECTION_POLICY),
+        bankRevision: plan.review.bankRevision,
+        standards: plan.review.standards,
+        candidateItemsPerStandard: plan.review.candidateItemsPerStandard,
+        selections: plan.review.selections,
+        fulfillment: plan.review.fulfillment
+      }
+    };
+  }
+  return { ...base, purpose: plan.purpose };
+}
+var init_timeback_assessment_preparation_util = __esm(() => {
+  init_src();
+  init_assessment_runtime2();
+});
+
 // ../api-core/src/utils/timeback-assessment-publication.util.ts
 function assessmentKeyFromManagedQtiIdentifier(identifier) {
   const assessmentKey = /^playcademy-test\.(.+)\.[a-f0-9]{64}$/.exec(identifier)?.[1];
@@ -100703,7 +102119,7 @@ async function prepareManagedAssessmentPublication(input) {
       sourceItemIdentifier: question.identifier,
       qtiItemIdentifier,
       contentHash,
-      xml: canonicalManagedAssetUrls(rewriteQtiItemIdentity(declarationNeutralQtiXml(question.rawXml), qtiItemIdentifier, title)),
+      xml: canonicalManagedAssetUrls(rewriteQtiItemIdentity(declarationNeutralQtiXml(question.rawXml).trim(), qtiItemIdentifier, title)),
       metadata: {
         ...metadata2,
         ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
@@ -100792,7 +102208,11 @@ async function prepareManagedAssessmentPublication(input) {
     qtiTestIdentifier,
     testInput,
     items,
-    diagnosticRoutingManifest: compiledRouting
+    diagnosticRoutingManifest: compiledRouting,
+    artifactSource: {
+      test: testInput,
+      questions: physicalQuestions
+    }
   };
 }
 function assertManagedAssessmentPublication(test, expected) {
@@ -100990,7 +102410,7 @@ var init_timeback_qti_hydration_util = __esm(() => {
 });
 
 // ../api-core/src/services/timeback-assessment-runtime.service.ts
-var TimebackAssessmentRuntimeService;
+var AssessmentPreparationPrerequisiteError, TimebackAssessmentRuntimeService;
 var init_timeback_assessment_runtime_service = __esm(async () => {
   init_drizzle_orm();
   init_src();
@@ -101002,17 +102422,30 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   init_types2();
   init_uuid();
   init_errors2();
+  init_assessment_artifact_runtime_util();
   init_assessment_runtime_lock_util();
+  init_timeback_assessment_artifacts_util();
+  init_timeback_assessment_preparation_util();
   init_timeback_assessment_publication_util();
   init_timeback_assessment_rules_util();
   init_timeback_assessment_runtime_util();
   init_timeback_qti_hydration_util();
   await __promiseAll([
     init_dist5(),
-    init_errors8()
+    init_errors8(),
+    init_assessment_artifact_loader_util()
   ]);
+  AssessmentPreparationPrerequisiteError = class AssessmentPreparationPrerequisiteError extends Error {
+    original;
+    constructor(original) {
+      super("Assessment preparation prerequisite provisioning failed");
+      this.name = "AssessmentPreparationPrerequisiteError";
+      this.original = original;
+    }
+  };
   TimebackAssessmentRuntimeService = class TimebackAssessmentRuntimeService {
     static ASSESSMENT_CACHE_LIMIT = 32;
+    static PREPARATION_IN_FLIGHT_LIMIT = 32;
     static ASSESSMENT_CACHE_TTL_MS = 60000;
     static EXPORT_CONCURRENCY = 4;
     static ITEM_SUBMISSION_MAX_PREPARATION_ATTEMPTS = 3;
@@ -101032,16 +102465,65 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       defaultTTL: TimebackAssessmentRuntimeService.ASSESSMENT_CACHE_TTL_MS,
       maxSize: TimebackAssessmentRuntimeService.ASSESSMENT_CACHE_LIMIT
     });
+    artifactLoader;
+    preparations = new AssessmentPreparationFlights(TimebackAssessmentRuntimeService.PREPARATION_IN_FLIGHT_LIMIT);
     constructor(deps) {
       this.deps = deps;
+      this.artifactLoader = new AssessmentArtifactRuntimeLoader(deps.assessmentArtifacts, {
+        maxSize: TimebackAssessmentRuntimeService.ASSESSMENT_CACHE_LIMIT
+      });
+    }
+    async prepare(params) {
+      await this.deps.validateDeveloperAccess(params.user, params.gameId);
+      const startedAt = Date.now();
+      const requestHash = await assessmentPreparationRequestHash(params.input);
+      const key = assessmentPreparationFlightKey({
+        gameId: params.gameId,
+        studentId: params.studentId,
+        requestHash
+      });
+      const flight = this.preparations.claim(key, () => this.prepareNewAttempt(params, requestHash).catch((error88) => {
+        if (error88 instanceof ValidationError || error88 instanceof AssessmentRuntimeError) {
+          throw error88;
+        }
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason: "prerequisite_unavailable",
+          error: error88
+        });
+        return {
+          status: "unprepared",
+          reason: "prerequisite_unavailable"
+        };
+      }));
+      if (flight.status === "coalesced") {
+        addEvent("assessment.preparation_coalesced", {
+          "app.assessment.purpose": params.input.purpose
+        });
+      }
+      if (flight.status === "at_capacity") {
+        this.recordPreparation("unprepared", params.input.purpose, Date.now(), {
+          reason: "local_capacity"
+        });
+        return { status: "unprepared", reason: "prerequisite_unavailable" };
+      }
+      return flight.promise;
     }
-    async start({
+    async start(params) {
+      await this.deps.validateDeveloperAccess(params.user, params.gameId);
+      if (params.preparationReceipt) {
+        const prepared = await this.tryPreparedStart(params, params.preparationReceipt);
+        if (prepared) {
+          return prepared;
+        }
+      }
+      return this.startCanonical(params);
+    }
+    async startCanonical({
       gameId,
       studentId,
       input,
       user
     }) {
-      await this.deps.validateDeveloperAccess(user, gameId);
       if (input.purpose === "diagnostic") {
         return this.startDiagnostic({ gameId, studentId, input, user });
       }
@@ -101150,6 +102632,285 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         return this.snapshot(result, metadata2, assessment, context2.integration);
       });
     }
+    async prepareNewAttempt(params, requestHash) {
+      const startedAt = Date.now();
+      const [candidates, results] = await Promise.all([
+        this.candidateIntegrations(params.gameId, params.studentId, params.input),
+        this.studentAssessmentResults(params.studentId)
+      ]);
+      const context2 = await this.selectIntegration(candidates, params.studentId, params.input, results);
+      const attemptScope = {
+        studentId: params.studentId,
+        activityId: params.input.activityId,
+        purpose: params.input.purpose,
+        courseId: context2.integration.courseId,
+        integrationId: context2.integration.id,
+        enrollmentId: context2.enrollment.id
+      };
+      const tests = await this.liveTests(context2.integration.id, params.input.purpose, this.deps.db, params.input.purpose === "mastery" ? params.input.standard : undefined, params.input.purpose === "diagnostic" ? params.input.diagnosticKey : undefined);
+      const listing = this.attemptListing(results, attemptScope);
+      const decision = selectRuntimeAssessment(tests, [
+        ...this.attemptsMatchingRequest(listing.attempts, this.startRequestFingerprint(params.input)).values()
+      ].map((entry) => entry.selection));
+      const selection = resolveAssessmentPreparationSelection(decision, candidates.rows.length);
+      if (selection.status === "blocked") {
+        this.recordPreparation(selection.result.status, params.input.purpose, startedAt, {
+          reason: selection.result.status === "canonical_required" ? selection.result.reason : "multiple_candidate_courses"
+        });
+        return selection.result;
+      }
+      if (selection.status === "unavailable") {
+        throw AssessmentRuntimeError.from(assessmentNoEligibleTests(params.input.purpose));
+      }
+      const preparation = {
+        context: context2,
+        tests,
+        listing,
+        decision: selection.decision
+      };
+      let prepared;
+      try {
+        prepared = await this.buildPreparationPlan(params, requestHash, preparation);
+      } catch (error88) {
+        if (error88 instanceof ValidationError || error88 instanceof AssessmentRuntimeError) {
+          throw error88;
+        }
+        const prerequisiteFailure = error88 instanceof AssessmentPreparationPrerequisiteError;
+        const reason = prerequisiteFailure ? "prerequisite_unavailable" : "artifact_unavailable";
+        this.recordPreparation("unprepared", params.input.purpose, startedAt, {
+          reason,
+          error: prerequisiteFailure ? error88.original : error88
+        });
+        return { status: "unprepared", reason };
+      }
+      const minted = await this.deps.mintAssessmentPreparationReceipt(prepared.plan);
+      this.recordPreparation("prepared", params.input.purpose, startedAt, {
+        artifactSource: prepared.artifactSource
+      });
+      return { status: "prepared", ...minted };
+    }
+    async buildPreparationPlan(params, requestHash, preparation) {
+      if (params.input.purpose === "review") {
+        return this.buildReviewPreparationPlan({ ...params, input: params.input }, requestHash, preparation);
+      }
+      const { context: context2, decision, listing } = preparation;
+      let artifact;
+      let diagnostic;
+      if (params.input.purpose === "diagnostic") {
+        const definition = await this.requireDiagnosticDefinition(decision.test.id, context2.integration.id, this.deps.db, true);
+        artifact = await this.loadOrCompileManagedArtifact(definition.qtiTestIdentifier, definition.diagnosticRoutingManifest);
+        diagnostic = {
+          definition,
+          routing: await this.initializeHostedDiagnostic(definition, artifact.assessment)
+        };
+      } else {
+        artifact = await this.loadOrCompileManagedArtifact(decision.test.qtiTestIdentifier);
+      }
+      const plan = await this.provisionPreparationPrerequisites(() => this.finishManagedPreparationPlan({
+        params,
+        requestHash,
+        context: context2,
+        listing,
+        decision,
+        assessment: artifact.assessment,
+        diagnostic
+      }));
+      return { plan, artifactSource: artifact.source };
+    }
+    async provisionPreparationPrerequisites(operation) {
+      try {
+        return await operation();
+      } catch (error88) {
+        throw new AssessmentPreparationPrerequisiteError(error88);
+      }
+    }
+    async finishManagedPreparationPlan(input) {
+      const { params, context: context2, listing, decision, assessment, diagnostic } = input;
+      const diagnosticIdentity = diagnostic && {
+        definitionId: diagnostic.definition.id,
+        diagnosticKey: diagnostic.definition.diagnosticKey,
+        routingRevision: diagnostic.routing.routingRevision
+      };
+      const classId = await this.resolveClassId(context2.integration.courseId, context2.enrollment, params.studentId);
+      const parentLineItemId = await this.ensureLineItem({
+        classId,
+        integration: context2.integration,
+        purpose: params.input.purpose,
+        assessment,
+        ...diagnosticIdentity ? { diagnostic: diagnosticIdentity } : {}
+      });
+      const attempt = await this.claimAttemptId({
+        gameId: params.gameId,
+        studentId: params.studentId,
+        courseId: context2.integration.courseId,
+        activityId: params.input.activityId,
+        purpose: params.input.purpose
+      }, nextAssessmentAttemptNumber(listing.attempts.values()));
+      const common2 = {
+        version: 1,
+        gameId: params.gameId,
+        studentId: params.studentId,
+        activityId: params.input.activityId,
+        requestHash: input.requestHash,
+        preparedAt: Date.now(),
+        integrationId: context2.integration.id,
+        enrollmentId: context2.enrollment.id,
+        courseId: context2.integration.courseId,
+        ...attempt,
+        parentLineItemId,
+        selectedTest: {
+          assessmentKey: decision.test.assessmentKey,
+          identifier: assessment.identifier,
+          contentRevision: assessment.contentRevision
+        }
+      };
+      if (params.input.purpose === "mastery") {
+        return {
+          ...common2,
+          purpose: params.input.purpose,
+          mastery: { standard: normalizeMasteryStandard(params.input.standard) }
+        };
+      }
+      if (params.input.purpose === "diagnostic") {
+        if (!diagnostic || !diagnosticIdentity) {
+          throw new Error("Diagnostic preparation is missing its routing plan");
+        }
+        return {
+          ...common2,
+          purpose: params.input.purpose,
+          diagnostic: { ...diagnosticIdentity, initialState: diagnostic.routing.state }
+        };
+      }
+      if (params.input.purpose !== "end_of_course") {
+        throw new Error(`Unsupported prepared assessment purpose ${params.input.purpose}`);
+      }
+      return { ...common2, purpose: "end_of_course" };
+    }
+    async buildReviewPreparationPlan(params, requestHash, preparation) {
+      const { context: context2, decision, listing, tests } = preparation;
+      if (tests.length !== 1) {
+        throw new ValidationError("Standards review requires exactly one live review-bank assessment.");
+      }
+      const normalized = normalizeReviewRequest(params.input);
+      const catalog = await this.loadReviewBankCatalog(decision.test.qtiTestIdentifier);
+      const selected = selectReviewItems({
+        request: params.input,
+        bank: catalog.bank,
+        exposures: this.reviewExposures(listing.reviewChildren.values(), {
+          bankRevision: catalog.bank.bankRevision
+        })
+      });
+      if (selected.selections.length === 0) {
+        if (selected.fulfillment.status !== "partial") {
+          throw new Error("A complete review selection cannot be empty");
+        }
+        throw AssessmentRuntimeError.from(assessmentReviewBankShortage(selected.fulfillment));
+      }
+      const artifact = await this.loadOrCompileReviewBankArtifact(catalog);
+      const assessment = projectReviewAssessment(artifact.assessment, catalog.bank, selected.selections);
+      const source = { assessment: artifact.assessment, bank: catalog.bank };
+      const parentLineItemId = await this.provisionPreparationPrerequisites(() => this.ensureReviewBankLineItem({
+        integration: context2.integration,
+        activityId: params.input.activityId,
+        source
+      }));
+      await this.provisionPreparationPrerequisites(() => runWithConcurrency(assessment.items, TimebackAssessmentRuntimeService.SCORING_CONCURRENCY, (item) => this.ensureReviewQuestionLineItem({
+        parentLineItemId,
+        integration: context2.integration,
+        bank: catalog.bank,
+        item
+      })));
+      const attempt = await this.provisionPreparationPrerequisites(() => this.claimAttemptId({
+        gameId: params.gameId,
+        studentId: params.studentId,
+        courseId: context2.integration.courseId,
+        activityId: params.input.activityId,
+        purpose: params.input.purpose
+      }, nextAssessmentAttemptNumber(listing.attempts.values())));
+      const plan = {
+        version: 1,
+        gameId: params.gameId,
+        studentId: params.studentId,
+        activityId: params.input.activityId,
+        purpose: params.input.purpose,
+        requestHash,
+        preparedAt: Date.now(),
+        integrationId: context2.integration.id,
+        enrollmentId: context2.enrollment.id,
+        courseId: context2.integration.courseId,
+        ...attempt,
+        parentLineItemId,
+        selectedTest: {
+          assessmentKey: decision.test.assessmentKey,
+          identifier: artifact.assessment.identifier,
+          contentRevision: artifact.assessment.contentRevision
+        },
+        review: {
+          bankRevision: catalog.bank.bankRevision,
+          standards: [...normalized.standards],
+          candidateItemsPerStandard: normalized.candidateItemsPerStandard,
+          selections: [...selected.selections],
+          fulfillment: selected.fulfillment
+        }
+      };
+      return { plan, artifactSource: artifact.source };
+    }
+    async tryPreparedStart(params, receipt) {
+      const startedAt = Date.now();
+      let plan;
+      try {
+        const verified = await this.deps.verifyAssessmentPreparationReceipt(receipt);
+        if (!verified || !await assessmentPreparationReceiptMatches(verified, params)) {
+          this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
+            reason: "receipt_mismatch"
+          });
+          return null;
+        }
+        plan = verified;
+        const assessment = await this.loadPreparedPlanAssessment(verified);
+        if (!assessment) {
+          this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
+            reason: "artifact_unavailable",
+            plan
+          });
+          return null;
+        }
+        const outcome = await this.deps.assessmentRuntimeLock(this.deps.db, [
+          assessmentRuntimeStartLockKey({
+            studentId: params.studentId,
+            activityId: params.input.activityId,
+            purpose: params.input.purpose,
+            courseId: verified.courseId
+          })
+        ], async (db2) => {
+          const candidates = await this.candidateIntegrations(verified.gameId, verified.studentId, params.input, db2);
+          const integration = preparedAssessmentIntegration(verified, candidates);
+          if (!integration || !await this.preparedPlanTestIsLive(verified, db2)) {
+            return null;
+          }
+          if (await this.attemptIdOccupied(verified.attemptId)) {
+            return null;
+          }
+          return this.createPreparedAttempt(verified, assessment, integration);
+        });
+        if (!outcome) {
+          this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
+            reason: "stale_plan",
+            plan
+          });
+          return null;
+        }
+        this.recordPreparedStart("started", params.input.purpose, startedAt, { plan });
+        return outcome;
+      } catch (error88) {
+        this.recordPreparedStart("fallback", params.input.purpose, startedAt, {
+          reason: "prepared_start_failed",
+          error: error88,
+          ...plan ? { plan } : {}
+        });
+        return null;
+      }
+    }
     async startDiagnostic({
       gameId,
       studentId,
@@ -101804,7 +103565,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       let scoring = null;
       if (loaded.state.status === "in-progress" && expected?.nodeKey === input.routingNodeKey && expected.itemIdentifier === input.itemIdentifier && attempt.metadata.responseVersion === input.expectedResponseVersion) {
         const responses = prepareDiagnosticAssessmentResponses(assessment, attempt.metadata.responses, input);
-        scoring = await this.scoreItem(assessment, responses, input.itemIdentifier);
+        scoring = await this.scoreItem(assessment, responses, input.itemIdentifier, assessmentArtifactIdentityFromAttempt(attempt.metadata));
       }
       return {
         responseVersion: attempt.metadata.responseVersion,
@@ -101815,7 +103576,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         scoring
       };
     }
-    async scoreItems(assessment, responses, itemIdentifiers) {
+    async scoreItems(assessment, responses, artifactIdentity, itemIdentifiers) {
+      await this.artifactLoader.loadMatchedScoring(assessment, artifactIdentity);
       const client2 = this.requireClient();
       const scoringItems = assessmentScoringRequests(assessment, responses).filter((item) => !itemIdentifiers || itemIdentifiers.has(item.itemIdentifier));
       const scoringTasks = scoringItems.flatMap((item, itemIndex) => item.requests.map((request) => ({
@@ -101845,8 +103607,8 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         };
       });
     }
-    async scoreItem(assessment, responses, itemIdentifier) {
-      const [scoring] = await this.scoreItems(assessment, responses, new Set([itemIdentifier]));
+    async scoreItem(assessment, responses, itemIdentifier, artifactIdentity) {
+      const [scoring] = await this.scoreItems(assessment, responses, artifactIdentity, new Set([itemIdentifier]));
       return scoring;
     }
     async prepareItemSubmission(params, input) {
@@ -101874,7 +103636,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         itemSubmissions: attempt.metadata.itemSubmissions,
         assessment
       }, input);
-      const scoring = transition.action === "commit" ? await this.scoreItem(assessment, transition.responses, input.itemIdentifier) : null;
+      const scoring = transition.action === "commit" ? await this.scoreItem(assessment, transition.responses, input.itemIdentifier, assessmentArtifactIdentityFromAttempt(attempt.metadata)) : null;
       return {
         responseVersion: attempt.metadata.responseVersion,
         submissionId: input.submissionId,
@@ -101887,7 +103649,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       const assessment = await this.loadAttemptAssessment(attempt.metadata);
       validateAssessmentResponses(assessment, attempt.metadata.responses);
       const administeredItems = attempt.metadata.purpose === "review" ? administeredItemIdentifiers(attempt.metadata.itemSubmissions) : undefined;
-      const itemResults = await this.scoreItems(assessment, attempt.metadata.responses, administeredItems);
+      const itemResults = await this.scoreItems(assessment, attempt.metadata.responses, assessmentArtifactIdentityFromAttempt(attempt.metadata), administeredItems);
       return {
         responseVersion: attempt.metadata.responseVersion,
         assessment,
@@ -102379,23 +104141,24 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         liveTestIntegrationIds: integrationIdsWithLiveTests
       };
     }
-    async selectIntegration(candidates, studentId, input) {
+    async selectIntegration(candidates, studentId, input, results) {
       const {
         rows: candidateRows,
         enrollmentByCourse,
         liveTestIntegrationIds: integrationIdsWithLiveTests
       } = candidates;
       const needsOpenAnnotation = candidateRows.length > 1 || candidateRows.some((row) => !integrationIdsWithLiveTests.has(row.id));
-      const openAttemptCourseIds = needsOpenAnnotation ? await this.openAttemptCourseIds({
+      const openAttemptScope = {
         studentId,
         activityId: input.activityId,
         purpose: input.purpose,
-        enrollmentIdByCourse: new Map(candidateRows.map((row) => [
-          row.courseId,
-          enrollmentByCourse.get(row.courseId).id
-        ])),
+        enrollmentIdByCourse: new Map(candidateRows.map((row) => [row.courseId, enrollmentByCourse.get(row.courseId).id])),
         requestFingerprint: this.startRequestFingerprint(input)
-      }) : new Set;
+      };
+      let openAttemptCourseIds = new Set;
+      if (needsOpenAnnotation) {
+        openAttemptCourseIds = results ? this.openAttemptCourseIdsFromResults(results, openAttemptScope) : await this.openAttemptCourseIds(openAttemptScope);
+      }
       const annotated = candidateRows.map((row) => ({
         ...row,
         hasLiveTests: integrationIdsWithLiveTests.has(row.id),
@@ -102429,14 +104192,24 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       })).filter((test) => !matchesMasteryStandard || matchesMasteryStandard(test.standard));
     }
     async openAttemptCourseIds(scope) {
-      const results = this.requireClient().api.oneroster.assessmentResults.stream({
+      return this.openAttemptCourseIdsFromResults(await this.studentAssessmentResults(scope.studentId), scope);
+    }
+    async studentAssessmentResults(studentId) {
+      const stream = this.requireClient().api.oneroster.assessmentResults.stream({
         where: {
-          "student.sourcedId": scope.studentId,
+          "student.sourcedId": studentId,
           status: ONEROSTER_STATUS2.active
         }
       });
+      const results = [];
+      for await (const result of stream) {
+        results.push(result);
+      }
+      return results;
+    }
+    openAttemptCourseIdsFromResults(results, scope) {
       const courseIds = new Set;
-      for await (const result of results) {
+      for (const result of results) {
         const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
         if (metadata2 && metadata2.activityId === scope.activityId && metadata2.purpose === scope.purpose && this.attemptMatchesRequestFingerprint(metadata2, scope.requestFingerprint) && result.student.sourcedId === scope.studentId && metadata2.enrollmentId === scope.enrollmentIdByCourse.get(metadata2.courseId) && (this.isOpen(result) || this.isAwaitingAward(result))) {
           courseIds.add(metadata2.courseId);
@@ -102445,15 +104218,12 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       return courseIds;
     }
     async listAttempts(scope) {
-      const results = this.requireClient().api.oneroster.assessmentResults.stream({
-        where: {
-          "student.sourcedId": scope.studentId,
-          status: ONEROSTER_STATUS2.active
-        }
-      });
+      return this.attemptListing(await this.studentAssessmentResults(scope.studentId), scope);
+    }
+    attemptListing(results, scope) {
       const attempts = new Map;
       const reviewChildren = new Map;
-      for await (const result of results) {
+      for (const result of results) {
         const metadata2 = playcademyAssessmentResultMetadata(result.metadata);
         const childMetadata = scope.purpose === "review" ? playcademyAssessmentItemResultMetadata(result.metadata) : null;
         if (childMetadata && childMetadata.activityId === scope.activityId && childMetadata.integrationId === scope.integrationId && childMetadata.enrollmentId === scope.enrollmentId && result.student.sourcedId === scope.studentId) {
@@ -102665,6 +104435,57 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
         ...counts.selectedCount === undefined ? {} : { "app.assessment.selected_count": counts.selectedCount }
       });
     }
+    async loadOrCompileManagedArtifact(identifier, diagnosticManifest) {
+      const playable = await this.artifactLoader.loadManagedPlayable(identifier);
+      if (playable) {
+        const identity = {
+          kind: "assessment",
+          qtiTestIdentifier: identifier,
+          contentRevision: playable.contentRevision
+        };
+        const scoring = await this.artifactLoader.loadMatchedScoring(playable, identity);
+        const expectedRoutingRevision = diagnosticManifest ? await diagnosticRoutingRevision(diagnosticManifest) : undefined;
+        if (scoring && (expectedRoutingRevision === undefined || scoring.diagnostic?.routingRevision === expectedRoutingRevision)) {
+          return { assessment: playable, source: "existing" };
+        }
+      }
+      const source = await loadHydratedQtiTest(this.requireClient(), identifier);
+      const compiled = await compileManagedAssessmentArtifacts({
+        source,
+        diagnosticRoutingManifest: diagnosticManifest
+      });
+      return this.storeCompiledArtifact(compiled, `assessment artifacts for ${identifier}`);
+    }
+    async loadOrCompileReviewBankArtifact(catalog) {
+      const identity = {
+        kind: "review-bank",
+        qtiTestIdentifier: catalog.bank.bankIdentifier,
+        sourceContentRevision: catalog.bank.sourceContentRevision,
+        bankRevision: catalog.bank.bankRevision
+      };
+      const playable = await this.artifactLoader.loadPlayable(identity);
+      const scoring = playable ? await this.artifactLoader.loadMatchedScoring(playable, identity) : null;
+      if (playable && scoring) {
+        return { assessment: playable, source: "existing" };
+      }
+      const itemIdentifiers = catalog.bank.items.map((item) => item.itemIdentifier);
+      const questions = await hydrateQtiTestQuestionSelection(this.requireClient(), catalog.references, itemIdentifiers);
+      const compiled = await compileReviewBankArtifacts({
+        source: { test: catalog.test, questions },
+        bank: catalog.bank
+      });
+      return this.storeCompiledArtifact(compiled, `review-bank artifacts for ${catalog.bank.bankIdentifier}`);
+    }
+    async storeCompiledArtifact(compiled, label) {
+      const assessment = await storeAndVerifyCompiledAssessmentArtifacts({
+        compiled,
+        label,
+        store: (pair) => this.deps.assessmentArtifacts.storePair(pair),
+        loadPlayable: (identity) => this.artifactLoader.loadPlayable(identity),
+        loadMatchedScoring: (playable, identity) => this.artifactLoader.loadMatchedScoring(playable, identity)
+      });
+      return { assessment, source: "compiled" };
+    }
     async loadReviewBankCatalog(identifier, expectedSourceRevision) {
       if (expectedSourceRevision) {
         const cached3 = this.reviewBankCache.get(`${identifier}\x00${expectedSourceRevision}`);
@@ -102717,6 +104538,16 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       return assessment;
     }
     async hydrateReviewBankSelection(catalog, itemIdentifiers) {
+      const identity = {
+        kind: "review-bank",
+        qtiTestIdentifier: catalog.bank.bankIdentifier,
+        sourceContentRevision: catalog.bank.sourceContentRevision,
+        bankRevision: catalog.bank.bankRevision
+      };
+      const artifact = await this.artifactLoader.loadPlayableContainingItems(identity, itemIdentifiers);
+      if (artifact) {
+        return { assessment: artifact, bank: catalog.bank };
+      }
       const assessment = await this.cachedReviewSelection({
         identifier: catalog.test.identifier,
         contentRevision: catalog.bank.sourceContentRevision,
@@ -102730,6 +104561,14 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
     async loadPinnedReviewBankSource(metadata2) {
       const itemIdentifiers = metadata2.review.selections.map((selection) => selection.itemIdentifier);
+      const identity = assessmentArtifactIdentityFromAttempt(metadata2);
+      const artifact = await this.artifactLoader.loadPlayableContainingItems(identity, itemIdentifiers);
+      if (artifact) {
+        return {
+          assessment: artifact,
+          bank: pinnedReviewBankFromAttempt(metadata2, artifact.identifier)
+        };
+      }
       let assessment;
       try {
         assessment = await this.cachedReviewSelection({
@@ -102755,18 +104594,19 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       }
       return {
         assessment,
-        bank: {
-          bankIdentifier: assessment.identifier,
-          sourceContentRevision: metadata2.selectedTest.contentRevision,
-          bankRevision: metadata2.review.bankRevision,
-          items: metadata2.review.selections.map((selection) => ({
-            itemIdentifier: selection.itemIdentifier,
-            standards: [selection.standard]
-          }))
-        }
+        bank: pinnedReviewBankFromAttempt(metadata2, assessment.identifier)
       };
     }
     async loadAssessment(identifier, expectedRevision) {
+      const artifact = expectedRevision ? await this.artifactLoader.loadPlayable({
+        kind: "assessment",
+        qtiTestIdentifier: identifier,
+        contentRevision: expectedRevision
+      }) : await this.artifactLoader.loadManagedPlayable(identifier);
+      if (artifact) {
+        return artifact;
+      }
+      this.artifactLoader.recordFallback("playable", "assessment");
       if (expectedRevision) {
         const cached3 = this.assessmentCache.get(`${identifier}\x00${expectedRevision}`);
         if (cached3) {
@@ -103534,6 +105374,72 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     scoreFromResult(result, possible, metadata2) {
       return metadata2.score ?? assessmentScoreFromPercentage(result.score, possible);
     }
+    recordPreparation(outcome, purpose, startedAt, details = {}) {
+      addEvent("assessment.preparation", {
+        "app.assessment.purpose": purpose,
+        "app.assessment.preparation_outcome": outcome,
+        "app.assessment.duration_ms": Date.now() - startedAt,
+        ...details.reason ? { "app.assessment.reason": details.reason } : {},
+        ...details.artifactSource ? { "app.assessment.artifact_source": details.artifactSource } : {},
+        ...details.error ? {
+          "exception.type": errorType(details.error),
+          "app.error.message": errorMessage(details.error)
+        } : {}
+      });
+    }
+    recordPreparedStart(outcome, purpose, startedAt, details = {}) {
+      addEvent("assessment.prepared_start", {
+        "app.assessment.purpose": purpose,
+        "app.assessment.prepared_start_outcome": outcome,
+        "app.assessment.duration_ms": Date.now() - startedAt,
+        ...details.reason ? { "app.assessment.reason": details.reason } : {},
+        ...details.plan ? {
+          "app.assessment.preparation_age_ms": Math.max(0, Date.now() - details.plan.preparedAt)
+        } : {},
+        ...details.error ? {
+          "exception.type": errorType(details.error),
+          "app.error.message": errorMessage(details.error)
+        } : {}
+      });
+    }
+    async preparedPlanTestIsLive(plan, db2) {
+      const tests = await this.liveTests(plan.integrationId, plan.purpose, db2, plan.purpose === "mastery" ? plan.mastery.standard : undefined, plan.purpose === "diagnostic" ? plan.diagnostic.diagnosticKey : undefined);
+      return preparedAssessmentTestIsLive(plan, tests);
+    }
+    async loadPreparedPlanAssessment(plan) {
+      const identity = preparedAssessmentArtifactIdentity(plan);
+      const playable = plan.purpose === "review" ? await this.artifactLoader.loadPlayableContainingItems(identity, plan.review.selections.map((selection) => selection.itemIdentifier)) : await this.artifactLoader.loadPlayable(identity);
+      if (!playable) {
+        return null;
+      }
+      const scoring = await this.artifactLoader.loadMatchedScoring(playable, identity);
+      if (!preparedAssessmentScoringIsCompatible(plan, scoring)) {
+        return null;
+      }
+      if (plan.purpose !== "review") {
+        return playable;
+      }
+      return projectReviewAssessment(playable, preparedReviewBankIndex(plan), plan.review.selections);
+    }
+    async createPreparedAttempt(plan, assessment, integration) {
+      const timestamp6 = new Date().toISOString();
+      const metadata2 = buildPreparedAssessmentMetadata(plan, timestamp6, assessment.title);
+      const result = await this.requireClient().api.oneroster.assessmentResults.upsert(plan.attemptId, {
+        status: ONEROSTER_STATUS2.active,
+        assessmentLineItem: { sourcedId: plan.parentLineItemId },
+        student: { sourcedId: plan.studentId },
+        score: 0,
+        scoreDate: timestamp6,
+        scoreStatus: ASSESSMENT_ATTEMPT_OPEN.scoreStatus,
+        inProgress: ASSESSMENT_ATTEMPT_OPEN.inProgress,
+        metadata: buildAssessmentResultMetadata({
+          metadata: metadata2,
+          testName: assessment.title,
+          grade: integration.grade
+        })
+      });
+      return this.isPlatformRoutedDiagnosticMetadata(metadata2) ? this.diagnosticSnapshot(result, metadata2, assessment, integration, metadata2.diagnostic.state) : this.snapshot(result, metadata2, assessment, integration);
+    }
     async claimAttemptId(scope, from) {
       for (let attemptNumber = from;attemptNumber < from + 20; attemptNumber += 1) {
         const attemptId = await assessmentAttemptId({ ...scope, attemptNumber });
@@ -103689,6 +105595,35 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
   };
 });
 
+// ../api-core/src/utils/assessment-artifact-fallback.util.ts
+function assessmentArtifactFailureFallback(error88) {
+  if (error88 instanceof ValidationError || error88 instanceof ConflictError || error88 instanceof AssessmentRuntimeError) {
+    throw error88;
+  }
+  return false;
+}
+function assessmentArtifactPublicationWarning(artifactsAvailable) {
+  return artifactsAvailable ? undefined : ASSESSMENT_ARTIFACTS_UNAVAILABLE_WARNING;
+}
+function assessmentArtifactImportMessage(message, artifactsAvailable) {
+  return artifactsAvailable ? message : `${message} Optimized ${ARTIFACTS_UNAVAILABLE_DETAIL}`;
+}
+function assessmentArtifactReviewBankWarnings(warnings, artifactsAvailable) {
+  return artifactsAvailable ? warnings : [
+    ...warnings,
+    {
+      code: "ASSESSMENT_ARTIFACTS_UNAVAILABLE",
+      message: REVIEW_BANK_ARTIFACTS_UNAVAILABLE_WARNING
+    }
+  ];
+}
+var ARTIFACTS_UNAVAILABLE_DETAIL = "assessment artifacts are unavailable. Students will use the slower QTI fallback until compilation is repaired.", ASSESSMENT_ARTIFACTS_UNAVAILABLE_WARNING, REVIEW_BANK_ARTIFACTS_UNAVAILABLE_WARNING;
+var init_assessment_artifact_fallback_util = __esm(() => {
+  init_errors2();
+  ASSESSMENT_ARTIFACTS_UNAVAILABLE_WARNING = `Published successfully, but optimized ${ARTIFACTS_UNAVAILABLE_DETAIL}`;
+  REVIEW_BANK_ARTIFACTS_UNAVAILABLE_WARNING = `Review bank synchronized successfully, but optimized ${ARTIFACTS_UNAVAILABLE_DETAIL}`;
+});
+
 // ../api-core/src/utils/timeback-assessment-diagnostic.util.ts
 function diagnosticRoutingCapabilities(assessment, scoring) {
   return assessment.items.map((item) => ({
@@ -104029,7 +105964,7 @@ class TimebackAssessmentsService {
         assertManagedAssessmentIdentity(loaded.test, entry.assessmentKey);
         assertAssessmentHasQuestions(loaded.questions.questions);
         assertPlayableAssessmentImportQuestions(targetStatus, loaded.questions.questions.map(({ question }) => question));
-        return { entry, test: loaded.test };
+        return { entry, source: loaded };
       } catch (error88) {
         return { entry, error: error88 };
       }
@@ -104049,7 +105984,7 @@ class TimebackAssessmentsService {
     const pendingInserts = [];
     for (const validation of input.validated) {
       const { entry } = validation;
-      const base = this.associationImportResultBase(entry, "test" in validation ? validation.test : undefined, input.gameSlug);
+      const base = this.associationImportResultBase(entry, "source" in validation ? validation.source.test : undefined, input.gameSlug);
       if ("error" in validation) {
         input.results[entry.index] = {
           ...base,
@@ -104060,7 +105995,7 @@ class TimebackAssessmentsService {
         const existingForKey = input.existingByKey.get(entry.assessmentKey);
         const decision = planAssessmentAssociationImport(entry, existingForKey, input.existingByIdentifier.get(entry.qtiTestIdentifier));
         if (decision.kind === "insert") {
-          pendingInserts.push({ entry, test: validation.test });
+          pendingInserts.push({ entry, source: validation.source });
         } else {
           input.results[entry.index] = {
             ...base,
@@ -104092,9 +106027,13 @@ class TimebackAssessmentsService {
     }
   }
   async insertImportedAssessments(input) {
-    for (const { entry, test } of input.pending) {
-      const base = this.associationImportResultBase(entry, test, input.gameSlug);
+    for (const { entry, source } of input.pending) {
+      const base = this.associationImportResultBase(entry, source.test, input.gameSlug);
       try {
+        let artifactsAvailable = true;
+        if (input.targetStatus === "live") {
+          artifactsAvailable = await this.storeManagedArtifacts(source, managedAssessmentDiagnosticRoutingManifest(source.test, entry.assessmentKey));
+        }
         const [row] = await input.db.insert(gameTimebackAssessmentTests).values({
           integrationId: input.integrationId,
           assessmentKey: entry.assessmentKey,
@@ -104117,11 +106056,12 @@ class TimebackAssessmentsService {
             throw new Error("Assessment association insert conflicted");
           }
         } else {
+          const message = attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false);
           input.results[entry.index] = {
             ...base,
             status: "created",
             association: this.associationImportSummary(row),
-            message: attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false)
+            message: assessmentArtifactImportMessage(message, artifactsAvailable)
           };
         }
       } catch (error88) {
@@ -104187,6 +106127,7 @@ class TimebackAssessmentsService {
           assertQtiTestOwnedByGame(test, ownership.gameSlug);
           await client2.qtiApi.assessmentTests.update(qtiTestIdentifier, buildQtiTestUpdateInput(test, input.title));
         }
+        let publicationWarning;
         if (publishing) {
           if (nextPurpose === "diagnostic" && !nextDiagnostic) {
             throw new ValidationError("Platform-routed diagnostics require a diagnostic key and routing manifest before publication.");
@@ -104202,6 +106143,7 @@ class TimebackAssessmentsService {
           if (publishing) {
             const publication = await this.publishManagedAssessment(row, nextPurpose, nextDiagnostic?.routingManifest ?? null, loaded);
             updates.qtiTestIdentifier = publication.qtiTestIdentifier;
+            publicationWarning = publication.warning;
             if (nextPurpose === "diagnostic") {
               updates.diagnosticRoutingManifest = publication.diagnosticRoutingManifest;
             }
@@ -104213,7 +106155,7 @@ class TimebackAssessmentsService {
           updated = updatedRow ?? row;
         }
         setAttribute("app.assessment.operation", input.title !== undefined ? "update_test" : "update_association");
-        return this.associationSummary(updated);
+        return this.associationSummary(updated, publicationWarning);
       });
     } catch (error88) {
       if (isUniqueViolation(error88)) {
@@ -104296,7 +106238,7 @@ class TimebackAssessmentsService {
         assertReviewBankSinkOwnership(existingSink, integrationId);
       }
       let unchangedResult = null;
-      if (existingSink) {
+      if (existingSink?.title === PLAYCADEMY_REVIEW_BANK_TITLE) {
         try {
           unchangedResult = await unchangedReviewBankSynchronizationResult({
             sink: existingSink,
@@ -104330,8 +106272,17 @@ class TimebackAssessmentsService {
         const diff = reviewBankSynchronizationDiff({ existingSink, plan });
         addedItemCount = diff.addedItemCount;
         removedItemCount = diff.removedItemCount;
-        catalogUnchanged = diff.unchanged;
+        catalogUnchanged = false;
       }
+      const artifactTest = catalogUnchanged ? existingSink : buildReviewBankSinkInput({
+        identifier: plan.bankIdentifier,
+        title: PLAYCADEMY_REVIEW_BANK_TITLE,
+        metadata: reviewBankSinkMetadata(integrationId, plan),
+        itemIdentifiers: plan.itemIdentifiers,
+        itemHref: (identifier) => qtiItemHref(client2, identifier),
+        includeIdentifier: true
+      });
+      const artifactsAvailable = await this.storeReviewBankGeneration(client2, artifactTest, catalogUnchanged ? reviewBankTestItemIdentifiers(existingSink) : plan.itemIdentifiers);
       const committed = await this.withLockedIntegrationAssessmentRows(integrationId, async (tx, lockedAssociations) => {
         const lockedSources = this.reviewBankMasterySources(lockedAssociations);
         const lockedFingerprint = await reviewBankContributorFingerprint(lockedSources);
@@ -104364,7 +106315,10 @@ class TimebackAssessmentsService {
           unchanged,
           warnings: plan.warnings
         };
-        return this.reviewMappingResult(result);
+        return this.reviewMappingResult({
+          ...result,
+          warnings: assessmentArtifactReviewBankWarnings(result.warnings, artifactsAvailable)
+        });
       });
       if (committed) {
         return committed;
@@ -104666,6 +106620,36 @@ class TimebackAssessmentsService {
       };
     });
   }
+  async storeReviewBankGeneration(client2, test, itemIdentifiers) {
+    const startedAt = Date.now();
+    const bank = await reviewBankIndexFromManifest(test.metadata, {
+      bankIdentifier: test.identifier,
+      membershipItemIdentifiers: itemIdentifiers
+    });
+    if (!bank) {
+      throw new ValidationError(`Review bank ${test.identifier} has no revisioned mapping to compile`);
+    }
+    const identity = {
+      kind: "review-bank",
+      qtiTestIdentifier: bank.bankIdentifier,
+      sourceContentRevision: bank.sourceContentRevision,
+      bankRevision: bank.bankRevision
+    };
+    try {
+      if (await this.deps.assessmentArtifacts.loadPair(identity)) {
+        return true;
+      }
+    } catch (error88) {
+      return this.handleArtifactFailure(test.identifier, "review-bank", startedAt, error88);
+    }
+    return this.compileAndStoreArtifacts(test.identifier, "review-bank", async () => compileReviewBankArtifacts({
+      source: {
+        test,
+        questions: await hydrateQtiItemSelection(client2, test, itemIdentifiers)
+      },
+      bank
+    }));
+  }
   async writeReviewBankSink(input) {
     function sinkInput(title, includeIdentifier = false) {
       return buildReviewBankSinkInput({
@@ -104678,11 +106662,11 @@ class TimebackAssessmentsService {
       });
     }
     if (input.existingSink) {
-      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(input.existingSink.title));
+      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(PLAYCADEMY_REVIEW_BANK_TITLE));
       return;
     }
     try {
-      const createInput = sinkInput(REVIEW_BANK_TITLE, true);
+      const createInput = sinkInput(PLAYCADEMY_REVIEW_BANK_TITLE, true);
       await input.client.qtiApi.assessmentTests.create(createInput);
     } catch (error88) {
       if (!isApiError(error88) || error88.statusCode !== 409) {
@@ -104690,7 +106674,7 @@ class TimebackAssessmentsService {
       }
       const concurrentlyCreated = await input.client.qtiApi.assessmentTests.get(input.plan.bankIdentifier);
       assertReviewBankSinkOwnership(concurrentlyCreated, input.integrationId);
-      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(concurrentlyCreated.title));
+      await input.client.qtiApi.assessmentTests.update(input.plan.bankIdentifier, sinkInput(PLAYCADEMY_REVIEW_BANK_TITLE));
     }
   }
   async installReviewBankAssociation(input) {
@@ -104875,15 +106859,64 @@ class TimebackAssessmentsService {
     return get();
   }
   async ensureManagedQtiPublication(client2, plan) {
-    await runWithConcurrency(plan.items, QTI_HYDRATION_CONCURRENCY, async (plannedItem) => {
+    const existingItems = 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);
+      return existing;
     });
     const existingTest = await this.ensureImmutableQtiResource(async () => await client2.qtiApi.assessmentTests.get(plan.qtiTestIdentifier), () => client2.qtiApi.assessmentTests.create(plan.testInput));
     assertManagedAssessmentPublication(existingTest, plan);
+    return {
+      test: existingTest,
+      questions: {
+        ...plan.artifactSource.questions,
+        assessmentTest: existingTest.identifier,
+        title: existingTest.title,
+        totalQuestions: existingItems.length,
+        questions: plan.artifactSource.questions.questions.map((entry, index2) => ({
+          ...entry,
+          reference: {
+            ...entry.reference,
+            identifier: existingItems[index2].identifier
+          },
+          question: existingItems[index2]
+        }))
+      }
+    };
+  }
+  async compileAndStoreArtifacts(qtiTestIdentifier, identityKind, compile) {
+    const startedAt = Date.now();
+    try {
+      const compiled = await compile();
+      const stored = await this.deps.assessmentArtifacts.storePair(compiled);
+      addEvent("assessment.artifacts_compiled", {
+        "app.assessment.qti_test_identifier": compiled.identity.qtiTestIdentifier,
+        "app.assessment.artifact_identity_kind": compiled.identity.kind,
+        "app.assessment.artifact_duration_ms": Date.now() - startedAt,
+        "app.assessment.artifact_fallback_item_count": qtiFallbackItemCount(compiled),
+        "app.assessment.playable_artifact_status": stored.playable.status,
+        "app.assessment.scoring_artifact_status": stored.scoring.status
+      });
+    } catch (error88) {
+      return this.handleArtifactFailure(qtiTestIdentifier, identityKind, startedAt, error88);
+    }
+    return true;
+  }
+  handleArtifactFailure(qtiTestIdentifier, identityKind, startedAt, error88) {
+    addEvent("assessment.artifact_compilation_failed", {
+      "app.assessment.qti_test_identifier": qtiTestIdentifier,
+      "app.assessment.artifact_identity_kind": identityKind,
+      "app.assessment.artifact_duration_ms": Date.now() - startedAt,
+      "exception.type": errorType(error88),
+      "app.error.message": errorMessage(error88)
+    });
+    return assessmentArtifactFailureFallback(error88);
+  }
+  async storeManagedArtifacts(source, diagnosticRoutingManifest) {
+    return this.compileAndStoreArtifacts(source.test.identifier, "assessment", () => compileManagedAssessmentArtifacts({ source, diagnosticRoutingManifest }));
   }
   async publishManagedAssessment(row, purpose, diagnosticRoutingManifest, loaded) {
     if (!row.assessmentKey) {
@@ -104898,8 +106931,10 @@ class TimebackAssessmentsService {
       diagnosticRoutingManifest,
       itemHref: (identifier) => qtiItemHref(client2, identifier)
     });
-    await this.ensureManagedQtiPublication(client2, plan);
-    return plan;
+    const artifactSource = await this.ensureManagedQtiPublication(client2, plan);
+    const artifactsAvailable = await this.storeManagedArtifacts(artifactSource, managedAssessmentDiagnosticRoutingManifest(artifactSource.test, plan.assessmentKey));
+    const warning = assessmentArtifactPublicationWarning(artifactsAvailable);
+    return { ...plan, ...warning ? { warning } : {} };
   }
   async cleanupQtiAssessmentCopy(client2, testIdentifier, itemIdentifiers) {
     let testDeleted = !testIdentifier;
@@ -104932,7 +106967,7 @@ class TimebackAssessmentsService {
       }
     }
   }
-  associationSummary(row) {
+  associationSummary(row, warning) {
     return {
       id: row.id,
       integrationId: row.integrationId,
@@ -104943,7 +106978,8 @@ class TimebackAssessmentsService {
       standard: assessmentStandardForRow(row),
       diagnostic: diagnosticDefinitionForRow(row),
       createdAt: row.createdAt,
-      updatedAt: row.updatedAt
+      updatedAt: row.updatedAt,
+      ...warning ? { warning } : {}
     };
   }
   associationImportSummary(row) {
@@ -105011,7 +107047,7 @@ class TimebackAssessmentsService {
     };
   }
 }
-var REVIEW_BANK_TITLE = "Review Bank", REVIEW_BANK_SYNC_ATTEMPTS = 2;
+var REVIEW_BANK_SYNC_ATTEMPTS = 2;
 var init_timeback_assessments_service = __esm(async () => {
   init_drizzle_orm();
   init_helpers_index();
@@ -105020,6 +107056,8 @@ var init_timeback_assessments_service = __esm(async () => {
   init_assessment_runtime2();
   init_timeback3();
   init_errors2();
+  init_assessment_artifact_fallback_util();
+  init_timeback_assessment_artifacts_util();
   init_timeback_assessment_diagnostic_util();
   init_timeback_assessment_import_util();
   init_timeback_assessment_publication_util();
@@ -107043,6 +109081,8 @@ function createPlatformServices(deps) {
     timebackClient,
     alerts,
     mintPlatformServiceToken,
+    mintAssessmentPreparationReceipt,
+    verifyAssessmentPreparationReceipt,
     validateDeveloperAccessBySlug,
     validateDeveloperAccess,
     validateGameManagementAccess
@@ -107058,6 +109098,10 @@ function createPlatformServices(deps) {
     environment: getPlatformEnvironment(config5),
     storage
   });
+  const assessmentArtifacts = new AssessmentArtifactsService({
+    bucketName: config5.assessmentArtifactBucket,
+    storage
+  });
   const upload = new UploadService({
     uploadBucket: config5.uploadBucket,
     generatePresignedPutUrl: storage.generatePresignedPutUrl.bind(storage),
@@ -107103,16 +109147,21 @@ function createPlatformServices(deps) {
   const timebackAssessments = new TimebackAssessmentsService({
     db: db2,
     timeback: timebackClient,
+    assessmentArtifacts,
     validateGameManagementAccess
   });
   const timebackAssessmentRuntime = new TimebackAssessmentRuntimeService({
     db: db2,
     timeback: timebackClient,
+    assessmentArtifacts,
     validateDeveloperAccess,
-    assessmentRuntimeLock
+    assessmentRuntimeLock,
+    mintAssessmentPreparationReceipt,
+    verifyAssessmentPreparationReceipt
   });
   return {
     assessmentAssets,
+    assessmentArtifacts,
     bucket,
     upload,
     kv,
@@ -107129,6 +109178,7 @@ function createPlatformServices(deps) {
 }
 var init_platform2 = __esm(async () => {
   init_config2();
+  init_assessment_artifacts_service();
   init_assessment_assets_service();
   init_bucket_service();
   init_database_service();
@@ -107855,6 +109905,8 @@ function createServices(ctx) {
     timebackClient: timeback2,
     alerts: infra2.alerts,
     mintPlatformServiceToken: auth2.mintPlatformServiceToken.bind(auth2),
+    mintAssessmentPreparationReceipt: auth2.mintAssessmentPreparationReceipt.bind(auth2),
+    verifyAssessmentPreparationReceipt: auth2.verifyAssessmentPreparationReceipt.bind(auth2),
     ...gaming.validators
   });
   const standalone = createStandaloneServices({ db: db2, auth: auth2, timeback: timeback2 });
@@ -107994,6 +110046,15 @@ function defineControllerNames(namespace, handlers) {
   return handlers;
 }
 
+// ../api-core/src/utils/assessment-artifact-backfill.util.ts
+var init_assessment_artifact_backfill_util = __esm(() => {
+  init_tables_index();
+  init_timeback_assessment_artifacts_util();
+  init_timeback_assessment_publication_util();
+  init_timeback_qti_hydration_util();
+  init_timeback_review_mapping_util();
+});
+
 // ../api-core/src/utils/lti.util.ts
 function generateUsername(email5) {
   const baseUsername = (email5.split("@")[0] || "user").toLowerCase();
@@ -108199,6 +110260,9 @@ var init_validation_util = __esm(() => {
 var init_utils7 = __esm(() => {
   init_auth_util();
   init_assessment_runtime_lock_util();
+  init_assessment_artifact_envelope_util();
+  init_assessment_artifact_backfill_util();
+  init_timeback_assessment_artifacts_util();
   init_dashboard_util();
   init_deployment_util();
   init_leaderboard_util();
@@ -108356,6 +110420,32 @@ function createSandboxAuthProvider() {
       }));
       return `${header}.${payload}.sandbox`;
     },
+    async mintAssessmentPreparationReceipt(plan) {
+      const now2 = Date.now();
+      for (const [receipt2, prepared] of sandboxAssessmentPreparationReceipts) {
+        if (prepared.expiresAt <= now2) {
+          sandboxAssessmentPreparationReceipts.delete(receipt2);
+        }
+      }
+      const receipt = `sandbox_assessment_preparation_${crypto.randomUUID()}`;
+      const expiresAt = now2 + ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS;
+      sandboxAssessmentPreparationReceipts.set(receipt, {
+        expiresAt,
+        plan: structuredClone(plan)
+      });
+      return { receipt, expiresAt: new Date(expiresAt).toISOString() };
+    },
+    async verifyAssessmentPreparationReceipt(receipt) {
+      const prepared = sandboxAssessmentPreparationReceipts.get(receipt);
+      if (!prepared) {
+        return null;
+      }
+      if (prepared.expiresAt <= Date.now()) {
+        sandboxAssessmentPreparationReceipts.delete(receipt);
+        return null;
+      }
+      return structuredClone(prepared.plan);
+    },
     async mintLogStreamToken(userId, workerId) {
       const jti = crypto.randomUUID();
       const payload = {
@@ -108397,11 +110487,13 @@ function createSandboxAuthProvider() {
     }
   };
 }
-var sandboxApiKeys;
+var sandboxApiKeys, sandboxAssessmentPreparationReceipts, ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS;
 var init_auth_provider = __esm(() => {
   init_src6();
   init_constants();
   sandboxApiKeys = new Map;
+  sandboxAssessmentPreparationReceipts = new Map;
+  ASSESSMENT_PREPARATION_RECEIPT_LIFETIME_MS = 5 * 60 * 1000;
 });
 
 // src/infrastructure/api/providers/cache.provider.ts
@@ -108576,6 +110668,7 @@ function buildConfig(options) {
     baseUrl,
     gameDomain: "localhost",
     uploadBucket: "sandbox-uploads",
+    assessmentArtifactBucket: "sandbox-assessment-artifacts",
     ltiTestMode: true,
     secretsManifestPepper: "sandbox-secrets-manifest-pepper",
     ...options.config
@@ -165033,7 +167126,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, saveRuntimeAssessment, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -165277,13 +167370,24 @@ var init_timeback_controller = __esm(() => {
       user: ctx.user
     });
   });
+  prepareRuntimeAssessment = requireDeveloper(async (ctx) => {
+    const body2 = await parseRequestBody(ctx.request, PrepareRuntimeAssessmentRequestSchema);
+    const { gameId, studentId, ...input } = body2;
+    return ctx.services.timebackAssessmentRuntime.prepare({
+      gameId,
+      studentId,
+      input,
+      user: ctx.user
+    });
+  });
   startRuntimeAssessment = requireDeveloper(async (ctx) => {
     const body2 = await parseRequestBody(ctx.request, StartRuntimeAssessmentRequestSchema);
-    const { gameId, studentId, ...input } = body2;
+    const { gameId, studentId, preparationReceipt, ...input } = body2;
     return ctx.services.timebackAssessmentRuntime.start({
       gameId,
       studentId,
       input,
+      preparationReceipt,
       user: ctx.user
     });
   });
@@ -165846,6 +167950,7 @@ var init_timeback_controller = __esm(() => {
     heartbeat,
     advanceCourse,
     unenrollCourse,
+    prepareRuntimeAssessment,
     startRuntimeAssessment,
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
@@ -166838,6 +168943,7 @@ var init_timeback8 = __esm(async () => {
   timebackRouter.post("/heartbeat", handle2(timeback2.heartbeat));
   timebackRouter.post("/advance-course", handle2(timeback2.advanceCourse));
   timebackRouter.post("/unenroll-course", handle2(timeback2.unenrollCourse));
+  timebackRouter.post("/assessments/prepare", handle2(timeback2.prepareRuntimeAssessment));
   timebackRouter.post("/assessments/start", handle2(timeback2.startRuntimeAssessment));
   timebackRouter.get("/assessments/latest", handle2(timeback2.getLatestRuntimeAssessment));
   timebackRouter.get("/assessments/:attemptId", handle2(timeback2.getRuntimeAssessment));