@intellectif/lk-core 1.2.0 → 1.4.0

package/dist/index.js

@@ -1,1246 +1,1162 @@
-import {
-  XAPIVerb,
-  XAPI_VERB_DISPLAY,
-  validateXAPIStatement,
-  xAPIBuilder,
-  xapiDefinitionFor
-} from "./chunk-JTNDIBZO.js";
-import {
-  dictationJsonSchema,
-  fillInTheBlanksJsonSchema,
-  gapSelectJsonSchema,
-  itemGroupJsonSchema,
-  jsonSchemaFor,
-  multipleChoiceJsonSchema,
-  readAloudJsonSchema,
-  stimulusJsonSchema,
-  validateActivity,
-  validateMedia,
-  validateOptionMedia,
-  writtenResponseJsonSchema
-} from "./chunk-CYPA5BW5.js";
-import {
-  AI_COACHING_MAX_TIP_LENGTH,
-  AI_COACHING_MAX_WORDS,
-  AI_CRITIQUE_MAX_FIELD_LENGTH,
-  AI_CRITIQUE_MAX_FINDINGS,
-  AI_DRAFTS_MAX_COUNT,
-  AI_DRAFTS_MAX_REPAIRS,
-  AI_EXPLANATION_TYPES,
-  AI_HINT_TYPES,
-  AI_TEXT_MAX_LENGTH,
-  AI_WRITING_MAX_CORRECTIONS,
-  AI_WRITING_MAX_FIELD_LENGTH,
-  aiAllowedByContent,
-  aiCoachingRequest,
-  aiCritiqueRequest,
-  aiDraftsRepairRequest,
-  aiDraftsRequest,
-  aiExplanationRequest,
-  aiGradeOf,
-  aiHintRequest,
-  aiSupports,
-  aiWritingFeedbackRequest,
-  buildAiFacts,
-  checkAiCoaching,
-  checkAiCritique,
-  checkAiDrafts,
-  checkAiExplanation,
-  checkAiHint,
-  checkAiWritingFeedback,
-  createDraft,
-  createInteractiveVideoDraft,
-  createItemGroupDraft,
-  critiqueDraft,
-  critiqueDrafts,
-  critiqueItemGroupDraft,
-  generateDrafts,
-  hintRevealsAnswer,
-  interactiveVideoFromDrafts,
-  readAiTextResult,
-  validateDraft,
-  validateItemGroupDraft
-} from "./chunk-7KOWU4RO.js";
-import {
-  DEFAULT_ITEM_SCORING_POLICY,
-  DEFAULT_PASS_THRESHOLD,
-  ITEM_SCORING_MAX_RETRIES,
-  alignReadAloud,
-  classifyBand,
-  composeAssessmentScore,
-  computePassThreshold,
-  diffDictationChars,
-  evaluate,
-  evaluateTries,
-  gradeFromRubric,
-  gradeReadAloud,
-  gte,
-  hasGrade,
-  inspectWav,
-  outcomeFromGrade,
-  outcomeFromUnscorable,
-  resolveItemScoringPolicy,
-  roundGrade,
-  score,
-  scoreTries,
-  validateItemScoringPolicy,
-  validateSpeechAssessment
-} from "./chunk-QX2ERL72.js";
-import {
-  INTERACTIVE_VIDEO_ITEM_TYPES,
-  RedactedItemGroupSchema,
-  TIMELINE_MAX_CHAPTERS,
-  TIMELINE_MAX_ITEMS,
-  TIMELINE_MAX_QUIZZES,
-  TIMELINE_MAX_TITLE_LENGTH,
-  isInteractiveVideoItemType,
-  validateItemGroup
-} from "./chunk-MV2N2WNS.js";
-import {
-  ActivitySchemaError,
-  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
-  DICTATION_MAX_EQUIVALENCES,
-  DICTATION_MAX_EQUIVALENCE_LENGTH,
-  DICTATION_MAX_TEXT_LENGTH,
-  DICTATION_MAX_TRANSCRIPT_LENGTH,
-  DeferredScoringError,
-  MEDIA_FIELD_POLICY,
-  READ_ALOUD_MAX_DIMENSION_WEIGHT,
-  READ_ALOUD_MAX_REFERENCE_LENGTH,
-  READ_ALOUD_MAX_SECONDS,
-  READ_ALOUD_MAX_TAKES,
-  RedactedScoringError,
-  SPEECH_ASSESSMENT_MAX_WORDS,
-  UnknownActivityTypeError,
-  alignDictation,
-  countWords,
-  defineActivityType,
-  dictationReferenceWords,
-  dictationType,
-  fillInTheBlanksType,
-  gapSelectType,
-  getActivityTypeDescriptor,
-  levenshteinDistance,
-  matchText,
-  multipleChoiceType,
-  readAloudType,
-  readSchema,
-  registerActivityType,
-  registeredActivityTypes,
-  writtenResponseType
-} from "./chunk-QS7B42ZR.js";
-
-// src/content-hash.ts
+import { A as AI_TEXT_MAX_LENGTH, B as readAiTextResult, C as validateItemGroupDraft, D as checkAiCoaching, E as aiCoachingRequest, F as aiSupports, I as buildAiFacts, L as checkAiExplanation, M as aiExplanationRequest, N as aiGradeOf, O as AI_EXPLANATION_TYPES, P as aiHintRequest, R as checkAiHint, S as critiqueItemGroupDraft, T as AI_COACHING_MAX_WORDS, V as AI_MATERIAL_MAX_LENGTH, _ as critiqueDraft, a as AI_DRAFTS_MAX_COUNT, b as createItemGroupDraft, c as aiDraftsRequest, d as interactiveVideoFromDrafts, f as AI_CRITIQUE_MAX_FIELD_LENGTH, g as createDraft, h as checkAiCritique, i as checkAiWritingFeedback, j as aiAllowedByContent, k as AI_HINT_TYPES, l as checkAiDrafts, m as aiCritiqueRequest, n as AI_WRITING_MAX_FIELD_LENGTH, o as AI_DRAFTS_MAX_REPAIRS, p as AI_CRITIQUE_MAX_FINDINGS, r as aiWritingFeedbackRequest, s as aiDraftsRepairRequest, t as AI_WRITING_MAX_CORRECTIONS, u as generateDrafts, v as validateDraft, w as AI_COACHING_MAX_TIP_LENGTH, x as critiqueDrafts, y as createInteractiveVideoDraft, z as hintRevealsAnswer } from "./ai-writing-CPpH9Qxq.js";
+import { $ as dictationReferenceWords, A as matchText, J as RedactedScoringError, K as ActivitySchemaError, S as READ_ALOUD_MAX_TAKES, Y as UnknownActivityTypeError, Z as alignDictation, a as readSchema, b as READ_ALOUD_MAX_REFERENCE_LENGTH, c as dictationType, ct as BUILT_IN_ACTIVITY_TYPES, d as multipleChoiceType, et as DICTATION_MAX_ACCEPTED_TRANSCRIPTS, f as readAloudType, it as DICTATION_MAX_TRANSCRIPT_LENGTH, j as countWords, k as levenshteinDistance, l as fillInTheBlanksType, m as defineActivityType, n as registerActivityType, nt as DICTATION_MAX_EQUIVALENCE_LENGTH, p as writtenResponseType, q as DeferredScoringError, r as registeredActivityTypes, rt as DICTATION_MAX_TEXT_LENGTH, s as MEDIA_FIELD_POLICY, t as getActivityTypeDescriptor, tt as DICTATION_MAX_EQUIVALENCES, u as gapSelectType, ut as isBuiltInActivityType, w as SPEECH_ASSESSMENT_MAX_WORDS, x as READ_ALOUD_MAX_SECONDS, y as READ_ALOUD_MAX_DIMENSION_WEIGHT } from "./registry-Dsx9mNsS.js";
+import { C as validateItemScoringPolicy, S as scoreTries, _ as gte, a as inspectWav, b as ITEM_SCORING_MAX_RETRIES, c as validateSpeechAssessment, d as gradeFromRubric, f as hasGrade, g as classifyBand, h as computePassThreshold, i as outcomeFromUnscorable, l as diffDictationChars, m as DEFAULT_PASS_THRESHOLD, n as evaluateTries, o as gradeReadAloud, p as outcomeFromGrade, r as score, s as alignReadAloud, t as evaluate, u as composeAssessmentScore, v as roundGrade, x as resolveItemScoringPolicy, y as DEFAULT_ITEM_SCORING_POLICY } from "./scoring-BZqUkuDF.js";
+import { a as INTERACTIVE_VIDEO_ITEM_TYPES, c as TIMELINE_MAX_QUIZZES, i as validateItemGroup, l as TIMELINE_MAX_TITLE_LENGTH, n as RedactedItemGroupSchema, o as TIMELINE_MAX_CHAPTERS, s as TIMELINE_MAX_ITEMS, u as isInteractiveVideoItemType } from "./item-group-DXiR8nOr.js";
+import { a as fillInTheBlanksJsonSchema, c as jsonSchemaFor, d as stimulusJsonSchema, f as writtenResponseJsonSchema, i as dictationJsonSchema, l as multipleChoiceJsonSchema, n as validateMedia, o as gapSelectJsonSchema, r as validateOptionMedia, s as itemGroupJsonSchema, t as validateActivity, u as readAloudJsonSchema } from "./schemas-Bdw0nGPo.js";
+import { a as validateXAPIStatement, i as XAPI_VERB_DISPLAY, n as xapiDefinitionFor, r as XAPIVerb, t as xAPIBuilder } from "./xapi-CMTph7wG.js";
+//#region src/content-hash.ts
+/**
+* Content fingerprinting — "is this the same content the learner was served?"
+*
+* A recorded attempt outlives the content it was taken against. Papers get
+* corrected, a typo is fixed, an option is reworded — and six months later a
+* remark, an appeal, or a per-item analysis is run against content that is no
+* longer what the learner saw. Nothing warns anybody, because the ids all still
+* match. A fingerprint stored with the attempt turns that silent drift into a
+* question somebody can answer.
+*/
+/**
+* Deterministic JSON: object keys sorted, arrays left in order, `undefined`
+* omitted from objects (matching `JSON.stringify`) and rendered as `null`
+* inside arrays.
+*
+* Key order is the whole point. Two objects that differ only in the order
+* their keys happened to be written are the SAME content, and a fingerprint
+* that disagreed would raise a false alarm every time a payload made a
+* round-trip through a different serializer.
+*/
 function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? JSON.stringify(value === 0 ? 0 : value) : `"#${String(value)}"`;
-  }
-  if (typeof value === "string" || typeof value === "boolean") {
-    return JSON.stringify(value);
-  }
-  if (typeof value === "bigint") {
-    return `"#${value.toString()}n"`;
-  }
-  if (typeof value === "object") {
-    if (seen.has(value)) {
-      throw new Error(
-        "canonicalJson: the value contains a circular reference and cannot be fingerprinted."
-      );
-    }
-    seen.add(value);
-    try {
-      if (Array.isArray(value)) {
-        return `[${value.map((element) => element === void 0 ? "null" : canonicalJson(element, seen)).join(",")}]`;
-      }
-      const source = value;
-      const parts = [];
-      for (const key of Object.keys(source).sort()) {
-        const entry = source[key];
-        if (entry === void 0) {
-          continue;
-        }
-        parts.push(`${JSON.stringify(key)}:${canonicalJson(entry, seen)}`);
-      }
-      return `{${parts.join(",")}}`;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  return "null";
+	if (value === null) return "null";
+	if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value === 0 ? 0 : value) : `"#${String(value)}"`;
+	if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "bigint") return `"#${value.toString()}n"`;
+	if (typeof value === "object") {
+		if (seen.has(value)) throw new Error("canonicalJson: the value contains a circular reference and cannot be fingerprinted.");
+		seen.add(value);
+		try {
+			if (Array.isArray(value)) return `[${value.map((element) => element === void 0 ? "null" : canonicalJson(element, seen)).join(",")}]`;
+			const source = value;
+			const parts = [];
+			for (const key of Object.keys(source).sort()) {
+				const entry = source[key];
+				if (entry === void 0) continue;
+				parts.push(`${JSON.stringify(key)}:${canonicalJson(entry, seen)}`);
+			}
+			return `{${parts.join(",")}}`;
+		} finally {
+			seen.delete(value);
+		}
+	}
+	return "null";
 }
-var FNV_OFFSET = 14695981039346656037n;
-var FNV_PRIME = 1099511628211n;
-var MASK64 = (1n << 64n) - 1n;
+const FNV_OFFSET = 14695981039346656037n;
+const FNV_PRIME = 1099511628211n;
+const MASK64 = (1n << 64n) - 1n;
+/**
+* FNV-1a over the UTF-8 bytes of `input`, as 16 lowercase hex digits.
+*
+* **This is a change-detection fingerprint, not a tamper-evident signature.**
+* It is deterministic across runtimes and dependency-free, which is what makes
+* it usable in a stored grade record — but an adversary who can edit content
+* can also, with effort, preserve the fingerprint. If you need the stronger
+* property, sign the plan with a key the content author does not hold; this
+* exists to catch honest edits, which is what actually happens.
+*/
 function fingerprint(input) {
-  const bytes = new TextEncoder().encode(input);
-  let hash = FNV_OFFSET;
-  for (const byte of bytes) {
-    hash = (hash ^ BigInt(byte)) * FNV_PRIME & MASK64;
-  }
-  return hash.toString(16).padStart(16, "0");
+	const bytes = new TextEncoder().encode(input);
+	let hash = FNV_OFFSET;
+	for (const byte of bytes) hash = (hash ^ BigInt(byte)) * FNV_PRIME & MASK64;
+	return hash.toString(16).padStart(16, "0");
 }
