@playcademy/vite-plugin 1.3.1-beta.3 → 1.3.2-beta.1

package/dist/index.js

@@ -24317,7 +24317,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.3.1-beta.3",
+  version: "1.3.2-beta.1",
   type: "module",
   exports: {
     ".": {
@@ -25934,7 +25934,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     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: {
@@ -36526,6 +36526,9 @@ var RESPONSE_CARDINALITIES;
 var RESPONSE_BASE_TYPES;
 var POINT_INTERACTION_TYPES;
 var INDEPENDENT_PROCESSING_TAGS;
+var SUPPORTED_BASE_TYPES;
+var SUPPORTED_CARDINALITIES;
+var MATCH_CORRECT_TEMPLATES;
 var UUID_PATTERN;
 var COMMON_CORE_MATH_FRAMEWORK_ALIASES;
 var COMMON_CORE_ELA_FRAMEWORK_ALIASES;
@@ -36569,10 +36572,13 @@ var LatestAssessmentFilterBaseSchema;
 var LatestAssessmentFiltersSchema;
 var LatestRuntimeAssessmentQuerySchema;
 var StartAssessmentBodySchema;
+var AssessmentPreparationReceiptSchema;
+var StartAssessmentRequestBodySchema;
 var SaveAssessmentBodySchema;
 var SubmitAssessmentItemBodySchema;
 var SubmitAssessmentBodySchema;
 var FinalizeAssessmentBodySchema;
+var PrepareRuntimeAssessmentRequestSchema;
 var StartRuntimeAssessmentRequestSchema;
 var SaveRuntimeAssessmentRequestSchema;
 var SubmitAssessmentItemRuntimeRequestSchema;
@@ -36731,6 +36737,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",
@@ -36907,6 +36930,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()))
@@ -36934,7 +36959,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({
@@ -37458,6 +37484,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()
@@ -63125,6 +63152,318 @@ var init_infra2 = __esm(() => {
   init_alerts_service();
   init_kv_backup_service();
 });
+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, path3, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return null;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? null : `${path3} must contain a finite number`;
+  }
+  if (typeof value !== "object") {
+    return `${path3} is not JSON-serializable`;
+  }
+  if (ancestors.has(value)) {
+    return `${path3} contains a circular reference`;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    return `${path3} 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 `${path3} must contain a dense JSON array`;
+  }
+  if (!Array.isArray(value) && Reflect.ownKeys(value).length !== Object.keys(value).length) {
+    return `${path3} contains non-JSON object properties`;
+  }
+  ancestors.add(value);
+  const entries = Array.isArray(value) ? value.map((entry2, index2) => [String(index2), entry2]) : Object.entries(value);
+  for (const [key, entry2] of entries) {
+    const message = jsonValidationMessage(entry2, `${path3}.${key}`, ancestors);
+    if (message) {
+      ancestors.delete(value);
+      return message;
+    }
+  }
+  ancestors.delete(value);
+  return null;
+}
+function assertJsonValue(value, path3) {
+  const message = jsonValidationMessage(value, path3, 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;
+var ASSESSMENT_GRADER_PROTOCOL_VERSION = 1;
+var ARTIFACT_KEY_PREFIX = "assessment-artifacts";
+var SHA256_HEX;
+var textEncoder;
+var init_assessment_artifact_envelope_util = __esm(() => {
+  init_errors2();
+  SHA256_HEX = /^[a-f0-9]{64}$/;
+  textEncoder = new TextEncoder;
+});
+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();
+});
+
+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();
+});
 var require_is = __commonJS2((exports, module2) => {
   var defined = function(val) {
     return typeof val !== "undefined" && val !== null;
@@ -121439,6 +121778,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);
 }
@@ -121638,6 +122336,11 @@ var BLANK_SENTINEL22 = "
 var PLAYABLE_POINT_VALUE;
 var POINT_INTERACTION_TYPES2;
 var INDEPENDENT_PROCESSING_TAGS2;
+var SUPPORTED_BASE_TYPES2;
+var SUPPORTED_CARDINALITIES2;
+var MATCH_CORRECT_TEMPLATES2;
+var DIRECTED_PAIR_VALUE;
+var QtiScoringArtifactValidationError;
 var COMMON_CORE_MATH_FRAMEWORK_ALIASES2;
 var COMMON_CORE_ELA_FRAMEWORK_ALIASES2;
 var COMMON_CORE_FRAMEWORK_ALIASES2;
@@ -121890,6 +122593,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 QtiScoringArtifactValidationError2 extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "QtiScoringArtifactValidationError";
+    }
+  };
   COMMON_CORE_MATH_FRAMEWORK_ALIASES2 = new Set([
     "ccssm",
     "ccssmath",
@@ -121913,11 +122640,11 @@ var init_qti = __esm(() => {
   ]);
   COMMON_CORE_FRAMEWORK_ALIASES2 = new Set(["ccss", "commoncore", "commoncorestatestandards"]);
 });
-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 : "";
@@ -121929,7 +122656,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 {
@@ -122005,7 +122732,7 @@ function mapGradeLevelTestSummary(result, options) {
   };
 }
 function readLearningObjectiveSets(record3) {
-  if (!isRecord6(record3)) {
+  if (!isRecord7(record3)) {
     return [];
   }
   const metadata2 = metadataOf(record3);
@@ -122035,7 +122762,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) {
@@ -122051,11 +122778,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 });
@@ -122067,7 +122794,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) {
@@ -122204,8 +122931,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);
@@ -124245,6 +124972,466 @@ var init_timeback_admin_service = __esm(async () => {
     init_timeback_mastery_completion_util()
   ]);
 });
+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, entry2]) => PRIVATE_PLAYABLE_KEYS.has(normalizedKey(key)) || containsPrivatePlayableKey(entry2));
+}
+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;
+var trimmedNonEmptyString;
+var finiteNumber2;
+var nonnegativeInteger;
+var playableContentNodesSchema;
+var playableChoiceSchema;
+var playableMatchChoiceSchema;
+var playableGraphicSchema;
+var playableHotspotSchema;
+var playableGapTextSchema;
+var playableGapImageSchema;
+var playableInteractionBase;
+var playableInteractionSchema;
+var playableItemSchema;
+var scoringRuleSchema;
+var scoringItemSchema;
+var uniqueScoringItemsSchema;
+var 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())
+  });
+});
+
+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();
+});
 function createInMemoryDatabaseLock() {
   const tails = new Map;
   return async (db2, key, operation) => {
@@ -124364,6 +125551,808 @@ var init_assessment_runtime_lock_util = __esm(() => {
     }
   };
 });
+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((entry2) => entry2.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: errorMessage2(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((entry2) => entry2.value > 0 && isPlayableAssessmentShape(entry2.shape)) : undefined;
+      if (areas?.length) {
+        (responseAreas[item.identifier] ??= {})[responseIdentifier] = areas.map((entry2) => ({
+          shape: entry2.shape,
+          coords: [...entry2.coords],
+          value: entry2.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);
+});
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
@@ -125306,808 +127295,6 @@ var init_timeback_qti_authoring_util = __esm(() => {
     buildMatchQuestionXml
   ];
 });
-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((entry2) => entry2.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: errorMessage2(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((entry2) => entry2.value > 0 && isPlayableAssessmentShape(entry2.shape)) : undefined;
-      if (areas?.length) {
-        (responseAreas[item.identifier] ??= {})[responseIdentifier] = areas.map((entry2) => ({
-          shape: entry2.shape,
-          coords: [...entry2.coords],
-          value: entry2.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);
-});
 function reviewBankTestItemIdentifiers(test) {
   return qtiTestParts(test).flatMap((part) => part["qti-assessment-section"].flatMap((section) => (section["qti-assessment-item-ref"] ?? []).map((reference) => reference.identifier)));
 }
@@ -126360,6 +127547,7 @@ async function prepareReviewMappingUpdate(test, questions) {
     }
   };
 }
+var PLAYCADEMY_REVIEW_BANK_TITLE = "Review Bank";
 var PLAYCADEMY_REVIEW_BANK_SINK_METADATA_KEY = "playcademyReviewBankSink";
 var PLAYCADEMY_REVIEW_BANK_SINK_VERSION = 1;
 var StoredSinkWarningSchema;
@@ -126405,6 +127593,256 @@ var init_timeback_review_mapping_util = __esm(() => {
     return { ...marker, warnings };
   });
 });
+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();
+});
+
+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((entry2) => entry2.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();
+});
 function assessmentKeyFromManagedQtiIdentifier(identifier) {
   const assessmentKey = /^playcademy-test\.(.+)\.[a-f0-9]{64}$/.exec(identifier)?.[1];
   return assessmentKey && AssessmentKeySchema.safeParse(assessmentKey).success ? assessmentKey : null;
@@ -126525,7 +127963,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,
@@ -126614,7 +128052,11 @@ async function prepareManagedAssessmentPublication(input) {
     qtiTestIdentifier,
     testInput,
     items,
-    diagnosticRoutingManifest: compiledRouting
+    diagnosticRoutingManifest: compiledRouting,
+    artifactSource: {
+      test: testInput,
+      questions: physicalQuestions
+    }
   };
 }
 function assertManagedAssessmentPublication(test, expected) {
@@ -126810,6 +128252,7 @@ var QTI_HYDRATION_CONCURRENCY = 8;
 var init_timeback_qti_hydration_util = __esm(() => {
   init_timeback_qti_authoring_util();
 });
+var AssessmentPreparationPrerequisiteError;
 var TimebackAssessmentRuntimeService;
 var init_timeback_assessment_runtime_service = __esm(async () => {
   init_drizzle_orm();
@@ -126822,17 +128265,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 AssessmentPreparationPrerequisiteError2 extends Error {
+    original;
+    constructor(original) {
+      super("Assessment preparation prerequisite provisioning failed");
+      this.name = "AssessmentPreparationPrerequisiteError";
+      this.original = original;
+    }
+  };
   TimebackAssessmentRuntimeService = class TimebackAssessmentRuntimeService2 {
     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;
@@ -126852,16 +128308,65 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
       defaultTTL: TimebackAssessmentRuntimeService2.ASSESSMENT_CACHE_TTL_MS,
       maxSize: TimebackAssessmentRuntimeService2.ASSESSMENT_CACHE_LIMIT
     });
+    artifactLoader;
+    preparations = new AssessmentPreparationFlights(TimebackAssessmentRuntimeService2.PREPARATION_IN_FLIGHT_LIMIT);
     constructor(deps) {
       this.deps = deps;
+      this.artifactLoader = new AssessmentArtifactRuntimeLoader(deps.assessmentArtifacts, {
+        maxSize: TimebackAssessmentRuntimeService2.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 });
       }
@@ -126970,6 +128475,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((entry2) => entry2.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, TimebackAssessmentRuntimeService2.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,
@@ -127624,7 +129408,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,
@@ -127635,7 +129419,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) => ({
@@ -127665,8 +129450,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) {
@@ -127694,7 +129479,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,
@@ -127707,7 +129492,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,
@@ -128199,23 +129984,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),
@@ -128249,14 +130035,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);
@@ -128265,15 +130061,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) {
@@ -128485,6 +130278,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}`);
@@ -128537,6 +130381,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,
@@ -128550,6 +130404,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({
@@ -128575,18 +130437,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) {
@@ -129354,6 +131217,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": errorMessage2(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": errorMessage2(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 });
@@ -129508,6 +131437,35 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }
   };
 });