+/**
+* Fingerprints any JSON-serialisable value through {@link canonicalJson}, so
+* the result depends on the content and not on how it was written.
+*/
 function contentHash(value) {
-  return fingerprint(canonicalJson(value));
+	return fingerprint(canonicalJson(value));
 }
-
-// src/delivery.ts
-var OPEN_DELIVERY_POLICY = Object.freeze({
-  feedback: true,
-  solutions: true,
-  hints: true,
-  ai: Object.freeze({ hints: true, explanations: true })
+//#endregion
+//#region src/delivery.ts
+/**
+* The policy that restricts nothing: every setting `true`. It is what an absent
+* policy resolves to, and it is exactly the behaviour the SDK had before
+* delivery policies existed.
+*/
+const OPEN_DELIVERY_POLICY = Object.freeze({
+	feedback: true,
+	solutions: true,
+	hints: true,
+	ai: Object.freeze({
+		hints: true,
+		explanations: true
+	})
 });
-var SETTINGS = ["feedback", "solutions", "hints"];
-var AI_SETTINGS = ["hints", "explanations"];
+const SETTINGS = [
+	"feedback",
+	"solutions",
+	"hints"
+];
+const AI_SETTINGS = ["hints", "explanations"];
+/**
+* One setting as a render reads it. Absent or `null` is unset, and unset is
+* `true`: JSON has no `undefined`, so a setting nobody chose arrives from a
+* database as `null`.
+*
+* Anything else that is not exactly `true` reads as `false`. Every setting is a
+* restriction, so a value that cannot be read is read as the restriction — a
+* `"false"` string from a form, say, whose author meant exactly that. Reading
+* it as `true` would put hints on a paper whose school had switched them off.
+*/
 function allows(value) {
-  return value === void 0 || value === null || value === true;
+	return value === void 0 || value === null || value === true;
 }
+/**
+* A policy with every setting spelled out — see {@link DeliveryPolicy}.
+*
+* Tolerant, because it runs where a learner is waiting: nothing here throws.
+* A value it cannot read restricts rather than allows (see above), and a
+* policy that is not an object at all restricts everything. Check a policy
+* before you store it with {@link validateDeliveryPolicy}; `planAttempt` does.
+*/
 function resolveDeliveryPolicy(policy) {
-  if (policy === void 0 || policy === null) {
-    return OPEN_DELIVERY_POLICY;
-  }
-  if (typeof policy !== "object" || Array.isArray(policy)) {
-    return {
-      feedback: false,
-      solutions: false,
-      hints: false,
-      ai: { hints: false, explanations: false }
-    };
-  }
-  const given = policy;
-  const ai = given.ai;
-  const aiGiven = ai === void 0 || ai === null || ai === true ? {} : typeof ai === "object" && !Array.isArray(ai) ? ai : { hints: false, explanations: false };
-  return {
-    feedback: allows(given.feedback),
-    solutions: allows(given.solutions),
-    hints: allows(given.hints),
-    ai: { hints: allows(aiGiven.hints), explanations: allows(aiGiven.explanations) }
-  };
+	if (policy === void 0 || policy === null) return OPEN_DELIVERY_POLICY;
+	if (typeof policy !== "object" || Array.isArray(policy)) return {
+		feedback: false,
+		solutions: false,
+		hints: false,
+		ai: {
+			hints: false,
+			explanations: false
+		}
+	};
+	const given = policy;
+	const ai = given.ai;
+	const aiGiven = ai === void 0 || ai === null || ai === true ? {} : typeof ai === "object" && !Array.isArray(ai) ? ai : {
+		hints: false,
+		explanations: false
+	};
+	return {
+		feedback: allows(given.feedback),
+		solutions: allows(given.solutions),
+		hints: allows(given.hints),
+		ai: {
+			hints: allows(aiGiven.hints),
+			explanations: allows(aiGiven.explanations)
+		}
+	};
 }
+/**
+* The strictest of several policies: a setting is on only where every one of
+* them leaves it on. How a course's policy and an assessment's combine, and
+* how a pager's policy wins over whatever a question it draws was handed.
+*/
 function combineDeliveryPolicies(...policies) {
-  const resolved = policies.map(resolveDeliveryPolicy);
-  const every = (read) => resolved.every(read);
-  return {
-    feedback: every((one) => one.feedback),
-    solutions: every((one) => one.solutions),
-    hints: every((one) => one.hints),
-    ai: {
-      hints: every((one) => one.ai.hints),
-      explanations: every((one) => one.ai.explanations)
-    }
-  };
+	const resolved = policies.map(resolveDeliveryPolicy);
+	const every = (read) => resolved.every(read);
+	return {
+		feedback: every((one) => one.feedback),
+		solutions: every((one) => one.solutions),
+		hints: every((one) => one.hints),
+		ai: {
+			hints: every((one) => one.ai.hints),
+			explanations: every((one) => one.ai.explanations)
+		}
+	};
 }
+/**
+* Checks a policy before it is stored: each setting `true`, `false`, `null`
+* or absent, and nothing else — no misspelled setting, no string standing in
+* for a boolean.
+*
+* Stricter than {@link resolveDeliveryPolicy} on purpose. A misspelled
+* restriction (`hint: false`) is silently no restriction at all, and a
+* policy is a record of the conditions a paper was sat under: it is worth
+* refusing before it is written down, rather than read charitably after.
+*/
 function validateDeliveryPolicy(policy) {
-  const issues = [];
-  if (policy === void 0 || policy === null) {
-    return { success: true, data: {} };
-  }
-  if (typeof policy !== "object" || Array.isArray(policy)) {
-    return {
-      success: false,
-      issues: [{ path: "", message: "A delivery policy is an object of settings." }]
-    };
-  }
-  const given = policy;
-  for (const key of Object.keys(given)) {
-    if (key === "ai") {
-      continue;
-    }
-    if (!SETTINGS.includes(key)) {
-      issues.push({
-        path: key,
-        message: `"${key}" is not a delivery setting. The settings are feedback, solutions, hints and ai.`
-      });
-      continue;
-    }
-    const value = given[key];
-    if (value !== true && value !== false && value !== null && value !== void 0) {
-      issues.push({ path: key, message: `"${key}" must be true, false or null.` });
-    }
-  }
-  const ai = given.ai;
-  if (ai !== void 0 && ai !== null && ai !== true && ai !== false) {
-    if (typeof ai !== "object" || Array.isArray(ai)) {
-      issues.push({
-        path: "ai",
-        message: '"ai" must be true, false, or an object of hints and explanations.'
-      });
-    } else {
-      for (const [key, value] of Object.entries(ai)) {
-        if (!AI_SETTINGS.includes(key)) {
-          issues.push({
-            path: `ai.${key}`,
-            message: `"ai.${key}" is not an AI setting. The settings are hints and explanations.`
-          });
-          continue;
-        }
-        if (value !== true && value !== false && value !== null && value !== void 0) {
-          issues.push({ path: `ai.${key}`, message: `"ai.${key}" must be true, false or null.` });
-        }
-      }
-    }
-  }
-  return issues.length > 0 ? { success: false, issues } : { success: true, data: given };
+	const issues = [];
+	if (policy === void 0 || policy === null) return {
+		success: true,
+		data: {}
+	};
+	if (typeof policy !== "object" || Array.isArray(policy)) return {
+		success: false,
+		issues: [{
+			path: "",
+			message: "A delivery policy is an object of settings."
+		}]
+	};
+	const given = policy;
+	for (const key of Object.keys(given)) {
+		if (key === "ai") continue;
+		if (!SETTINGS.includes(key)) {
+			issues.push({
+				path: key,
+				message: `"${key}" is not a delivery setting. The settings are feedback, solutions, hints and ai.`
+			});
+			continue;
+		}
+		const value = given[key];
+		if (value !== true && value !== false && value !== null && value !== void 0) issues.push({
+			path: key,
+			message: `"${key}" must be true, false or null.`
+		});
+	}
+	const ai = given.ai;
+	if (ai !== void 0 && ai !== null && ai !== true && ai !== false) {
+		if (typeof ai !== "object" || Array.isArray(ai)) issues.push({
+			path: "ai",
+			message: "\"ai\" must be true, false, or an object of hints and explanations."
+		});
+		else for (const [key, value] of Object.entries(ai)) {
+			if (!AI_SETTINGS.includes(key)) {
+				issues.push({
+					path: `ai.${key}`,
+					message: `"ai.${key}" is not an AI setting. The settings are hints and explanations.`
+				});
+				continue;
+			}
+			if (value !== true && value !== false && value !== null && value !== void 0) issues.push({
+				path: `ai.${key}`,
+				message: `"ai.${key}" must be true, false or null.`
+			});
+		}
+	}
+	return issues.length > 0 ? {
+		success: false,
+		issues
+	} : {
+		success: true,
+		data: given
+	};
 }
-
-// src/shuffle.ts
+//#endregion
+//#region src/shuffle.ts
+/**
+* Seeded, deterministic shuffling — the ONE algorithm every presentation-order
+* decision in the SDK goes through: option order in a multiple-choice item,
+* item order inside an item group, entry order in a sequence. A server and a
+* client holding the same seed derive the same order, and an order recorded
+* against an attempt can be rebuilt later from nothing but its seed.
+*
+* STABILITY: the hash and the generator are part of the wire contract. A
+* stored attempt may hold only a seed and rely on this function to reproduce
+* the order it presented; changing either would silently re-order every
+* recorded attempt. Any change here is a package major, and the pinned
+* permutation test exists so an accidental one fails loudly.
+*/
+/** FNV-1a hash of a string → unsigned 32-bit integer. */
 function hashSeed(input) {
-  let h = 2166136261 >>> 0;
-  for (let i = 0; i < input.length; i += 1) {
-    h ^= input.charCodeAt(i);
-    h = Math.imul(h, 16777619) >>> 0;
-  }
-  return h;
+	let h = 2166136261;
+	for (let i = 0; i < input.length; i += 1) {
+		h ^= input.charCodeAt(i);
+		h = Math.imul(h, 16777619) >>> 0;
+	}
+	return h;
 }
+/** LCG-driven Fisher–Yates over a 32-bit seed; returns a permutation (no loss, no duplicate). */
 function shuffleWithSeed(items, seed, version) {
-  const out = [...items];
-  let s = seed >>> 0 || 1;
-  for (let i = out.length - 1; i > 0; i -= 1) {
-    s = Math.imul(s, 1664525) + 1013904223 >>> 0;
-    const j = version === 2 ? Math.floor(s / 4294967296 * (i + 1)) : s % (i + 1);
-    [out[i], out[j]] = [out[j], out[i]];
-  }
-  return out;
+	const out = [...items];
+	let s = seed >>> 0 || 1;
+	for (let i = out.length - 1; i > 0; i -= 1) {
+		s = Math.imul(s, 1664525) + 1013904223 >>> 0;
+		const j = version === 2 ? Math.floor(s / 4294967296 * (i + 1)) : s % (i + 1);
+		[out[i], out[j]] = [out[j], out[i]];
+	}
+	return out;
 }
 function seededShuffle(items, seed, options = {}) {
-  return shuffleWithSeed(items, hashSeed(seed), options.version ?? 1);
+	return shuffleWithSeed(items, hashSeed(seed), options.version ?? 1);
 }
-
-// src/item-group.ts
+//#endregion
+//#region src/item-group.ts
+/** Narrows a sequence entry to an item group. */
 function isItemGroup(entry) {
-  return entry.type === "item-group";
+	return entry.type === "item-group";
 }
+/**
+* An entry's declared `slotKey`, if it has one. Read structurally rather than
+* from the type, because a plain activity may carry one too — `slotKey` is a
+* property of an item's PLACE in a paper, so any entry can declare it without
+* every activity schema having to know about assessment assembly.
+*
+* A key containing `.` is rejected: `.` separates a group from its item in a
+* slot id, so `"a.b"` as a group key would be indistinguishable from item `b`
+* of group `a`.
+*/
 function keyOf(entry) {
-  const key = entry.slotKey;
-  if (key === void 0) {
-    return void 0;
-  }
-  if (typeof key !== "string" || key.length === 0) {
-    throw new Error(
-      `flattenSequence: slotKey must be a non-empty string, received ${String(key)}.`
-    );
-  }
-  if (key.includes(".")) {
-    throw new Error(
-      `flattenSequence: slotKey "${key}" contains a "." , which separates a group from its item in a slot id. Choose a key without it, or the two become indistinguishable.`
-    );
-  }
-  return key;
+	const key = entry.slotKey;
+	if (key === void 0) return;
+	if (typeof key !== "string" || key.length === 0) throw new Error(`flattenSequence: slotKey must be a non-empty string, received ${String(key)}.`);
+	if (key.includes(".")) throw new Error(`flattenSequence: slotKey "${key}" contains a "." , which separates a group from its item in a slot id. Choose a key without it, or the two become indistinguishable.`);
+	return key;
 }
+/**
+* An interactive video's items in the order its quizzes open: by the quiz's
+* time — stably, so quizzes at one moment keep their authored order — then by
+* position within the quiz. An item no quiz places (content the schema would
+* refuse) keeps its authored place after every placed one, rather than
+* vanishing from the paper.
+*/
 function inQuizOrder(items, timeline) {
-  const placement = /* @__PURE__ */ new Map();
-  timeline.cues.forEach((cue, cueIndex) => {
-    cue.itemIds.forEach((itemId, position) => {
-      if (!placement.has(itemId)) {
-        placement.set(itemId, { at: cue.at, cue: cueIndex, position });
-      }
-    });
-  });
-  const unplaced = { at: Number.POSITIVE_INFINITY, cue: Number.POSITIVE_INFINITY, position: 0 };
-  return items.map((entry) => ({ entry, place: placement.get(entry.item.id) ?? unplaced })).sort(
-    (a, b) => a.place.at - b.place.at || a.place.cue - b.place.cue || a.place.position - b.place.position || a.entry.itemIndex - b.entry.itemIndex
-  ).map(({ entry }) => entry);
+	const placement = /* @__PURE__ */ new Map();
+	timeline.cues.forEach((cue, cueIndex) => {
+		cue.itemIds.forEach((itemId, position) => {
+			if (!placement.has(itemId)) placement.set(itemId, {
+				at: cue.at,
+				cue: cueIndex,
+				position
+			});
+		});
+	});
+	const unplaced = {
+		at: Number.POSITIVE_INFINITY,
+		cue: Number.POSITIVE_INFINITY,
+		position: 0
+	};
+	return items.map((entry) => ({
+		entry,
+		place: placement.get(entry.item.id) ?? unplaced
+	})).sort((a, b) => a.place.at - b.place.at || a.place.cue - b.place.cue || a.place.position - b.place.position || a.entry.itemIndex - b.entry.itemIndex).map(({ entry }) => entry);
 }
+/**
+* Turns a sequence definition — loose activities and item groups, in authored
+* order — into the ordered list of slots to present. Pure and deterministic:
+* call it on the server to record an attempt's order, and on the client to
+* render it, and the two agree.
+*
+* Shuffling is opt-in and seeded. Groups are shuffle-atomic: with
+* `shuffleEntries` a group changes position but stays one contiguous block,
+* and only a group that declares `shuffle: 'within-group'` has its items
+* reordered. Every slot carries a `slotId` derived from the authored
+* position, so identities survive shuffling.
+*
+* @throws Error when a shuffle is requested without a `seed`.
+*/
 function flattenSequence(entries, options = {}) {
-  const shuffleEntries = options.shuffleEntries === true;
-  const needsSeed = shuffleEntries || entries.some((entry) => isItemGroup(entry) && entry.shuffle === "within-group");
-  if (needsSeed && options.seed === void 0) {
-    throw new Error(
-      'flattenSequence: a seed is required when shuffling (shuffleEntries, or a group with shuffle: "within-group"). Pass the attempt id so the server and the client derive the same order.'
-    );
-  }
-  const seed = options.seed ?? "";
-  const authored = entries.map((entry, entryIndex) => ({ entry, entryIndex }));
-  const ordered = shuffleEntries ? seededShuffle(authored, `${seed}:entries`) : authored;
-  const slots = [];
-  for (const { entry, entryIndex } of ordered) {
-    const entryKey = keyOf(entry) ?? String(entryIndex);
-    if (!isItemGroup(entry)) {
-      slots.push({ slotId: entryKey, index: slots.length, activity: entry });
-      continue;
-    }
-    if (entry.items.length === 0) {
-      throw new Error(
-        `flattenSequence: item group "${entry.id}" has no items. An empty group would silently remove its stimulus and its questions from the presented sequence.`
-      );
-    }
-    const timeline = entry.timeline;
-    if (timeline !== void 0 && entry.shuffle === "within-group") {
-      throw new Error(
-        `flattenSequence: item group "${entry.id}" has a timeline and shuffle: "within-group". An interactive video presents its questions in the order its quizzes open.`
-      );
-    }
-    const items = entry.items.map((item, itemIndex) => ({ item, itemIndex }));
-    const presented = timeline !== void 0 ? inQuizOrder(items, timeline) : entry.shuffle === "within-group" ? seededShuffle(items, `${seed}:group:${entry.id}`) : items;
-    const size = presented.length;
-    presented.forEach(({ item, itemIndex }, position) => {
-      const cue = timeline?.cues.find((candidate) => candidate.itemIds.includes(item.id));
-      slots.push({
-        // Slot ids stay AUTHORED — the item's index or its key — whatever the
-        // presented order: moving a quiz must never re-map a stored answer.
-        slotId: `${entryKey}.${keyOf(item) ?? String(itemIndex)}`,
-        index: slots.length,
-        activity: item,
-        group: {
-          id: entry.id,
-          ...entry.title !== void 0 ? { title: entry.title } : {},
-          stimulus: entry.stimulus,
-          position,
-          size,
-          ...timeline !== void 0 ? { timeline } : {},
-          ...cue !== void 0 ? { cue } : {}
-        }
-      });
-    });
-  }
-  const seenSlotIds = /* @__PURE__ */ new Set();
-  const seenEntryKeys = /* @__PURE__ */ new Set();
-  for (const slot of slots) {
-    if (seenSlotIds.has(slot.slotId)) {
-      throw new Error(
-        `flattenSequence: duplicate slot id "${slot.slotId}". Two entries declare the same slotKey, so responses stored against them could not be told apart.`
-      );
-    }
-    seenSlotIds.add(slot.slotId);
-  }
-  for (const { entry, entryIndex } of ordered) {
-    const entryKey = keyOf(entry) ?? String(entryIndex);
-    if (seenEntryKeys.has(entryKey)) {
-      throw new Error(
-        `flattenSequence: duplicate entry key "${entryKey}". A loose activity and an item group cannot share a slotKey \u2014 their slot ids would not collide, but everything that reads the entry they belong to would treat them as one entry.`
-      );
-    }
-    seenEntryKeys.add(entryKey);
-  }
-  return slots;
+	const shuffleEntries = options.shuffleEntries === true;
+	if ((shuffleEntries || entries.some((entry) => isItemGroup(entry) && entry.shuffle === "within-group")) && options.seed === void 0) throw new Error("flattenSequence: a seed is required when shuffling (shuffleEntries, or a group with shuffle: \"within-group\"). Pass the attempt id so the server and the client derive the same order.");
+	const seed = options.seed ?? "";
+	const authored = entries.map((entry, entryIndex) => ({
+		entry,
+		entryIndex
+	}));
+	const ordered = shuffleEntries ? seededShuffle(authored, `${seed}:entries`, { version: 1 }) : authored;
+	const slots = [];
+	for (const { entry, entryIndex } of ordered) {
+		const entryKey = keyOf(entry) ?? String(entryIndex);
+		if (!isItemGroup(entry)) {
+			slots.push({
+				slotId: entryKey,
+				index: slots.length,
+				activity: entry
+			});
+			continue;
+		}
+		if (entry.items.length === 0) throw new Error(`flattenSequence: item group "${entry.id}" has no items. An empty group would silently remove its stimulus and its questions from the presented sequence.`);
+		const timeline = entry.timeline;
+		if (timeline !== void 0 && entry.shuffle === "within-group") throw new Error(`flattenSequence: item group "${entry.id}" has a timeline and shuffle: "within-group". An interactive video presents its questions in the order its quizzes open.`);
+		const items = entry.items.map((item, itemIndex) => ({
+			item,
+			itemIndex
+		}));
+		const presented = timeline !== void 0 ? inQuizOrder(items, timeline) : entry.shuffle === "within-group" ? seededShuffle(items, `${seed}:group:${entry.id}`, { version: 1 }) : items;
+		const size = presented.length;
+		presented.forEach(({ item, itemIndex }, position) => {
+			const cue = timeline?.cues.find((candidate) => candidate.itemIds.includes(item.id));
+			slots.push({
+				slotId: `${entryKey}.${keyOf(item) ?? String(itemIndex)}`,
+				index: slots.length,
+				activity: item,
+				group: {
+					id: entry.id,
+					...entry.title !== void 0 ? { title: entry.title } : {},
+					stimulus: entry.stimulus,
+					position,
+					size,
+					...timeline !== void 0 ? { timeline } : {},
+					...cue !== void 0 ? { cue } : {}
+				}
+			});
+		});
+	}
+	const seenSlotIds = /* @__PURE__ */ new Set();
+	const seenEntryKeys = /* @__PURE__ */ new Set();
+	for (const slot of slots) {
+		if (seenSlotIds.has(slot.slotId)) throw new Error(`flattenSequence: duplicate slot id "${slot.slotId}". Two entries declare the same slotKey, so responses stored against them could not be told apart.`);
+		seenSlotIds.add(slot.slotId);
+	}
+	for (const { entry, entryIndex } of ordered) {
+		const entryKey = keyOf(entry) ?? String(entryIndex);
+		if (seenEntryKeys.has(entryKey)) throw new Error(`flattenSequence: duplicate entry key "${entryKey}". A loose activity and an item group cannot share a slotKey — their slot ids would not collide, but everything that reads the entry they belong to would treat them as one entry.`);
+		seenEntryKeys.add(entryKey);
+	}
+	return slots;
 }
-
-// src/media-budget.ts
+//#endregion
+//#region src/media-budget.ts
+/**
+* The authored-entry prefix of a slot id: `"3"` for both `"3"` and `"3.1"`.
+*
+* Safe because every slot id in a plan is produced by `flattenSequence`, and
+* `keyOf` rejects a `.` in both an entry key and an item key — so the first
+* `.` is always the group/item separator.
+*/
 function entryKeyOf(slotId) {
-  const dot = slotId.indexOf(".");
-  return dot === -1 ? slotId : slotId.slice(0, dot);
+	const dot = slotId.indexOf(".");
+	return dot === -1 ? slotId : slotId.slice(0, dot);
 }
+/** Budget key for an activity's OWN `data.media`. One budget per slot. */
 function slotMediaKey(slotId) {
-  return `slot:${slotId}`;
+	return `slot:${slotId}`;
 }
+/**
+* Budget key for an item group's `stimulus.media`.
+*
+* Keyed by the ENTRY, not the slot: one recording serves every question in the
+* group, so `"3.0"`…`"3.5"` share one budget. Keying by `slotId` would hand a
+* six-question `maxPlays: 2` listening group twelve plays; keying by
+* `stimulus.id` would collide across papers, which is the thing slot keys and
+* `planHash` exist to prevent.
+*/
 function stimulusMediaKey(slotId) {
-  return `stimulus:${entryKeyOf(slotId)}`;
+	return `stimulus:${entryKeyOf(slotId)}`;
 }
+/**
+* Resolves the defaults once, so the schema refinements, the plan and the
+* renderer cannot drift apart about what a policy means.
+*
+* Absent `playback` resolves to exactly the SDK's pre-0.8.0 behaviour:
+* `controls: 'native'`, no budget, free seeking, free speed, no hints.
+*/
 function resolvePlaybackPolicy(media) {
-  const p = media.playback;
-  const budgeted = typeof p?.maxPlays === "number";
-  const seek = p?.seek ?? (budgeted ? "none" : "allow");
-  const rate = p?.rate ?? "allow";
-  const controls = p?.controls ?? (budgeted || seek === "none" || rate === "fixed" ? "minimal" : "native");
-  return {
-    controls,
-    maxPlays: budgeted ? p?.maxPlays : null,
-    seek,
-    rate,
-    nativeControlHints: p?.nativeControlHints ?? []
-  };
+	const p = media.playback;
+	const budgeted = typeof p?.maxPlays === "number";
+	const seek = p?.seek ?? (budgeted ? "none" : "allow");
+	const rate = p?.rate ?? "allow";
+	return {
+		controls: p?.controls ?? (budgeted || seek === "none" || rate === "fixed" ? "minimal" : "native"),
+		maxPlays: budgeted ? p?.maxPlays : null,
+		seek,
+		rate,
+		nativeControlHints: p?.nativeControlHints ?? []
+	};
 }
+/**
+* Every budgeted recording a plan contains: budget key → the `maxPlays` that
+* was frozen when the attempt was planned.
+*
+* Use it to build the storage rows an attempt needs, and to check a stored
+* ledger against the paper it claims to belong to.
+*/
 function planMediaBudgets(plan) {
-  const out = {};
-  for (const slot of plan.slots) {
-    for (const budget of slot.mediaBudgets ?? []) {
-      out[budget.key] = budget.maxPlays;
-    }
-  }
-  return out;
+	const out = {};
+	for (const slot of plan.slots) for (const budget of slot.mediaBudgets ?? []) out[budget.key] = budget.maxPlays;
+	return out;
 }
 function assertEntry(key, entry) {
-  if (entry === null || typeof entry !== "object" || !Number.isInteger(entry.plays) || entry.plays < 0) {
-    throw new Error(
-      `serializeMediaPlayLedger: play count for ${JSON.stringify(key)} is ${JSON.stringify(entry?.plays)}. A count must be a non-negative integer; Number(a NULL column) is the usual cause.`
-    );
-  }
-  if (entry.at !== void 0 && (!Number.isFinite(entry.at) || entry.at < 0)) {
-    throw new Error(
-      `serializeMediaPlayLedger: position for ${JSON.stringify(key)} is ${JSON.stringify(entry.at)}. A position must be a finite number of seconds >= 0.`
-    );
-  }
+	if (entry === null || typeof entry !== "object" || !Number.isInteger(entry.plays) || entry.plays < 0) throw new Error(`serializeMediaPlayLedger: play count for ${JSON.stringify(key)} is ${JSON.stringify(entry?.plays)}. A count must be a non-negative integer; Number(a NULL column) is the usual cause.`);
+	if (entry.at !== void 0 && (!Number.isFinite(entry.at) || entry.at < 0)) throw new Error(`serializeMediaPlayLedger: position for ${JSON.stringify(key)} is ${JSON.stringify(entry.at)}. A position must be a finite number of seconds >= 0.`);
 }
+/**
+* Validates a set of spent-play counts against the plan that budgeted them,
+* and stamps the envelope.
+*
+* Validates on the way **in**: a play recorded against a recording the paper
+* does not budget is a bug at the moment it is written, and discovering it
+* when a learner tries to resume is discovering it far too late.
+*
+* @throws Error when a key is not budgeted by the plan, or a count is not a
+*         non-negative integer, or a position is not a finite number.
+*/
 function serializeMediaPlayLedger(plan, entries, options = {}) {
-  if (entries === null || typeof entries !== "object") {
-    throw new Error("serializeMediaPlayLedger: entries must be an object keyed by media key.");
-  }
-  const budgets = planMediaBudgets(plan);
-  const out = {};
-  for (const key of Object.keys(entries)) {
-    if (!Object.hasOwn(budgets, key)) {
-      throw new Error(
-        `serializeMediaPlayLedger: media play recorded against a recording the plan does not budget: ${JSON.stringify(key)}. Keys come from slotMediaKey() / stimulusMediaKey(); a key that belongs to no budgeted media means the client and the plan disagree about which paper this is.`
-      );
-    }
-    const entry = entries[key];
-    assertEntry(key, entry);
-    out[key] = { plays: entry.plays, ...entry.at !== void 0 ? { at: entry.at } : {} };
-  }
-  return {
-    ledgerVersion: "1.0",
-    planHash: plan.planHash,
-    entries: out,
-    ...options.savedAt !== void 0 ? { savedAt: options.savedAt } : {}
-  };
+	if (entries === null || typeof entries !== "object") throw new Error("serializeMediaPlayLedger: entries must be an object keyed by media key.");
+	const budgets = planMediaBudgets(plan);
+	const out = {};
+	for (const key of Object.keys(entries)) {
+		if (!Object.hasOwn(budgets, key)) throw new Error(`serializeMediaPlayLedger: media play recorded against a recording the plan does not budget: ${JSON.stringify(key)}. Keys come from slotMediaKey() / stimulusMediaKey(); a key that belongs to no budgeted media means the client and the plan disagree about which paper this is.`);
+		const entry = entries[key];
+		assertEntry(key, entry);
+		out[key] = {
+			plays: entry.plays,
+			...entry.at !== void 0 ? { at: entry.at } : {}
+		};
+	}
+	return {
+		ledgerVersion: "1.0",
+		planHash: plan.planHash,
+		entries: out,
+		...options.savedAt !== void 0 ? { savedAt: options.savedAt } : {}
+	};
 }
+/**
+* Reopens a stored ledger against the paper it was spent on.
+*
+* Refuses a ledger from a different paper for the same reason
+* `restoreAttemptState` does: budget keys are short and repeat across papers
+* (`slot:0`, `stimulus:1`), so a ledger from last term's midterm would hold a
+* learner to a budget from an exam they never sat, and look entirely plausible
+* doing it.
+*
+* @throws Error on an unrecognised `ledgerVersion`, a `planHash` mismatch, or
+*         anything `serializeMediaPlayLedger` refuses.
+*/
 function restoreMediaPlayLedger(plan, stored) {
-  if (stored === null || typeof stored !== "object") {
-    throw new Error("restoreMediaPlayLedger: the stored ledger is not an object.");
-  }
-  if (stored.ledgerVersion !== "1.0") {
-    throw new Error(
-      `restoreMediaPlayLedger: unsupported ledgerVersion ${JSON.stringify(stored.ledgerVersion)}. This build understands "1.0"; a newer ledger must be migrated before it is restored.`
-    );
-  }
-  if (stored.entries === null || typeof stored.entries !== "object") {
-    throw new Error(
-      "restoreMediaPlayLedger: the ledger carries no entries object (a NULL column, or a partially written row)."
-    );
-  }
-  if (stored.planHash !== plan.planHash) {
-    throw new Error(
-      `restoreMediaPlayLedger: this ledger belongs to a different paper (ledger ${stored.planHash}, plan ${plan.planHash}). Restoring it would hold the learner to a play budget from an exam they never sat.`
-    );
-  }
-  return serializeMediaPlayLedger(plan, stored.entries, {
-    ...stored.savedAt !== void 0 ? { savedAt: stored.savedAt } : {}
-  });
+	if (stored === null || typeof stored !== "object") throw new Error("restoreMediaPlayLedger: the stored ledger is not an object.");
+	if (stored.ledgerVersion !== "1.0") throw new Error(`restoreMediaPlayLedger: unsupported ledgerVersion ${JSON.stringify(stored.ledgerVersion)}. This build understands "1.0"; a newer ledger must be migrated before it is restored.`);
+	if (stored.entries === null || typeof stored.entries !== "object") throw new Error("restoreMediaPlayLedger: the ledger carries no entries object (a NULL column, or a partially written row).");
+	if (stored.planHash !== plan.planHash) throw new Error(`restoreMediaPlayLedger: this ledger belongs to a different paper (ledger ${stored.planHash}, plan ${plan.planHash}). Restoring it would hold the learner to a play budget from an exam they never sat.`);
+	return serializeMediaPlayLedger(plan, stored.entries, { ...stored.savedAt !== void 0 ? { savedAt: stored.savedAt } : {} });
 }
-
-// src/attempt-plan.ts
+//#endregion
+//#region src/attempt-plan.ts
+/**
+* The activity as CONTENT, with its slot key removed.
+*
+* `slotKey` rides on the same object but is identity, not content — the whole
+* point of the design. Including it in the fingerprint meant that annotating
+* an existing entry with the key that pins its identity reported as
+* "this question was edited", which is precisely backwards.
+*/
 function contentOf(activity) {
-  if (!Object.hasOwn(activity, "slotKey")) {
-    return activity;
-  }
-  const { slotKey: _slotKey, ...content } = activity;
-  return content;
+	if (!Object.hasOwn(activity, "slotKey")) return activity;
+	const { slotKey: _slotKey, ...content } = activity;
+	return content;
 }
+/**
+* The budgeted recordings a slot presents: its own media, and its group's
+* stimulus. Returns `undefined` — not `[]` — when nothing is budgeted, so the
+* conditional spread below leaves the serialized slot byte-identical to what
+* every pre-0.8.0 paper produced.
+*/
 function mediaBudgetsOf(slot) {
-  const budgets = [];
-  const own = slot.activity.media;
-  if (own !== void 0) {
-    const maxPlays = resolvePlaybackPolicy(own).maxPlays;
-    if (maxPlays !== null) {
-      budgets.push({ key: slotMediaKey(slot.slotId), maxPlays });
-    }
-  }
-  const stimulusMedia = slot.group?.stimulus.media;
-  if (stimulusMedia !== void 0) {
-    const maxPlays = resolvePlaybackPolicy(stimulusMedia).maxPlays;
-    if (maxPlays !== null) {
-      budgets.push({ key: stimulusMediaKey(slot.slotId), maxPlays });
-    }
-  }
-  return budgets.length > 0 ? budgets : void 0;
+	const budgets = [];
+	const own = slot.activity.media;
+	if (own !== void 0) {
+		const maxPlays = resolvePlaybackPolicy(own).maxPlays;
+		if (maxPlays !== null) budgets.push({
+			key: slotMediaKey(slot.slotId),
+			maxPlays
+		});
+	}
+	const stimulusMedia = slot.group?.stimulus.media;
+	if (stimulusMedia !== void 0) {
+		const maxPlays = resolvePlaybackPolicy(stimulusMedia).maxPlays;
+		if (maxPlays !== null) budgets.push({
+			key: stimulusMediaKey(slot.slotId),
+			maxPlays
+		});
+	}
+	return budgets.length > 0 ? budgets : void 0;
 }
+/**
+* Refuses a paper in which one recording is budgeted under several keys.
+*
+* Six questions that each carry the same `/audio/part2.mp3` with `maxPlays: 2`
+* are six budgets, so the learner gets twelve plays of one recording while the
+* paper says two. The fix is authoring, not arithmetic: questions that share a
+* recording belong in an item group, whose stimulus is one recording with one
+* budget.
+*/
 function assertNoSplitBudgets(slots) {
-  const keysByUrl = /* @__PURE__ */ new Map();
-  for (const slot of slots) {
-    const own = slot.activity.media;
-    if (own === void 0 || resolvePlaybackPolicy(own).maxPlays === null) {
-      continue;
-    }
-    const keys = keysByUrl.get(own.url) ?? [];
-    keys.push(slotMediaKey(slot.slotId));
-    keysByUrl.set(own.url, keys);
-  }
-  for (const [url, keys] of keysByUrl) {
-    if (keys.length > 1) {
-      throw new Error(
-        `planAttempt: media ${JSON.stringify(url)} is budgeted under ${keys.length} separate keys (${keys.join(", ")}), so one recording grants ${keys.length} \xD7 maxPlays. Put the questions that share a recording in an item group \u2014 a group's stimulus is one recording with one budget.`
-      );
-    }
-  }
+	const keysByUrl = /* @__PURE__ */ new Map();
+	for (const slot of slots) {
+		const own = slot.activity.media;
+		if (own === void 0 || resolvePlaybackPolicy(own).maxPlays === null) continue;
+		const keys = keysByUrl.get(own.url) ?? [];
+		keys.push(slotMediaKey(slot.slotId));
+		keysByUrl.set(own.url, keys);
+	}
+	for (const [url, keys] of keysByUrl) if (keys.length > 1) throw new Error(`planAttempt: media ${JSON.stringify(url)} is budgeted under ${keys.length} separate keys (${keys.join(", ")}), so one recording grants ${keys.length} × maxPlays. Put the questions that share a recording in an item group — a group's stimulus is one recording with one budget.`);
 }
 function planSlot(slot, points) {
-  if (!Number.isFinite(points) || points < 0) {
-    throw new Error(
-      `planAttempt: slot "${slot.slotId}" resolved to ${String(points)} points. Points must be a finite, non-negative number, or the paper has no defensible total.`
-    );
-  }
-  const mediaBudgets = mediaBudgetsOf(slot);
-  return {
-    slotId: slot.slotId,
-    index: slot.index,
-    activityId: slot.activity.id,
-    activityType: slot.activity.type,
-    points,
-    contentHash: contentHash(contentOf(slot.activity)),
-    ...slot.group !== void 0 ? {
-      group: {
-        id: slot.group.id,
-        ...slot.group.title !== void 0 ? { title: slot.group.title } : {},
-        stimulusHash: contentHash(slot.group.stimulus),
-        ...slot.group.cue !== void 0 ? {
-          cue: {
-            id: slot.group.cue.id,
-            at: slot.group.cue.at,
-            ...slot.group.cue.required !== void 0 ? { required: slot.group.cue.required } : {}
-          }
-        } : {}
-      }
-    } : {},
-    ...mediaBudgets !== void 0 ? { mediaBudgets } : {}
-  };
+	if (!Number.isFinite(points) || points < 0) throw new Error(`planAttempt: slot "${slot.slotId}" resolved to ${String(points)} points. Points must be a finite, non-negative number, or the paper has no defensible total.`);
+	const mediaBudgets = mediaBudgetsOf(slot);
+	return {
+		slotId: slot.slotId,
+		index: slot.index,
+		activityId: slot.activity.id,
+		activityType: slot.activity.type,
+		points,
+		contentHash: contentHash(contentOf(slot.activity)),
+		...slot.group !== void 0 ? { group: {
+			id: slot.group.id,
+			...slot.group.title !== void 0 ? { title: slot.group.title } : {},
+			stimulusHash: contentHash(slot.group.stimulus),
+			...slot.group.cue !== void 0 ? { cue: {
+				id: slot.group.cue.id,
+				at: slot.group.cue.at,
+				...slot.group.cue.required !== void 0 ? { required: slot.group.cue.required } : {}
+			} } : {}
+		} } : {},
+		...mediaBudgets !== void 0 ? { mediaBudgets } : {}
+	};
 }
+/**
+* Freezes what an attempt is being served: the presented order, each slot's
+* identity and worth, and a fingerprint of the content behind it.
+*
+* Call this once, when the attempt starts, and store the result beside the
+* responses. Everything that decides the grade is then a historical fact
+* rather than a re-read of content that may since have changed — which is what
+* makes a re-grade, a remark or an appeal answerable.
+*
+* Ordering comes from `flattenSequence`, so a plan and a live render of the
+* same entries with the same seed agree slot for slot.
+*
+* @throws Error when a shuffle is requested without a seed, when a group is
+*         empty, when two entries collide on a `slotKey`, or when `points`
+*         returns a value that is not finite and non-negative.
+*/
 function planAttempt(entries, options = {}) {
-  const { seed, shuffleEntries, points } = options;
-  const delivery = frozenDelivery(options.delivery);
-  const scoring = frozenScoring(options.scoring);
-  const slots = flattenSequence(entries, {
-    ...shuffleEntries !== void 0 ? { shuffleEntries } : {},
-    ...seed !== void 0 ? { seed } : {}
-  });
-  assertNoSplitBudgets(slots);
-  const planned = slots.map((slot) => planSlot(slot, points?.(slot) ?? 1));
-  const totalPoints = planned.reduce((sum, slot) => sum + slot.points, 0);
-  return {
-    planVersion: "1.0",
-    ...seed !== void 0 ? { seed } : {},
-    ...shuffleEntries !== void 0 ? { shuffleEntries } : {},
-    // The plan's own fingerprint covers the slots verbatim — identity, order,
-    // points and content hashes — so one stored value answers "is this still
-    // the paper that was sat?" and the per-slot hashes then say what moved.
-    // A policy joins it when there is one: the same paper sat with hints and
-    // without is two different attempts. Without one, the fingerprint is the
-    // one every plan before policies had.
-    // So does a scoring policy: the same answers are worth something else when
-    // a hint costs a tenth of the marks. Each joins only when it is there, so
-    // a plan with neither — or with a delivery policy alone — keeps the
-    // fingerprint it always had.
-    planHash: contentHash(
-      delivery === void 0 && scoring === void 0 ? planned : {
-        slots: planned,
-        ...delivery !== void 0 ? { delivery } : {},
-        ...scoring !== void 0 ? { scoring } : {}
-      }
-    ),
-    ...delivery !== void 0 ? { delivery } : {},
-    ...scoring !== void 0 ? { scoring } : {},
-    slots: planned,
-    totalPoints
-  };
+	const { seed, shuffleEntries, points } = options;
+	const delivery = frozenDelivery(options.delivery);
+	const scoring = frozenScoring(options.scoring);
+	const slots = flattenSequence(entries, {
+		...shuffleEntries !== void 0 ? { shuffleEntries } : {},
+		...seed !== void 0 ? { seed } : {}
+	});
+	assertNoSplitBudgets(slots);
+	const planned = slots.map((slot) => planSlot(slot, points?.(slot) ?? 1));
+	const totalPoints = planned.reduce((sum, slot) => sum + slot.points, 0);
+	return {
+		planVersion: "1.0",
+		...seed !== void 0 ? { seed } : {},
+		...shuffleEntries !== void 0 ? { shuffleEntries } : {},
+		planHash: contentHash(delivery === void 0 && scoring === void 0 ? planned : {
+			slots: planned,
+			...delivery !== void 0 ? { delivery } : {},
+			...scoring !== void 0 ? { scoring } : {}
+		}),
+		...delivery !== void 0 ? { delivery } : {},
+		...scoring !== void 0 ? { scoring } : {},
+		slots: planned,
+		totalPoints
+	};
 }
+/**
+* Compares a stored plan with the content as it stands now, and reports every
+* way they have drifted apart.
+*
+* This is the question a remark or an appeal actually asks: *is the paper I am
+* looking at the paper this learner sat?* Ids alone cannot answer it, because
+* they survive an edit unchanged.
+*
+* Rebuild the comparison plan with the SAME options the stored one recorded —
+* its `seed`, its `shuffleEntries`, and the same `points` function — or the
+* differences you see will be your own:
+*
+* ```ts
+* const now = planAttempt(currentEntries, {
+*   seed: stored.seed,
+*   shuffleEntries: stored.shuffleEntries,
+*   points: pointsFor,          // omit it and every slot reweights to 1
+* });
+* const drift = verifyAttemptPlan(stored, now);
+* ```
+*
+* A drift is not automatically a problem — a fixed typo changes a hash without
+* changing what was asked. It is a fact somebody has to be able to see.
+*/
 function verifyAttemptPlan(plan, current) {
-  const before = new Map(plan.slots.map((slot) => [slot.slotId, slot]));
-  const after = new Map(current.slots.map((slot) => [slot.slotId, slot]));
-  const missingSlotIds = plan.slots.filter((s) => !after.has(s.slotId)).map((s) => s.slotId);
-  const addedSlotIds = current.slots.filter((s) => !before.has(s.slotId)).map((s) => s.slotId);
-  const changedSlotIds = [];
-  const changedStimulusSlotIds = [];
-  const changedCueSlotIds = [];
-  const changedPointsSlotIds = [];
-  const reorderedSlotIds = [];
-  const deliveryChanged = contentHash(plan.delivery ?? null) !== contentHash(current.delivery ?? null);
-  const scoringChanged = contentHash(plan.scoring ?? null) !== contentHash(current.scoring ?? null);
-  for (const slot of plan.slots) {
-    const now = after.get(slot.slotId);
-    if (now === void 0) {
-      continue;
-    }
-    if (now.contentHash !== slot.contentHash) {
-      changedSlotIds.push(slot.slotId);
-    }
-    if (now.group?.stimulusHash !== slot.group?.stimulusHash) {
-      changedStimulusSlotIds.push(slot.slotId);
-    }
-    if (contentHash(now.group?.cue ?? null) !== contentHash(slot.group?.cue ?? null)) {
-      changedCueSlotIds.push(slot.slotId);
-    }
-    if (now.points !== slot.points) {
-      changedPointsSlotIds.push(slot.slotId);
-    }
-    if (now.index !== slot.index) {
-      reorderedSlotIds.push(slot.slotId);
-    }
-  }
-  return {
-    matches: missingSlotIds.length === 0 && addedSlotIds.length === 0 && changedSlotIds.length === 0 && changedStimulusSlotIds.length === 0 && changedCueSlotIds.length === 0 && changedPointsSlotIds.length === 0 && reorderedSlotIds.length === 0 && !deliveryChanged && !scoringChanged,
-    missingSlotIds,
-    addedSlotIds,
-    changedSlotIds,
-    changedStimulusSlotIds,
-    changedCueSlotIds,
-    changedPointsSlotIds,
-    reorderedSlotIds,
-    // Present only when it is true, as `rejectedSlotIds` is on a composed
-    // score: a drift report between two plans without a policy — every one
-    // written before policies existed — keeps exactly the shape it had.
-    ...deliveryChanged ? { deliveryChanged: true } : {},
-    ...scoringChanged ? { scoringChanged: true } : {}
-  };
+	const before = new Map(plan.slots.map((slot) => [slot.slotId, slot]));
+	const after = new Map(current.slots.map((slot) => [slot.slotId, slot]));
+	const missingSlotIds = plan.slots.filter((s) => !after.has(s.slotId)).map((s) => s.slotId);
+	const addedSlotIds = current.slots.filter((s) => !before.has(s.slotId)).map((s) => s.slotId);
+	const changedSlotIds = [];
+	const changedStimulusSlotIds = [];
+	const changedCueSlotIds = [];
+	const changedPointsSlotIds = [];
+	const reorderedSlotIds = [];
+	const deliveryChanged = contentHash(plan.delivery ?? null) !== contentHash(current.delivery ?? null);
+	const scoringChanged = contentHash(plan.scoring ?? null) !== contentHash(current.scoring ?? null);
+	for (const slot of plan.slots) {
+		const now = after.get(slot.slotId);
+		if (now === void 0) continue;
+		if (now.contentHash !== slot.contentHash) changedSlotIds.push(slot.slotId);
+		if (now.group?.stimulusHash !== slot.group?.stimulusHash) changedStimulusSlotIds.push(slot.slotId);
+		if (contentHash(now.group?.cue ?? null) !== contentHash(slot.group?.cue ?? null)) changedCueSlotIds.push(slot.slotId);
+		if (now.points !== slot.points) changedPointsSlotIds.push(slot.slotId);
+		if (now.index !== slot.index) reorderedSlotIds.push(slot.slotId);
+	}
+	return {
+		matches: missingSlotIds.length === 0 && addedSlotIds.length === 0 && changedSlotIds.length === 0 && changedStimulusSlotIds.length === 0 && changedCueSlotIds.length === 0 && changedPointsSlotIds.length === 0 && reorderedSlotIds.length === 0 && !deliveryChanged && !scoringChanged,
+		missingSlotIds,
+		addedSlotIds,
+		changedSlotIds,
+		changedStimulusSlotIds,
+		changedCueSlotIds,
+		changedPointsSlotIds,
+		reorderedSlotIds,
+		...deliveryChanged ? { deliveryChanged: true } : {},
+		...scoringChanged ? { scoringChanged: true } : {}
+	};
 }
+/**
+* The policy a plan records: checked, then spelled out. `undefined` when there
+* is none, so the plan carries no field at all rather than an empty one.
+*/
 function frozenDelivery(policy) {
-  if (policy === void 0 || policy === null) {
-    return void 0;
-  }
-  const checked = validateDeliveryPolicy(policy);
-  if (!checked.success) {
-    const first = checked.issues[0];
-    throw new Error(
-      `planAttempt: the delivery policy is not one to record \u2014 ${first?.message ?? "invalid"}` + (checked.issues.length > 1 ? ` (and ${checked.issues.length - 1} more)` : "")
-    );
-  }
-  return resolveDeliveryPolicy(checked.data);
+	if (policy === void 0 || policy === null) return;
+	const checked = validateDeliveryPolicy(policy);
+	if (!checked.success) {
+		const first = checked.issues[0];
+		throw new Error(`planAttempt: the delivery policy is not one to record — ${first?.message ?? "invalid"}` + (checked.issues.length > 1 ? ` (and ${checked.issues.length - 1} more)` : ""));
+	}
+	return resolveDeliveryPolicy(checked.data);
 }
+/** The scoring policy a plan records, as {@link frozenDelivery} records a delivery policy. */
 function frozenScoring(policy) {
-  if (policy === void 0 || policy === null) {
-    return void 0;
-  }
-  const checked = validateItemScoringPolicy(policy);
-  if (!checked.success) {
-    const first = checked.issues[0];
-    throw new Error(
-      `planAttempt: the scoring policy is not one to record \u2014 ${first?.message ?? "invalid"}` + (checked.issues.length > 1 ? ` (and ${checked.issues.length - 1} more)` : "")
-    );
-  }
-  return resolveItemScoringPolicy(checked.data);
+	if (policy === void 0 || policy === null) return;
+	const checked = validateItemScoringPolicy(policy);
+	if (!checked.success) {
+		const first = checked.issues[0];
+		throw new Error(`planAttempt: the scoring policy is not one to record — ${first?.message ?? "invalid"}` + (checked.issues.length > 1 ? ` (and ${checked.issues.length - 1} more)` : ""));
+	}
+	return resolveItemScoringPolicy(checked.data);
 }
 function missingOutcome(slot, policy) {
-  if (typeof policy === "function") {
-    return policy(slot);
-  }
-  if (policy === "zero") {
-    return { status: "scored", score: 0, maxScore: 1, passed: false, feedback: null, details: [] };
-  }
-  return { status: "deferred", reason: "no_response_recorded", maxScore: 1 };
+	if (typeof policy === "function") return policy(slot);
+	if (policy === "zero") return {
+		status: "scored",
+		score: 0,
+		maxScore: 1,
+		passed: false,
+		feedback: null,
+		details: []
+	};
+	return {
+		status: "deferred",
+		reason: "no_response_recorded",
+		maxScore: 1
+	};
 }
+/**
+* Turns a plan plus whatever outcomes exist into the `ScoredItem[]`
+* `composeAssessmentScore` consumes.
+*
+* The plan is the source of the denominator, not the outcomes. A slot the
+* learner never reached still has to appear — otherwise it silently leaves the
+* denominator and the remaining questions quietly become worth more than the
+* paper says.
+*
+* **A missing outcome defaults to `deferred`, never `unscorable`.** The
+* distinction decides a grade: `unscorable` means "a grade is never coming",
+* so `composeAssessmentScore` drops the slot from the denominator AND lets the
+* result go `final` — which turned a three-question paper with one answer into
+* a final, passing 100%. `deferred` means "not yet", which holds the result
+* `provisional` so nothing can be recorded. Pass `'zero'` once you know the
+* attempt was submitted and the blanks are genuinely blanks.
+*
+* Pass outcomes keyed by `slotId`. Keys the plan does not know are ignored:
+* a plan is the authority on what the attempt contained.
+*/
 function scoredItemsFromPlan(plan, outcomes, options = {}) {
-  const policy = options.missing ?? "deferred";
-  return plan.slots.map((slot) => ({
-    slotId: slot.slotId,
-    activityId: slot.activityId,
-    points: slot.points,
-    // `Object.hasOwn`, not a bare lookup: slot ids come from authored
-    // `slotKey`s, and a key of `constructor` or `toString` would otherwise
-    // resolve through the prototype chain and hand a FUNCTION to the scorer
-    // in place of an outcome.
-    outcome: Object.hasOwn(outcomes, slot.slotId) ? outcomes[slot.slotId] : missingOutcome(slot, policy)
-  }));
+	const policy = options.missing ?? "deferred";
+	return plan.slots.map((slot) => ({
+		slotId: slot.slotId,
+		activityId: slot.activityId,
+		points: slot.points,
+		outcome: Object.hasOwn(outcomes, slot.slotId) ? outcomes[slot.slotId] : missingOutcome(slot, policy)
+	}));
 }
-
-// src/attempt-state.ts
+//#endregion
+//#region src/attempt-state.ts
+/**
+* A DEEP copy of the responses.
+*
+* A one-level spread is not enough: every `LearnerResponse` shape is itself an
+* object (`selectedOptionIds`, `answers`, `text`), so a spread hands back a new
+* map of the caller's SAME response objects. A consumer whose reducer updates
+* an answer in place — an Immer draft, a push onto a multi-select, or
+* `answers[blankId] = text`, which is the natural update for that shape — then
+* mutates every snapshot ever taken. The stored snapshot retroactively becomes
+* the new answer, `diffResponses` sees no change, and a delta autosave writes
+* nothing for an edit the learner really made.
+*/
 function cloneResponses(responses) {
-  return typeof structuredClone === "function" ? structuredClone(responses) : JSON.parse(JSON.stringify(responses));
+	return typeof structuredClone === "function" ? structuredClone(responses) : JSON.parse(JSON.stringify(responses));
 }
+/** Slot ids present in the object but unknown to the plan. */
 function unknownKeys(plan, keys) {
-  const known = new Set(plan.slots.map((slot) => slot.slotId));
-  return keys.filter((key) => !known.has(key));
+	const known = new Set(plan.slots.map((slot) => slot.slotId));
+	return keys.filter((key) => !known.has(key));
 }
+/**
+* Captures an in-progress attempt as a storable snapshot, bound to its plan.
+*
+* Validated against the plan on the way in, not on the way out: a response
+* stored under a slot the paper does not contain is a bug at the moment it is
+* written, and finding it months later — when a learner tries to resume — is
+* finding it far too late.
+*
+* The SDK reads no clock: pass `savedAt` if you want the snapshot stamped, so
+* the function stays pure and its output stays reproducible in a test.
+*
+* @throws Error when a response or submitted slot is not in the plan, or when
+*         `index` is not a position the plan actually has.
+*/
 function serializeAttemptState(plan, progress) {
-  const responseKeys = Object.keys(progress.responses);
-  const submittedSlotIds = [...progress.submittedSlotIds ?? []];
-  const strayResponses = unknownKeys(plan, responseKeys);
-  if (strayResponses.length > 0) {
-    throw new Error(
-      `serializeAttemptState: response recorded for slot(s) the plan does not contain: ${strayResponses.join(", ")}. A response that belongs to no question cannot be scored and would be lost silently.`
-    );
-  }
-  const straySubmitted = unknownKeys(plan, submittedSlotIds);
-  if (straySubmitted.length > 0) {
-    throw new Error(
-      `serializeAttemptState: submitted slot(s) the plan does not contain: ${straySubmitted.join(", ")}.`
-    );
-  }
-  const index = progress.index ?? 0;
-  const lastIndex = Math.max(0, plan.slots.length - 1);
-  if (!Number.isInteger(index) || index < 0 || index > lastIndex) {
-    throw new Error(
-      `serializeAttemptState: index ${String(index)} is not a position in a ${plan.slots.length}-slot plan.`
-    );
-  }
-  return {
-    stateVersion: "1.0",
-    planHash: plan.planHash,
-    // Copied DEEPLY, not aliased: a snapshot that keeps mutating with the
-    // live attempt is not a snapshot. See cloneResponses.
-    responses: cloneResponses(progress.responses),
-    submittedSlotIds,
-    index,
-    ...progress.savedAt !== void 0 ? { savedAt: progress.savedAt } : {}
-  };
+	const responseKeys = Object.keys(progress.responses);
+	const submittedSlotIds = [...progress.submittedSlotIds ?? []];
+	const strayResponses = unknownKeys(plan, responseKeys);
+	if (strayResponses.length > 0) throw new Error(`serializeAttemptState: response recorded for slot(s) the plan does not contain: ${strayResponses.join(", ")}. A response that belongs to no question cannot be scored and would be lost silently.`);
+	const straySubmitted = unknownKeys(plan, submittedSlotIds);
+	if (straySubmitted.length > 0) throw new Error(`serializeAttemptState: submitted slot(s) the plan does not contain: ${straySubmitted.join(", ")}.`);
+	const index = progress.index ?? 0;
+	const lastIndex = Math.max(0, plan.slots.length - 1);
+	if (!Number.isInteger(index) || index < 0 || index > lastIndex) throw new Error(`serializeAttemptState: index ${String(index)} is not a position in a ${plan.slots.length}-slot plan.`);
+	return {
+		stateVersion: "1.0",
+		planHash: plan.planHash,
+		responses: cloneResponses(progress.responses),
+		submittedSlotIds,
+		index,
+		...progress.savedAt !== void 0 ? { savedAt: progress.savedAt } : {}
+	};
 }
+/**
+* Reopens a stored snapshot against a plan, refusing anything that does not
+* belong to it.
+*
+* The `planHash` check is the point. Slot ids are short and stable by design,
+* so a snapshot from a DIFFERENT paper — last term's midterm, a sibling
+* version, a copy-pasted attempt row — will happily line its answers up
+* against the wrong questions and look entirely plausible doing it. Comparing
+* the paper's fingerprint is what makes that impossible rather than unlikely.
+*
+* @throws Error when the snapshot belongs to a different plan, or references
+*         slots the plan does not contain.
+*/
 function restoreAttemptState(plan, state) {
-  if (state === null || typeof state !== "object") {
-    throw new Error("restoreAttemptState: the snapshot is not an object.");
-  }
-  if (state.stateVersion !== "1.0") {
-    throw new Error(
-      `restoreAttemptState: unsupported stateVersion ${JSON.stringify(state.stateVersion)}. This build understands "1.0"; a newer snapshot must be migrated before it is restored.`
-    );
-  }
-  if (state.responses === null || typeof state.responses !== "object") {
-    throw new Error(
-      "restoreAttemptState: the snapshot carries no responses object (a NULL column, or a partially written row)."
-    );
-  }
-  if (state.planHash !== plan.planHash) {
-    throw new Error(
-      `restoreAttemptState: this snapshot belongs to a different paper (snapshot ${state.planHash}, plan ${plan.planHash}). Restoring it would attach the learner's answers to questions they never saw.`
-    );
-  }
-  return serializeAttemptState(plan, {
-    responses: state.responses,
-    submittedSlotIds: state.submittedSlotIds,
-    index: state.index,
-    ...state.savedAt !== void 0 ? { savedAt: state.savedAt } : {}
-  });
+	if (state === null || typeof state !== "object") throw new Error("restoreAttemptState: the snapshot is not an object.");
+	if (state.stateVersion !== "1.0") throw new Error(`restoreAttemptState: unsupported stateVersion ${JSON.stringify(state.stateVersion)}. This build understands "1.0"; a newer snapshot must be migrated before it is restored.`);
+	if (state.responses === null || typeof state.responses !== "object") throw new Error("restoreAttemptState: the snapshot carries no responses object (a NULL column, or a partially written row).");
+	if (state.planHash !== plan.planHash) throw new Error(`restoreAttemptState: this snapshot belongs to a different paper (snapshot ${state.planHash}, plan ${plan.planHash}). Restoring it would attach the learner's answers to questions they never saw.`);
+	return serializeAttemptState(plan, {
+		responses: state.responses,
+		submittedSlotIds: state.submittedSlotIds,
+		index: state.index,
+		...state.savedAt !== void 0 ? { savedAt: state.savedAt } : {}
+	});
 }
+/**
+* Reports how two snapshots' responses differ, slot by slot.
+*
+* Useful for an autosave that should only write what moved, and for an audit
+* trail that has to show what a learner changed between two saves — including
+* an answer they cleared, which a naive comparison of the later snapshot
+* alone cannot see.
+*
+* Entries come back sorted by `slotId`, so the output is stable regardless of
+* the order the two objects happened to be written in.
+*/
 function diffResponses(before, after) {
-  const slotIds = [.../* @__PURE__ */ new Set([...Object.keys(before.responses), ...Object.keys(after.responses)])];
-  slotIds.sort();
-  const entries = [];
-  for (const slotId of slotIds) {
-    const had = Object.hasOwn(before.responses, slotId);
-    const has = Object.hasOwn(after.responses, slotId);
-    const from = before.responses[slotId];
-    const to = after.responses[slotId];
-    if (had && !has) {
-      entries.push({ slotId, change: "removed", ...from !== void 0 ? { before: from } : {} });
-      continue;
-    }
-    if (!had && has) {
-      entries.push({ slotId, change: "added", ...to !== void 0 ? { after: to } : {} });
-      continue;
-    }
-    if (canonicalJson(from) !== canonicalJson(to)) {
-      entries.push({
-        slotId,
-        change: "changed",
-        ...from !== void 0 ? { before: from } : {},
-        ...to !== void 0 ? { after: to } : {}
-      });
-    }
-  }
-  return entries;
+	const slotIds = [.../* @__PURE__ */ new Set([...Object.keys(before.responses), ...Object.keys(after.responses)])];
+	slotIds.sort();
+	const entries = [];
+	for (const slotId of slotIds) {
+		const had = Object.hasOwn(before.responses, slotId);
+		const has = Object.hasOwn(after.responses, slotId);
+		const from = before.responses[slotId];
+		const to = after.responses[slotId];
+		if (had && !has) {
+			entries.push({
+				slotId,
+				change: "removed",
+				...from !== void 0 ? { before: from } : {}
+			});
+			continue;
+		}
+		if (!had && has) {
+			entries.push({
+				slotId,
+				change: "added",
+				...to !== void 0 ? { after: to } : {}
+			});
+			continue;
+		}
+		if (canonicalJson(from) !== canonicalJson(to)) entries.push({
+			slotId,
+			change: "changed",
+			...from !== void 0 ? { before: from } : {},
+			...to !== void 0 ? { after: to } : {}
+		});
+	}
+	return entries;
 }
-
-// src/redact.ts
+//#endregion
+//#region src/redact.ts
+/** Merges per-call overrides over a registered policy, one level deep. */
 function mergePolicy(base, overrides) {
-  if (overrides === void 0) {
-    return base;
-  }
-  const merged = { ...base };
-  for (const [key, override] of Object.entries(overrides)) {
-    const current = merged[key];
-    merged[key] = typeof override === "object" && typeof current === "object" ? { ...current, ...override } : override;
-  }
-  return merged;
+	if (overrides === void 0) return base;
+	const merged = { ...base };
+	for (const [key, override] of Object.entries(overrides)) {
+		const current = merged[key];
+		merged[key] = typeof override === "object" && typeof current === "object" ? {
+			...current,
+			...override
+		} : override;
+	}
+	return merged;
 }
 function isSensitivity(value) {
-  return typeof value === "string";
+	return typeof value === "string";
 }
 function keepField(sensitivity, reveal) {
-  if (sensitivity === "public") {
-    return true;
-  }
-  return sensitivity === "answer-key" && reveal === "after-submit";
+	if (sensitivity === "public") return true;
+	return sensitivity === "answer-key" && reveal === "after-submit";
 }
+/** An object projection that kept no fields at all. Arrays are never dropped. */
 function isEmptyObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
 }
 function redactValue(value, policy, reveal) {
-  if (Array.isArray(value)) {
-    return value.map((element) => redactValue(element, policy, reveal));
-  }
-  if (value === null || typeof value !== "object") {
-    return void 0;
-  }
-  const source = value;
-  const output = {};
-  for (const [key, fieldValue] of Object.entries(source)) {
-    if (fieldValue === void 0) {
-      continue;
-    }
-    const classification = policy[key];
-    if (classification === void 0) {
-      continue;
-    }
-    if (isSensitivity(classification)) {
-      if (keepField(classification, reveal)) {
-        output[key] = fieldValue;
-      }
-      continue;
-    }
-    const nested = redactValue(fieldValue, classification, reveal);
-    if (nested !== void 0 && !isEmptyObject(nested)) {
-      output[key] = nested;
-    }
-  }
-  return output;
+	if (Array.isArray(value)) return value.map((element) => redactValue(element, policy, reveal));
+	if (value === null || typeof value !== "object") return;
+	const source = value;
+	const output = {};
+	for (const [key, fieldValue] of Object.entries(source)) {
+		if (fieldValue === void 0) continue;
+		const classification = policy[key];
+		if (classification === void 0) continue;
+		if (isSensitivity(classification)) {
+			if (keepField(classification, reveal)) output[key] = fieldValue;
+			continue;
+		}
+		const nested = redactValue(fieldValue, classification, reveal);
+		if (nested !== void 0 && !isEmptyObject(nested)) output[key] = nested;
+	}
+	return output;
 }
+/**
+* Produces the learner-safe projection of activity data (R7), driven by the
+* `fieldPolicy` registered for `data.type`. Fail-closed and exhaustive by
+* construction: a field the policy does not classify is removed — including
+* unknown passthrough fields — so a NEW field added by a future SDK or a
+* consumer sidecar can never leak through an out-of-date redactor.
+*
+* With the default `reveal: 'none'`, the output validates against the type's
+* strict redacted schema (verified here; an invalid projection throws
+* {@link ActivitySchemaError} rather than shipping an unproven payload).
+*
+* @throws UnknownActivityTypeError when `data.type` is not registered.
+* @throws Error when the registered descriptor declares no `fieldPolicy`
+*         (redaction cannot guess sensitivities).
+*/
 function redact(data, options = {}) {
-  const reveal = options.reveal ?? "none";
-  const descriptor = getActivityTypeDescriptor(data.type);
-  if (descriptor === void 0) {
-    throw new UnknownActivityTypeError(String(data.type));
-  }
-  if (descriptor.fieldPolicy === void 0) {
-    throw new Error(
-      `Activity type "${descriptor.type}" has no fieldPolicy; redact() cannot run fail-closed redaction without one.`
-    );
-  }
-  const effectivePolicy = mergePolicy(descriptor.fieldPolicy, options.policy);
-  const projected = redactValue(data, effectivePolicy, reveal);
-  const result = { ...projected, redacted: true };
-  if (reveal === "none" && descriptor.redactedSchema !== void 0) {
-    const parsed = readSchema(
-      descriptor.redactedSchema,
-      result,
-      `Activity type "${descriptor.type}"`
-    );
-    if (!parsed.success) {
-      throw new ActivitySchemaError(
-        descriptor.type,
-        parsed.issues.map((issue) => ({
-          path: issue.path.map(String),
-          message: issue.message,
-          code: issue.code
-        }))
-      );
-    }
-  }
-  return result;
+	const reveal = options.reveal ?? "none";
+	const descriptor = getActivityTypeDescriptor(data.type);
+	if (descriptor === void 0) throw new UnknownActivityTypeError(String(data.type));
+	if (descriptor.fieldPolicy === void 0) throw new Error(`Activity type "${descriptor.type}" has no fieldPolicy; redact() cannot run fail-closed redaction without one.`);
+	const result = {
+		...redactValue(data, mergePolicy(descriptor.fieldPolicy, options.policy), reveal),
+		redacted: true
+	};
+	if (reveal === "none" && descriptor.redactedSchema !== void 0) {
+		const parsed = readSchema(descriptor.redactedSchema, result, `Activity type "${descriptor.type}"`);
+		if (!parsed.success) throw new ActivitySchemaError(descriptor.type, parsed.issues.map((issue) => ({
+			path: issue.path.map(String),
+			message: issue.message,
+			code: issue.code
+		})));
+	}
+	return result;
 }
+/**
+* Asserts that `data` is a learner-safe redacted projection: it carries the
+* `redacted: true` marker and, when its type registers a strict redacted
+* schema, validates against it (proving the absence of answer-key fields).
+* Use this at the server boundary before sending activity data to a client
+* that must not hold the key.
+*/
 function assertRedacted(data) {
-  if (typeof data !== "object" || data === null) {
-    throw new ActivitySchemaError("unknown", [
-      { path: [], message: "Redacted activity data must be an object.", code: "invalid_type" }
-    ]);
-  }
-  const candidate = data;
-  if (candidate.redacted !== true) {
-    throw new ActivitySchemaError(String(candidate.type ?? "unknown"), [
-      {
-        path: ["redacted"],
-        message: "Missing redacted marker \u2014 this payload is not a redact() projection.",
-        code: "custom"
-      }
-    ]);
-  }
-  const type = typeof candidate.type === "string" ? candidate.type : "";
-  const descriptor = getActivityTypeDescriptor(type);
-  if (descriptor === void 0) {
-    throw new UnknownActivityTypeError(type);
-  }
-  if (descriptor.redactedSchema === void 0) {
-    throw new ActivitySchemaError(descriptor.type, [
-      {
-        path: [],
-        message: `Activity type "${descriptor.type}" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,
-        code: "custom"
-      }
-    ]);
-  }
-  const parsed = readSchema(
-    descriptor.redactedSchema,
-    candidate,
-    `Activity type "${descriptor.type}"`
-  );
-  if (!parsed.success) {
-    throw new ActivitySchemaError(
-      descriptor.type,
-      parsed.issues.map((issue) => ({
-        path: issue.path.map(String),
-        message: issue.message,
-        code: issue.code
-      }))
-    );
-  }
+	if (typeof data !== "object" || data === null) throw new ActivitySchemaError("unknown", [{
+		path: [],
+		message: "Redacted activity data must be an object.",
+		code: "invalid_type"
+	}]);
+	const candidate = data;
+	if (candidate.redacted !== true) throw new ActivitySchemaError(String(candidate.type ?? "unknown"), [{
+		path: ["redacted"],
+		message: "Missing redacted marker — this payload is not a redact() projection.",
+		code: "custom"
+	}]);
+	const type = typeof candidate.type === "string" ? candidate.type : "";
+	const descriptor = getActivityTypeDescriptor(type);
+	if (descriptor === void 0) throw new UnknownActivityTypeError(type);
+	if (descriptor.redactedSchema === void 0) throw new ActivitySchemaError(descriptor.type, [{
+		path: [],
+		message: `Activity type "${descriptor.type}" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,
+		code: "custom"
+	}]);
+	const parsed = readSchema(descriptor.redactedSchema, candidate, `Activity type "${descriptor.type}"`);
+	if (!parsed.success) throw new ActivitySchemaError(descriptor.type, parsed.issues.map((issue) => ({
+		path: issue.path.map(String),
+		message: issue.message,
+		code: issue.code
+	})));
 }
-var STIMULUS_FIELD_POLICY = {
-  id: "public",
-  kind: "public",
-  title: "public",
-  body: "public",
-  bodyHtml: "public",
-  media: MEDIA_FIELD_POLICY,
-  locale: "public",
-  attribution: "public",
-  transcript: "author-only"
-};
-var ITEM_GROUP_FIELD_POLICY = {
-  schemaVersion: "public",
-  type: "public",
-  id: "public",
-  title: "public",
-  // See the note on the built-in activity policies: a slot key is identity,
-  // and identity has to cross the redaction boundary intact.
-  slotKey: "public",
-  shuffle: "public",
-  stimulus: STIMULUS_FIELD_POLICY,
-  // Public, and classified key by key rather than as one leaf: the learner's
-  // player needs every part of it, none of it is a key — and a leaf would hand
-  // over the author's object by reference, with whatever else was parked in it.
-  timeline: {
-    // Applies to every element of the array.
-    cues: {
-      id: "public",
-      at: "public",
-      itemIds: "public",
-      title: "public",
-      required: "public"
-    },
-    chapters: {
-      at: "public",
-      title: "public"
-    },
-    navigation: "public"
-  }
+/** The group container's own fields. `items` is handled separately, per item type. */
+const ITEM_GROUP_FIELD_POLICY = {
+	schemaVersion: "public",
+	type: "public",
+	id: "public",
+	title: "public",
+	slotKey: "public",
+	shuffle: "public",
+	stimulus: {
+		id: "public",
+		kind: "public",
+		title: "public",
+		body: "public",
+		bodyHtml: "public",
+		media: MEDIA_FIELD_POLICY,
+		locale: "public",
+		attribution: "public",
+		transcript: "author-only"
+	},
+	timeline: {
+		cues: {
+			id: "public",
+			at: "public",
+			itemIds: "public",
+			title: "public",
+			required: "public"
+		},
+		chapters: {
+			at: "public",
+			title: "public"
+		},
+		navigation: "public"
+	}
 };
+/**
+* Produces the learner-safe projection of an item group: the container and
+* stimulus under their own fail-closed policy (the author transcript goes;
+* the passage, media and attribution stay — the learner is meant to see
+* them), and every item through {@link redact} with the same `options`, so
+* a per-call `policy` tightens each item exactly as it would alone.
+*
+* With the default `reveal: 'none'` the container is verified against the
+* strict redacted schema; each item was already verified by `redact`.
+*/
 function redactItemGroup(group, options = {}) {
-  const reveal = options.reveal ?? "none";
-  const { items, ...container } = group;
-  const projected = redactValue(container, ITEM_GROUP_FIELD_POLICY, reveal);
-  const result = {
-    ...projected,
-    items: items.map((item) => redact(item, options)),
-    redacted: true
-  };
-  if (reveal === "none") {
-    const parsed = RedactedItemGroupSchema.safeParse(result);
-    if (!parsed.success) {
-      throw new ActivitySchemaError(
-        "item-group",
-        parsed.error.issues.map((issue) => ({
-          path: issue.path.map(String),
-          message: issue.message,
-          code: issue.code
-        }))
-      );
-    }
-  }
-  return result;
+	const reveal = options.reveal ?? "none";
+	const { items, ...container } = group;
+	const result = {
+		...redactValue(container, ITEM_GROUP_FIELD_POLICY, reveal),
+		items: items.map((item) => redact(item, options)),
+		redacted: true
+	};
+	if (reveal === "none") {
+		const parsed = RedactedItemGroupSchema.safeParse(result);
+		if (!parsed.success) throw new ActivitySchemaError("item-group", parsed.error.issues.map((issue) => ({
+			path: issue.path.map(String),
+			message: issue.message,
+			code: issue.code
+		})));
+	}
+	return result;
 }
+/**
+* Asserts that `data` is a learner-safe item group: it carries the marker,
+* its container and stimulus satisfy the strict redacted schema (so no
+* transcript, no unclassified field), and EVERY item passes
+* {@link assertRedacted} against its own type's redacted schema. Item
+* failures are reported at `items.<index>.…`. Use it at the server boundary
+* before sending a group to a client that must not hold the key.
+*/
 function assertRedactedItemGroup(data) {
-  if (typeof data !== "object" || data === null) {
-    throw new ActivitySchemaError("item-group", [
-      { path: [], message: "Redacted item group must be an object.", code: "invalid_type" }
-    ]);
-  }
-  const candidate = data;
-  if (candidate.redacted !== true) {
-    throw new ActivitySchemaError("item-group", [
-      {
-        path: ["redacted"],
-        message: "Missing redacted marker \u2014 this payload is not a redactItemGroup() projection.",
-        code: "custom"
-      }
-    ]);
-  }
-  const parsed = RedactedItemGroupSchema.safeParse(candidate);
-  if (!parsed.success) {
-    throw new ActivitySchemaError(
-      "item-group",
-      parsed.error.issues.map((issue) => ({
-        path: issue.path.map(String),
-        message: issue.message,
-        code: issue.code
-      }))
-    );
-  }
-  parsed.data.items.forEach((item, index) => {
-    try {
-      assertRedacted(item);
-    } catch (error) {
-      if (error instanceof ActivitySchemaError) {
-        throw new ActivitySchemaError(
-          "item-group",
-          error.errors.map((issue) => ({
-            ...issue,
-            path: ["items", String(index), ...issue.path]
-          }))
-        );
-      }
-      throw error;
-    }
-  });
+	if (typeof data !== "object" || data === null) throw new ActivitySchemaError("item-group", [{
+		path: [],
+		message: "Redacted item group must be an object.",
+		code: "invalid_type"
+	}]);
+	const candidate = data;
+	if (candidate.redacted !== true) throw new ActivitySchemaError("item-group", [{
+		path: ["redacted"],
+		message: "Missing redacted marker — this payload is not a redactItemGroup() projection.",
+		code: "custom"
+	}]);
+	const parsed = RedactedItemGroupSchema.safeParse(candidate);
+	if (!parsed.success) throw new ActivitySchemaError("item-group", parsed.error.issues.map((issue) => ({
+		path: issue.path.map(String),
+		message: issue.message,
+		code: issue.code
+	})));
+	parsed.data.items.forEach((item, index) => {
+		try {
+			assertRedacted(item);
+		} catch (error) {
+			if (error instanceof ActivitySchemaError) throw new ActivitySchemaError("item-group", error.errors.map((issue) => ({
+				...issue,
+				path: [
+					"items",
+					String(index),
+					...issue.path
+				]
+			})));
+			throw error;
+		}
+	});
 }
-
-// src/timeline.ts
+//#endregion
+//#region src/timeline.ts
+/**
+* Reads a stored {@link MediaProgress}. Never throws: anything that is not one
+* — a string, a stale shape, an object whose getters throw — answers `null`,
+* and the player starts from the beginning.
+*
+* What it keeps, it clamps. A stored position is host storage, which is input
+* from a stranger by the time it is read back: a negative `at`, a `furthest`
+* behind `at`, or a position past the end of a video that has since been
+* re-cut must not put the playhead somewhere it cannot be. Give `duration`
+* once the video's metadata is known, and both positions are held inside it.
+*/
 function readMediaProgress(value, duration) {
-  let version;
-  let at;
-  let furthest;
-  try {
-    if (typeof value !== "object" || value === null) {
-      return null;
-    }
-    ({ progressVersion: version, at, furthest } = value);
-  } catch {
-    return null;
-  }
-  if (version !== "1.0" || typeof at !== "number" || !Number.isFinite(at)) {
-    return null;
-  }
-  const end = typeof duration === "number" && Number.isFinite(duration) && duration >= 0 ? duration : Number.POSITIVE_INFINITY;
-  const clampedAt = Math.min(Math.max(0, at), end);
-  const reached = typeof furthest === "number" && Number.isFinite(furthest) ? furthest : clampedAt;
-  return {
-    progressVersion: "1.0",
-    at: clampedAt,
-    furthest: Math.min(Math.max(clampedAt, reached), end)
-  };
+	let version;
+	let at;
+	let furthest;
+	try {
+		if (typeof value !== "object" || value === null) return null;
+		({progressVersion: version, at, furthest} = value);
+	} catch {
+		return null;
+	}
+	if (version !== "1.0" || typeof at !== "number" || !Number.isFinite(at)) return null;
+	const end = typeof duration === "number" && Number.isFinite(duration) && duration >= 0 ? duration : Number.POSITIVE_INFINITY;
+	const clampedAt = Math.min(Math.max(0, at), end);
+	return {
+		progressVersion: "1.0",
+		at: clampedAt,
+		furthest: Math.min(Math.max(clampedAt, typeof furthest === "number" && Number.isFinite(furthest) ? furthest : clampedAt), end)
+	};
 }
+/**
+* One interactive video's composed result: the scored items whose slot belongs
+* to the entry, composed as one section of weight 1. A slot belongs when
+* `entryKeyOf(item.slotId) === entryKey`, so a host can pass a whole attempt's
+* items and get the video's share of it.
+*
+* `entryKey` is the group's `slotKey` when it has one — which every published
+* video should — or its position in the sequence otherwise. A group object
+* alone cannot know its position, which is why this takes the key.
+*
+* @throws Error when no item belongs to the entry. A mistyped key would
+*         otherwise compose nothing into a `final` result, and a refusal must
+*         never read as a grade.
+*/
 function composeTimelineScore(entryKey, items, policy) {
-  const own = items.filter((item) => entryKeyOf(item.slotId) === entryKey);
-  if (own.length === 0) {
-    throw new Error(
-      `composeTimelineScore: no scored item belongs to entry "${entryKey}". Pass the video's slotKey (or its position in the sequence), and the items of the attempt that holds it.`
-    );
-  }
-  return composeAssessmentScore([{ id: entryKey, weight: 1, items: own }], policy);
+	const own = items.filter((item) => entryKeyOf(item.slotId) === entryKey);
+	if (own.length === 0) throw new Error(`composeTimelineScore: no scored item belongs to entry "${entryKey}". Pass the video's slotKey (or its position in the sequence), and the items of the attempt that holds it.`);
+	return composeAssessmentScore([{
+		id: entryKey,
+		weight: 1,
+		items: own
+	}], policy);
 }
-export {
-  AI_COACHING_MAX_TIP_LENGTH,
-  AI_COACHING_MAX_WORDS,
-  AI_CRITIQUE_MAX_FIELD_LENGTH,
-  AI_CRITIQUE_MAX_FINDINGS,
-  AI_DRAFTS_MAX_COUNT,
-  AI_DRAFTS_MAX_REPAIRS,
-  AI_EXPLANATION_TYPES,
-  AI_HINT_TYPES,
-  AI_TEXT_MAX_LENGTH,
-  AI_WRITING_MAX_CORRECTIONS,
-  AI_WRITING_MAX_FIELD_LENGTH,
-  ActivitySchemaError,
-  DEFAULT_ITEM_SCORING_POLICY,
-  DEFAULT_PASS_THRESHOLD,
-  DICTATION_MAX_ACCEPTED_TRANSCRIPTS,
-  DICTATION_MAX_EQUIVALENCES,
-  DICTATION_MAX_EQUIVALENCE_LENGTH,
-  DICTATION_MAX_TEXT_LENGTH,
-  DICTATION_MAX_TRANSCRIPT_LENGTH,
-  DeferredScoringError,
-  INTERACTIVE_VIDEO_ITEM_TYPES,
-  ITEM_SCORING_MAX_RETRIES,
-  OPEN_DELIVERY_POLICY,
-  READ_ALOUD_MAX_DIMENSION_WEIGHT,
-  READ_ALOUD_MAX_REFERENCE_LENGTH,
-  READ_ALOUD_MAX_SECONDS,
-  READ_ALOUD_MAX_TAKES,
-  RedactedScoringError,
-  SPEECH_ASSESSMENT_MAX_WORDS,
-  TIMELINE_MAX_CHAPTERS,
-  TIMELINE_MAX_ITEMS,
-  TIMELINE_MAX_QUIZZES,
-  TIMELINE_MAX_TITLE_LENGTH,
-  UnknownActivityTypeError,
-  XAPIVerb,
-  XAPI_VERB_DISPLAY,
-  aiAllowedByContent,
-  aiCoachingRequest,
-  aiCritiqueRequest,
-  aiDraftsRepairRequest,
-  aiDraftsRequest,
-  aiExplanationRequest,
-  aiGradeOf,
-  aiHintRequest,
-  aiSupports,
-  aiWritingFeedbackRequest,
-  alignDictation,
-  alignReadAloud,
-  assertRedacted,
-  assertRedactedItemGroup,
-  buildAiFacts,
-  canonicalJson,
-  checkAiCoaching,
-  checkAiCritique,
-  checkAiDrafts,
-  checkAiExplanation,
-  checkAiHint,
-  checkAiWritingFeedback,
-  classifyBand,
-  combineDeliveryPolicies,
-  composeAssessmentScore,
-  composeTimelineScore,
-  computePassThreshold,
-  contentHash,
-  countWords,
-  createDraft,
-  createInteractiveVideoDraft,
-  createItemGroupDraft,
-  critiqueDraft,
-  critiqueDrafts,
-  critiqueItemGroupDraft,
-  defineActivityType,
-  dictationJsonSchema,
-  dictationReferenceWords,
-  dictationType,
-  diffDictationChars,
-  diffResponses,
-  entryKeyOf,
-  evaluate,
-  evaluateTries,
-  fillInTheBlanksJsonSchema,
-  fillInTheBlanksType,
-  fingerprint,
-  flattenSequence,
-  gapSelectJsonSchema,
-  gapSelectType,
-  generateDrafts,
-  getActivityTypeDescriptor,
-  gradeFromRubric,
-  gradeReadAloud,
-  gte,
-  hasGrade,
-  hashSeed,
-  hintRevealsAnswer,
-  inspectWav,
-  interactiveVideoFromDrafts,
-  isInteractiveVideoItemType,
-  isItemGroup,
-  itemGroupJsonSchema,
-  jsonSchemaFor,
-  levenshteinDistance,
-  matchText,
-  multipleChoiceJsonSchema,
-  multipleChoiceType,
-  outcomeFromGrade,
-  outcomeFromUnscorable,
-  planAttempt,
-  planMediaBudgets,
-  readAiTextResult,
-  readAloudJsonSchema,
-  readAloudType,
-  readMediaProgress,
-  redact,
-  redactItemGroup,
-  registerActivityType,
-  registeredActivityTypes,
-  resolveDeliveryPolicy,
-  resolveItemScoringPolicy,
-  resolvePlaybackPolicy,
-  restoreAttemptState,
-  restoreMediaPlayLedger,
-  roundGrade,
-  score,
-  scoreTries,
-  scoredItemsFromPlan,
-  seededShuffle,
-  serializeAttemptState,
-  serializeMediaPlayLedger,
-  slotMediaKey,
-  stimulusJsonSchema,
-  stimulusMediaKey,
-  validateActivity,
-  validateDeliveryPolicy,
-  validateDraft,
-  validateItemGroup,
-  validateItemGroupDraft,
-  validateItemScoringPolicy,
-  validateMedia,
-  validateOptionMedia,
-  validateSpeechAssessment,
-  validateXAPIStatement,
-  verifyAttemptPlan,
-  writtenResponseJsonSchema,
-  writtenResponseType,
-  xAPIBuilder,
-  xapiDefinitionFor
-};
+//#endregion
+export { AI_COACHING_MAX_TIP_LENGTH, AI_COACHING_MAX_WORDS, AI_CRITIQUE_MAX_FIELD_LENGTH, AI_CRITIQUE_MAX_FINDINGS, AI_DRAFTS_MAX_COUNT, AI_DRAFTS_MAX_REPAIRS, AI_EXPLANATION_TYPES, AI_HINT_TYPES, AI_MATERIAL_MAX_LENGTH, AI_TEXT_MAX_LENGTH, AI_WRITING_MAX_CORRECTIONS, AI_WRITING_MAX_FIELD_LENGTH, ActivitySchemaError, BUILT_IN_ACTIVITY_TYPES, DEFAULT_ITEM_SCORING_POLICY, DEFAULT_PASS_THRESHOLD, DICTATION_MAX_ACCEPTED_TRANSCRIPTS, DICTATION_MAX_EQUIVALENCES, DICTATION_MAX_EQUIVALENCE_LENGTH, DICTATION_MAX_TEXT_LENGTH, DICTATION_MAX_TRANSCRIPT_LENGTH, DeferredScoringError, INTERACTIVE_VIDEO_ITEM_TYPES, ITEM_SCORING_MAX_RETRIES, OPEN_DELIVERY_POLICY, READ_ALOUD_MAX_DIMENSION_WEIGHT, READ_ALOUD_MAX_REFERENCE_LENGTH, READ_ALOUD_MAX_SECONDS, READ_ALOUD_MAX_TAKES, RedactedScoringError, SPEECH_ASSESSMENT_MAX_WORDS, TIMELINE_MAX_CHAPTERS, TIMELINE_MAX_ITEMS, TIMELINE_MAX_QUIZZES, TIMELINE_MAX_TITLE_LENGTH, UnknownActivityTypeError, XAPIVerb, XAPI_VERB_DISPLAY, aiAllowedByContent, aiCoachingRequest, aiCritiqueRequest, aiDraftsRepairRequest, aiDraftsRequest, aiExplanationRequest, aiGradeOf, aiHintRequest, aiSupports, aiWritingFeedbackRequest, alignDictation, alignReadAloud, assertRedacted, assertRedactedItemGroup, buildAiFacts, canonicalJson, checkAiCoaching, checkAiCritique, checkAiDrafts, checkAiExplanation, checkAiHint, checkAiWritingFeedback, classifyBand, combineDeliveryPolicies, composeAssessmentScore, composeTimelineScore, computePassThreshold, contentHash, countWords, createDraft, createInteractiveVideoDraft, createItemGroupDraft, critiqueDraft, critiqueDrafts, critiqueItemGroupDraft, defineActivityType, dictationJsonSchema, dictationReferenceWords, dictationType, diffDictationChars, diffResponses, entryKeyOf, evaluate, evaluateTries, fillInTheBlanksJsonSchema, fillInTheBlanksType, fingerprint, flattenSequence, gapSelectJsonSchema, gapSelectType, generateDrafts, getActivityTypeDescriptor, gradeFromRubric, gradeReadAloud, gte, hasGrade, hashSeed, hintRevealsAnswer, inspectWav, interactiveVideoFromDrafts, isBuiltInActivityType, isInteractiveVideoItemType, isItemGroup, itemGroupJsonSchema, jsonSchemaFor, levenshteinDistance, matchText, multipleChoiceJsonSchema, multipleChoiceType, outcomeFromGrade, outcomeFromUnscorable, planAttempt, planMediaBudgets, readAiTextResult, readAloudJsonSchema, readAloudType, readMediaProgress, redact, redactItemGroup, registerActivityType, registeredActivityTypes, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, restoreAttemptState, restoreMediaPlayLedger, roundGrade, score, scoreTries, scoredItemsFromPlan, seededShuffle, serializeAttemptState, serializeMediaPlayLedger, slotMediaKey, stimulusJsonSchema, stimulusMediaKey, validateActivity, validateDeliveryPolicy, validateDraft, validateItemGroup, validateItemGroupDraft, validateItemScoringPolicy, validateMedia, validateOptionMedia, validateSpeechAssessment, validateXAPIStatement, verifyAttemptPlan, writtenResponseJsonSchema, writtenResponseType, xAPIBuilder, xapiDefinitionFor };
+
 //# sourceMappingURL=index.js.map