+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.";
+var ASSESSMENT_ARTIFACTS_UNAVAILABLE_WARNING;
+var 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}`;
+});
 function diagnosticRoutingCapabilities(assessment, scoring) {
   return assessment.items.map((item) => ({
     itemIdentifier: item.identifier,
@@ -129842,7 +131800,7 @@ class TimebackAssessmentsService {
         assertManagedAssessmentIdentity(loaded.test, entry2.assessmentKey);
         assertAssessmentHasQuestions(loaded.questions.questions);
         assertPlayableAssessmentImportQuestions(targetStatus, loaded.questions.questions.map(({ question }) => question));
-        return { entry: entry2, test: loaded.test };
+        return { entry: entry2, source: loaded };
       } catch (error88) {
         return { entry: entry2, error: error88 };
       }
@@ -129862,7 +131820,7 @@ class TimebackAssessmentsService {
     const pendingInserts = [];
     for (const validation of input.validated) {
       const { entry: entry2 } = validation;
-      const base = this.associationImportResultBase(entry2, "test" in validation ? validation.test : undefined, input.gameSlug);
+      const base = this.associationImportResultBase(entry2, "source" in validation ? validation.source.test : undefined, input.gameSlug);
       if ("error" in validation) {
         input.results[entry2.index] = {
           ...base,
@@ -129873,7 +131831,7 @@ class TimebackAssessmentsService {
         const existingForKey = input.existingByKey.get(entry2.assessmentKey);
         const decision = planAssessmentAssociationImport(entry2, existingForKey, input.existingByIdentifier.get(entry2.qtiTestIdentifier));
         if (decision.kind === "insert") {
-          pendingInserts.push({ entry: entry2, test: validation.test });
+          pendingInserts.push({ entry: entry2, source: validation.source });
         } else {
           input.results[entry2.index] = {
             ...base,
@@ -129905,9 +131863,13 @@ class TimebackAssessmentsService {
     }
   }
   async insertImportedAssessments(input) {
-    for (const { entry: entry2, test } of input.pending) {
-      const base = this.associationImportResultBase(entry2, test, input.gameSlug);
+    for (const { entry: entry2, source } of input.pending) {
+      const base = this.associationImportResultBase(entry2, source.test, input.gameSlug);
       try {
+        let artifactsAvailable = true;
+        if (input.targetStatus === "live") {
+          artifactsAvailable = await this.storeManagedArtifacts(source, managedAssessmentDiagnosticRoutingManifest(source.test, entry2.assessmentKey));
+        }
         const [row] = await input.db.insert(gameTimebackAssessmentTests).values({
           integrationId: input.integrationId,
           assessmentKey: entry2.assessmentKey,
@@ -129930,11 +131892,12 @@ class TimebackAssessmentsService {
             throw new Error("Assessment association insert conflicted");
           }
         } else {
+          const message = attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false);
           input.results[entry2.index] = {
             ...base,
             status: "created",
             association: this.associationImportSummary(row),
-            message: attachedAssessmentImportMessage(input.targetStatus, base.editable ?? false)
+            message: assessmentArtifactImportMessage(message, artifactsAvailable)
           };
         }
       } catch (error88) {
@@ -130000,6 +131963,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.");
@@ -130015,6 +131979,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;
             }
@@ -130026,7 +131991,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)) {
@@ -130109,7 +132074,7 @@ class TimebackAssessmentsService {
         assertReviewBankSinkOwnership(existingSink, integrationId);
       }
       let unchangedResult = null;
-      if (existingSink) {
+      if (existingSink?.title === PLAYCADEMY_REVIEW_BANK_TITLE) {
         try {
           unchangedResult = await unchangedReviewBankSynchronizationResult({
             sink: existingSink,
@@ -130143,8 +132108,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);
@@ -130177,7 +132151,10 @@ class TimebackAssessmentsService {
           unchanged,
           warnings: plan.warnings
         };
-        return this.reviewMappingResult(result);
+        return this.reviewMappingResult({
+          ...result,
+          warnings: assessmentArtifactReviewBankWarnings(result.warnings, artifactsAvailable)
+        });
       });
       if (committed) {
         return committed;
@@ -130479,6 +132456,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({
@@ -130491,11 +132498,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) {
@@ -130503,7 +132510,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) {
@@ -130688,15 +132695,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((entry2, index2) => ({
+          ...entry2,
+          reference: {
+            ...entry2.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": errorMessage2(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) {
@@ -130711,8 +132767,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;
@@ -130745,7 +132803,7 @@ class TimebackAssessmentsService {
       }
     }
   }
-  associationSummary(row) {
+  associationSummary(row, warning) {
     return {
       id: row.id,
       integrationId: row.integrationId,
@@ -130756,7 +132814,8 @@ class TimebackAssessmentsService {
       standard: assessmentStandardForRow(row),
       diagnostic: diagnosticDefinitionForRow(row),
       createdAt: row.createdAt,
-      updatedAt: row.updatedAt
+      updatedAt: row.updatedAt,
+      ...warning ? { warning } : {}
     };
   }
   associationImportSummary(row) {
@@ -130824,7 +132883,6 @@ class TimebackAssessmentsService {
     };
   }
 }
-var REVIEW_BANK_TITLE = "Review Bank";
 var REVIEW_BANK_SYNC_ATTEMPTS = 2;
 var init_timeback_assessments_service = __esm(async () => {
   init_drizzle_orm();
@@ -130834,6 +132892,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();
@@ -132836,6 +134896,8 @@ function createPlatformServices(deps) {
     timebackClient,
     alerts,
     mintPlatformServiceToken,
+    mintAssessmentPreparationReceipt,
+    verifyAssessmentPreparationReceipt,
     validateDeveloperAccessBySlug,
     validateDeveloperAccess,
     validateGameManagementAccess
@@ -132851,6 +134913,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),
@@ -132896,16 +134962,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,
@@ -132922,6 +134993,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();
@@ -133633,6 +135705,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 });
@@ -133763,6 +135837,13 @@ function defineControllerNames(namespace, handlers) {
   }
   return handlers;
 }
+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();
+});
 function generateUsername(email5) {
   const baseUsername = (email5.split("@")[0] || "user").toLowerCase();
   const cleanUsername = baseUsername.replace(/[^a-z0-9]/g, "");
@@ -133959,6 +136040,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();
@@ -134110,6 +136194,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 = {
@@ -134152,10 +136262,14 @@ function createSandboxAuthProvider() {
   };
 }
 var sandboxApiKeys;
+var sandboxAssessmentPreparationReceipts;
+var 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 = 300000;
 });
 function createSandboxCacheProvider() {
   return {
@@ -134320,6 +136434,7 @@ function buildConfig(options) {
     baseUrl,
     gameDomain: "localhost",
     uploadBucket: "sandbox-uploads",
+    assessmentArtifactBucket: "sandbox-assessment-artifacts",
     ltiTestMode: true,
     secretsManifestPepper: "sandbox-secrets-manifest-pepper",
     ...options.config
@@ -193453,6 +195568,7 @@ var endActivity;
 var heartbeat;
 var advanceCourse;
 var unenrollCourse;
+var prepareRuntimeAssessment;
 var startRuntimeAssessment;
 var getRuntimeAssessment;
 var getLatestRuntimeAssessment;
@@ -193739,13 +195855,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
     });
   });
@@ -194308,6 +196435,7 @@ var init_timeback_controller = __esm(() => {
     heartbeat,
     advanceCourse,
     unenrollCourse,
+    prepareRuntimeAssessment,
     startRuntimeAssessment,
     getLatestRuntimeAssessment,
     getRuntimeAssessment,
@@ -195261,6 +197389,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));