@intellectif/lk-core 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1,1246 +1,1310 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-var _chunk46BXIGLGcjs = require('./chunk-46BXIGLG.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkCYCTIXUNcjs = require('./chunk-CYCTIXUN.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkMXI26H62cjs = require('./chunk-MXI26H62.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk4YANYTFNcjs = require('./chunk-4YANYTFN.cjs');
-
-
-
-
-
-
-
-
-
-var _chunkZWXQSKCXcjs = require('./chunk-ZWXQSKCX.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk7THXD7ANcjs = require('./chunk-7THXD7AN.cjs');
-
-// src/content-hash.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_registry = require("./registry-DVi0LR_i.cjs");
+const require_ai_writing = require("./ai-writing-DCVkv4Zj.cjs");
+const require_scoring = require("./scoring-B2_HEhMT.cjs");
+const require_item_group = require("./item-group-DroFXgLb.cjs");
+const require_schemas = require("./schemas-DVbAOrtd.cjs");
+const require_xapi = require("./xapi-DNzkSJ0S.cjs");
+//#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), _nullishCoalesce(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: _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _optionalChain([timeline, 'optionalAccess', _ => _.cues, 'access', _2 => _2.find, 'call', _3 => _3((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}.${_nullishCoalesce(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 = _nullishCoalesce(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 _optionalChain([p, 'optionalAccess', _4 => _4.maxPlays]) === "number";
-  const seek = _nullishCoalesce(_optionalChain([p, 'optionalAccess', _5 => _5.seek]), () => ( (budgeted ? "none" : "allow")));
-  const rate = _nullishCoalesce(_optionalChain([p, 'optionalAccess', _6 => _6.rate]), () => ( "allow"));
-  const controls = _nullishCoalesce(_optionalChain([p, 'optionalAccess', _7 => _7.controls]), () => ( (budgeted || seek === "none" || rate === "fixed" ? "minimal" : "native")));
-  return {
-    controls,
-    maxPlays: budgeted ? _optionalChain([p, 'optionalAccess', _8 => _8.maxPlays]) : null,
-    seek,
-    rate,
-    nativeControlHints: _nullishCoalesce(_optionalChain([p, 'optionalAccess', _9 => _9.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 _nullishCoalesce(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(_optionalChain([entry, 'optionalAccess', _10 => _10.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 = _optionalChain([slot, 'access', _11 => _11.group, 'optionalAccess', _12 => _12.stimulus, 'access', _13 => _13.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 = _nullishCoalesce(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, _nullishCoalesce(_optionalChain([points, 'optionalCall', _14 => _14(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(_nullishCoalesce(plan.delivery, () => ( null))) !== contentHash(_nullishCoalesce(current.delivery, () => ( null)));
-  const scoringChanged = contentHash(_nullishCoalesce(plan.scoring, () => ( null))) !== contentHash(_nullishCoalesce(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 (_optionalChain([now, 'access', _15 => _15.group, 'optionalAccess', _16 => _16.stimulusHash]) !== _optionalChain([slot, 'access', _17 => _17.group, 'optionalAccess', _18 => _18.stimulusHash])) {
-      changedStimulusSlotIds.push(slot.slotId);
-    }
-    if (contentHash(_nullishCoalesce(_optionalChain([now, 'access', _19 => _19.group, 'optionalAccess', _20 => _20.cue]), () => ( null))) !== contentHash(_nullishCoalesce(_optionalChain([slot, 'access', _21 => _21.group, 'optionalAccess', _22 => _22.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 ${_nullishCoalesce(_optionalChain([first, 'optionalAccess', _23 => _23.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 = _chunk4YANYTFNcjs.validateItemScoringPolicy.call(void 0, policy);
-  if (!checked.success) {
-    const first = checked.issues[0];
-    throw new Error(
-      `planAttempt: the scoring policy is not one to record \u2014 ${_nullishCoalesce(_optionalChain([first, 'optionalAccess', _24 => _24.message]), () => ( "invalid"))}` + (checked.issues.length > 1 ? ` (and ${checked.issues.length - 1} more)` : "")
-    );
-  }
-  return _chunk4YANYTFNcjs.resolveItemScoringPolicy.call(void 0, checked.data);
+	if (policy === void 0 || policy === null) return;
+	const checked = require_scoring.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 require_scoring.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 = _nullishCoalesce(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 = [..._nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(options.reveal, () => ( "none"));
-  const descriptor = _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, data.type);
-  if (descriptor === void 0) {
-    throw new (0, _chunk7THXD7ANcjs.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 = _chunk7THXD7ANcjs.readSchema.call(void 0, 
-      descriptor.redactedSchema,
-      result,
-      `Activity type "${descriptor.type}"`
-    );
-    if (!parsed.success) {
-      throw new (0, _chunk7THXD7ANcjs.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 = require_registry.getActivityTypeDescriptor(data.type);
+	if (descriptor === void 0) throw new require_registry.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 = require_registry.readSchema(descriptor.redactedSchema, result, `Activity type "${descriptor.type}"`);
+		if (!parsed.success) throw new require_registry.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 (0, _chunk7THXD7ANcjs.ActivitySchemaError)("unknown", [
-      { path: [], message: "Redacted activity data must be an object.", code: "invalid_type" }
-    ]);
-  }
-  const candidate = data;
-  if (candidate.redacted !== true) {
-    throw new (0, _chunk7THXD7ANcjs.ActivitySchemaError)(String(_nullishCoalesce(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 = _chunk7THXD7ANcjs.getActivityTypeDescriptor.call(void 0, type);
-  if (descriptor === void 0) {
-    throw new (0, _chunk7THXD7ANcjs.UnknownActivityTypeError)(type);
-  }
-  if (descriptor.redactedSchema === void 0) {
-    throw new (0, _chunk7THXD7ANcjs.ActivitySchemaError)(descriptor.type, [
-      {
-        path: [],
-        message: `Activity type "${descriptor.type}" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,
-        code: "custom"
-      }
-    ]);
-  }
-  const parsed = _chunk7THXD7ANcjs.readSchema.call(void 0, 
-    descriptor.redactedSchema,
-    candidate,
-    `Activity type "${descriptor.type}"`
-  );
-  if (!parsed.success) {
-    throw new (0, _chunk7THXD7ANcjs.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 require_registry.ActivitySchemaError("unknown", [{
+		path: [],
+		message: "Redacted activity data must be an object.",
+		code: "invalid_type"
+	}]);
+	const candidate = data;
+	if (candidate.redacted !== true) throw new require_registry.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 = require_registry.getActivityTypeDescriptor(type);
+	if (descriptor === void 0) throw new require_registry.UnknownActivityTypeError(type);
+	if (descriptor.redactedSchema === void 0) throw new require_registry.ActivitySchemaError(descriptor.type, [{
+		path: [],
+		message: `Activity type "${descriptor.type}" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,
+		code: "custom"
+	}]);
+	const parsed = require_registry.readSchema(descriptor.redactedSchema, candidate, `Activity type "${descriptor.type}"`);
+	if (!parsed.success) throw new require_registry.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: _chunk7THXD7ANcjs.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: require_registry.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 = _nullishCoalesce(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 = _chunkZWXQSKCXcjs.RedactedItemGroupSchema.safeParse(result);
-    if (!parsed.success) {
-      throw new (0, _chunk7THXD7ANcjs.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 = require_item_group.RedactedItemGroupSchema.safeParse(result);
+		if (!parsed.success) throw new require_registry.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 (0, _chunk7THXD7ANcjs.ActivitySchemaError)("item-group", [
-      { path: [], message: "Redacted item group must be an object.", code: "invalid_type" }
-    ]);
-  }
-  const candidate = data;
-  if (candidate.redacted !== true) {
-    throw new (0, _chunk7THXD7ANcjs.ActivitySchemaError)("item-group", [
-      {
-        path: ["redacted"],
-        message: "Missing redacted marker \u2014 this payload is not a redactItemGroup() projection.",
-        code: "custom"
-      }
-    ]);
-  }
-  const parsed = _chunkZWXQSKCXcjs.RedactedItemGroupSchema.safeParse(candidate);
-  if (!parsed.success) {
-    throw new (0, _chunk7THXD7ANcjs.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 _chunk7THXD7ANcjs.ActivitySchemaError) {
-        throw new (0, _chunk7THXD7ANcjs.ActivitySchemaError)(
-          "item-group",
-          error.errors.map((issue) => ({
-            ...issue,
-            path: ["items", String(index), ...issue.path]
-          }))
-        );
-      }
-      throw error;
-    }
-  });
+	if (typeof data !== "object" || data === null) throw new require_registry.ActivitySchemaError("item-group", [{
+		path: [],
+		message: "Redacted item group must be an object.",
+		code: "invalid_type"
+	}]);
+	const candidate = data;
+	if (candidate.redacted !== true) throw new require_registry.ActivitySchemaError("item-group", [{
+		path: ["redacted"],
+		message: "Missing redacted marker — this payload is not a redactItemGroup() projection.",
+		code: "custom"
+	}]);
+	const parsed = require_item_group.RedactedItemGroupSchema.safeParse(candidate);
+	if (!parsed.success) throw new require_registry.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 require_registry.ActivitySchemaError) throw new require_registry.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 (e) {
-    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 _chunk4YANYTFNcjs.composeAssessmentScore.call(void 0, [{ 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 require_scoring.composeAssessmentScore([{
+		id: entryKey,
+		weight: 1,
+		items: own
+	}], policy);
 }
+//#endregion
+exports.AI_COACHING_MAX_TIP_LENGTH = require_ai_writing.AI_COACHING_MAX_TIP_LENGTH;
+exports.AI_COACHING_MAX_WORDS = require_ai_writing.AI_COACHING_MAX_WORDS;
+exports.AI_CRITIQUE_MAX_FIELD_LENGTH = require_ai_writing.AI_CRITIQUE_MAX_FIELD_LENGTH;
+exports.AI_CRITIQUE_MAX_FINDINGS = require_ai_writing.AI_CRITIQUE_MAX_FINDINGS;
+exports.AI_DRAFTS_MAX_COUNT = require_ai_writing.AI_DRAFTS_MAX_COUNT;
+exports.AI_DRAFTS_MAX_REPAIRS = require_ai_writing.AI_DRAFTS_MAX_REPAIRS;
+exports.AI_EXPLANATION_TYPES = require_ai_writing.AI_EXPLANATION_TYPES;
+exports.AI_HINT_TYPES = require_ai_writing.AI_HINT_TYPES;
+exports.AI_TEXT_MAX_LENGTH = require_ai_writing.AI_TEXT_MAX_LENGTH;
+exports.AI_WRITING_MAX_CORRECTIONS = require_ai_writing.AI_WRITING_MAX_CORRECTIONS;
+exports.AI_WRITING_MAX_FIELD_LENGTH = require_ai_writing.AI_WRITING_MAX_FIELD_LENGTH;
+exports.ActivitySchemaError = require_registry.ActivitySchemaError;
+exports.BUILT_IN_ACTIVITY_TYPES = require_registry.BUILT_IN_ACTIVITY_TYPES;
+exports.DEFAULT_ITEM_SCORING_POLICY = require_scoring.DEFAULT_ITEM_SCORING_POLICY;
+exports.DEFAULT_PASS_THRESHOLD = require_scoring.DEFAULT_PASS_THRESHOLD;
+exports.DICTATION_MAX_ACCEPTED_TRANSCRIPTS = require_registry.DICTATION_MAX_ACCEPTED_TRANSCRIPTS;
+exports.DICTATION_MAX_EQUIVALENCES = require_registry.DICTATION_MAX_EQUIVALENCES;
+exports.DICTATION_MAX_EQUIVALENCE_LENGTH = require_registry.DICTATION_MAX_EQUIVALENCE_LENGTH;
+exports.DICTATION_MAX_TEXT_LENGTH = require_registry.DICTATION_MAX_TEXT_LENGTH;
+exports.DICTATION_MAX_TRANSCRIPT_LENGTH = require_registry.DICTATION_MAX_TRANSCRIPT_LENGTH;
+exports.DeferredScoringError = require_registry.DeferredScoringError;
+exports.INTERACTIVE_VIDEO_ITEM_TYPES = require_item_group.INTERACTIVE_VIDEO_ITEM_TYPES;
+exports.ITEM_SCORING_MAX_RETRIES = require_scoring.ITEM_SCORING_MAX_RETRIES;
+exports.OPEN_DELIVERY_POLICY = OPEN_DELIVERY_POLICY;
+exports.READ_ALOUD_MAX_DIMENSION_WEIGHT = require_registry.READ_ALOUD_MAX_DIMENSION_WEIGHT;
+exports.READ_ALOUD_MAX_REFERENCE_LENGTH = require_registry.READ_ALOUD_MAX_REFERENCE_LENGTH;
+exports.READ_ALOUD_MAX_SECONDS = require_registry.READ_ALOUD_MAX_SECONDS;
+exports.READ_ALOUD_MAX_TAKES = require_registry.READ_ALOUD_MAX_TAKES;
+exports.RedactedScoringError = require_registry.RedactedScoringError;
+exports.SPEECH_ASSESSMENT_MAX_WORDS = require_registry.SPEECH_ASSESSMENT_MAX_WORDS;
+exports.TIMELINE_MAX_CHAPTERS = require_item_group.TIMELINE_MAX_CHAPTERS;
+exports.TIMELINE_MAX_ITEMS = require_item_group.TIMELINE_MAX_ITEMS;
+exports.TIMELINE_MAX_QUIZZES = require_item_group.TIMELINE_MAX_QUIZZES;
+exports.TIMELINE_MAX_TITLE_LENGTH = require_item_group.TIMELINE_MAX_TITLE_LENGTH;
+exports.UnknownActivityTypeError = require_registry.UnknownActivityTypeError;
+exports.XAPIVerb = require_xapi.XAPIVerb;
+exports.XAPI_VERB_DISPLAY = require_xapi.XAPI_VERB_DISPLAY;
+exports.aiAllowedByContent = require_ai_writing.aiAllowedByContent;
+exports.aiCoachingRequest = require_ai_writing.aiCoachingRequest;
+exports.aiCritiqueRequest = require_ai_writing.aiCritiqueRequest;
+exports.aiDraftsRepairRequest = require_ai_writing.aiDraftsRepairRequest;
+exports.aiDraftsRequest = require_ai_writing.aiDraftsRequest;
+exports.aiExplanationRequest = require_ai_writing.aiExplanationRequest;
+exports.aiGradeOf = require_ai_writing.aiGradeOf;
+exports.aiHintRequest = require_ai_writing.aiHintRequest;
+exports.aiSupports = require_ai_writing.aiSupports;
+exports.aiWritingFeedbackRequest = require_ai_writing.aiWritingFeedbackRequest;
+exports.alignDictation = require_registry.alignDictation;
+exports.alignReadAloud = require_scoring.alignReadAloud;
+exports.assertRedacted = assertRedacted;
+exports.assertRedactedItemGroup = assertRedactedItemGroup;
+exports.buildAiFacts = require_ai_writing.buildAiFacts;
+exports.canonicalJson = canonicalJson;
+exports.checkAiCoaching = require_ai_writing.checkAiCoaching;
+exports.checkAiCritique = require_ai_writing.checkAiCritique;
+exports.checkAiDrafts = require_ai_writing.checkAiDrafts;
+exports.checkAiExplanation = require_ai_writing.checkAiExplanation;
+exports.checkAiHint = require_ai_writing.checkAiHint;
+exports.checkAiWritingFeedback = require_ai_writing.checkAiWritingFeedback;
+exports.classifyBand = require_scoring.classifyBand;
+exports.combineDeliveryPolicies = combineDeliveryPolicies;
+exports.composeAssessmentScore = require_scoring.composeAssessmentScore;
+exports.composeTimelineScore = composeTimelineScore;
+exports.computePassThreshold = require_scoring.computePassThreshold;
+exports.contentHash = contentHash;
+exports.countWords = require_registry.countWords;
+exports.createDraft = require_ai_writing.createDraft;
+exports.createInteractiveVideoDraft = require_ai_writing.createInteractiveVideoDraft;
+exports.createItemGroupDraft = require_ai_writing.createItemGroupDraft;
+exports.critiqueDraft = require_ai_writing.critiqueDraft;
+exports.critiqueDrafts = require_ai_writing.critiqueDrafts;
+exports.critiqueItemGroupDraft = require_ai_writing.critiqueItemGroupDraft;
+exports.defineActivityType = require_registry.defineActivityType;
+exports.dictationJsonSchema = require_schemas.dictationJsonSchema;
+exports.dictationReferenceWords = require_registry.dictationReferenceWords;
+exports.dictationType = require_registry.dictationType;
+exports.diffDictationChars = require_scoring.diffDictationChars;
+exports.diffResponses = diffResponses;
+exports.entryKeyOf = entryKeyOf;
+exports.evaluate = require_scoring.evaluate;
+exports.evaluateTries = require_scoring.evaluateTries;
+exports.fillInTheBlanksJsonSchema = require_schemas.fillInTheBlanksJsonSchema;
+exports.fillInTheBlanksType = require_registry.fillInTheBlanksType;
+exports.fingerprint = fingerprint;
+exports.flattenSequence = flattenSequence;
+exports.gapSelectJsonSchema = require_schemas.gapSelectJsonSchema;
+exports.gapSelectType = require_registry.gapSelectType;
+exports.generateDrafts = require_ai_writing.generateDrafts;
+exports.getActivityTypeDescriptor = require_registry.getActivityTypeDescriptor;
+exports.gradeFromRubric = require_scoring.gradeFromRubric;
+exports.gradeReadAloud = require_scoring.gradeReadAloud;
+exports.gte = require_scoring.gte;
+exports.hasGrade = require_scoring.hasGrade;
+exports.hashSeed = hashSeed;
+exports.hintRevealsAnswer = require_ai_writing.hintRevealsAnswer;
+exports.inspectWav = require_scoring.inspectWav;
+exports.interactiveVideoFromDrafts = require_ai_writing.interactiveVideoFromDrafts;
+exports.isBuiltInActivityType = require_registry.isBuiltInActivityType;
+exports.isInteractiveVideoItemType = require_item_group.isInteractiveVideoItemType;
+exports.isItemGroup = isItemGroup;
+exports.itemGroupJsonSchema = require_schemas.itemGroupJsonSchema;
+exports.jsonSchemaFor = require_schemas.jsonSchemaFor;
+exports.levenshteinDistance = require_registry.levenshteinDistance;
+exports.matchText = require_registry.matchText;
+exports.multipleChoiceJsonSchema = require_schemas.multipleChoiceJsonSchema;
+exports.multipleChoiceType = require_registry.multipleChoiceType;
+exports.outcomeFromGrade = require_scoring.outcomeFromGrade;
+exports.outcomeFromUnscorable = require_scoring.outcomeFromUnscorable;
+exports.planAttempt = planAttempt;
+exports.planMediaBudgets = planMediaBudgets;
+exports.readAiTextResult = require_ai_writing.readAiTextResult;
+exports.readAloudJsonSchema = require_schemas.readAloudJsonSchema;
+exports.readAloudType = require_registry.readAloudType;
+exports.readMediaProgress = readMediaProgress;
+exports.redact = redact;
+exports.redactItemGroup = redactItemGroup;
+exports.registerActivityType = require_registry.registerActivityType;
+exports.registeredActivityTypes = require_registry.registeredActivityTypes;
+exports.resolveDeliveryPolicy = resolveDeliveryPolicy;
+exports.resolveItemScoringPolicy = require_scoring.resolveItemScoringPolicy;
+exports.resolvePlaybackPolicy = resolvePlaybackPolicy;
+exports.restoreAttemptState = restoreAttemptState;
+exports.restoreMediaPlayLedger = restoreMediaPlayLedger;
+exports.roundGrade = require_scoring.roundGrade;
+exports.score = require_scoring.score;
+exports.scoreTries = require_scoring.scoreTries;
+exports.scoredItemsFromPlan = scoredItemsFromPlan;
+exports.seededShuffle = seededShuffle;
+exports.serializeAttemptState = serializeAttemptState;
+exports.serializeMediaPlayLedger = serializeMediaPlayLedger;
+exports.slotMediaKey = slotMediaKey;
+exports.stimulusJsonSchema = require_schemas.stimulusJsonSchema;
+exports.stimulusMediaKey = stimulusMediaKey;
+exports.validateActivity = require_schemas.validateActivity;
+exports.validateDeliveryPolicy = validateDeliveryPolicy;
+exports.validateDraft = require_ai_writing.validateDraft;
+exports.validateItemGroup = require_item_group.validateItemGroup;
+exports.validateItemGroupDraft = require_ai_writing.validateItemGroupDraft;
+exports.validateItemScoringPolicy = require_scoring.validateItemScoringPolicy;
+exports.validateMedia = require_schemas.validateMedia;
+exports.validateOptionMedia = require_schemas.validateOptionMedia;
+exports.validateSpeechAssessment = require_scoring.validateSpeechAssessment;
+exports.validateXAPIStatement = require_xapi.validateXAPIStatement;
+exports.verifyAttemptPlan = verifyAttemptPlan;
+exports.writtenResponseJsonSchema = require_schemas.writtenResponseJsonSchema;
+exports.writtenResponseType = require_registry.writtenResponseType;
+exports.xAPIBuilder = require_xapi.xAPIBuilder;
+exports.xapiDefinitionFor = require_xapi.xapiDefinitionFor;
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.AI_COACHING_MAX_TIP_LENGTH = _chunkMXI26H62cjs.AI_COACHING_MAX_TIP_LENGTH; exports.AI_COACHING_MAX_WORDS = _chunkMXI26H62cjs.AI_COACHING_MAX_WORDS; exports.AI_CRITIQUE_MAX_FIELD_LENGTH = _chunkMXI26H62cjs.AI_CRITIQUE_MAX_FIELD_LENGTH; exports.AI_CRITIQUE_MAX_FINDINGS = _chunkMXI26H62cjs.AI_CRITIQUE_MAX_FINDINGS; exports.AI_DRAFTS_MAX_COUNT = _chunkMXI26H62cjs.AI_DRAFTS_MAX_COUNT; exports.AI_DRAFTS_MAX_REPAIRS = _chunkMXI26H62cjs.AI_DRAFTS_MAX_REPAIRS; exports.AI_EXPLANATION_TYPES = _chunkMXI26H62cjs.AI_EXPLANATION_TYPES; exports.AI_HINT_TYPES = _chunkMXI26H62cjs.AI_HINT_TYPES; exports.AI_TEXT_MAX_LENGTH = _chunkMXI26H62cjs.AI_TEXT_MAX_LENGTH; exports.AI_WRITING_MAX_CORRECTIONS = _chunkMXI26H62cjs.AI_WRITING_MAX_CORRECTIONS; exports.AI_WRITING_MAX_FIELD_LENGTH = _chunkMXI26H62cjs.AI_WRITING_MAX_FIELD_LENGTH; exports.ActivitySchemaError = _chunk7THXD7ANcjs.ActivitySchemaError; exports.DEFAULT_ITEM_SCORING_POLICY = _chunk4YANYTFNcjs.DEFAULT_ITEM_SCORING_POLICY; exports.DEFAULT_PASS_THRESHOLD = _chunk4YANYTFNcjs.DEFAULT_PASS_THRESHOLD; exports.DICTATION_MAX_ACCEPTED_TRANSCRIPTS = _chunk7THXD7ANcjs.DICTATION_MAX_ACCEPTED_TRANSCRIPTS; exports.DICTATION_MAX_EQUIVALENCES = _chunk7THXD7ANcjs.DICTATION_MAX_EQUIVALENCES; exports.DICTATION_MAX_EQUIVALENCE_LENGTH = _chunk7THXD7ANcjs.DICTATION_MAX_EQUIVALENCE_LENGTH; exports.DICTATION_MAX_TEXT_LENGTH = _chunk7THXD7ANcjs.DICTATION_MAX_TEXT_LENGTH; exports.DICTATION_MAX_TRANSCRIPT_LENGTH = _chunk7THXD7ANcjs.DICTATION_MAX_TRANSCRIPT_LENGTH; exports.DeferredScoringError = _chunk7THXD7ANcjs.DeferredScoringError; exports.INTERACTIVE_VIDEO_ITEM_TYPES = _chunkZWXQSKCXcjs.INTERACTIVE_VIDEO_ITEM_TYPES; exports.ITEM_SCORING_MAX_RETRIES = _chunk4YANYTFNcjs.ITEM_SCORING_MAX_RETRIES; exports.OPEN_DELIVERY_POLICY = OPEN_DELIVERY_POLICY; exports.READ_ALOUD_MAX_DIMENSION_WEIGHT = _chunk7THXD7ANcjs.READ_ALOUD_MAX_DIMENSION_WEIGHT; exports.READ_ALOUD_MAX_REFERENCE_LENGTH = _chunk7THXD7ANcjs.READ_ALOUD_MAX_REFERENCE_LENGTH; exports.READ_ALOUD_MAX_SECONDS = _chunk7THXD7ANcjs.READ_ALOUD_MAX_SECONDS; exports.READ_ALOUD_MAX_TAKES = _chunk7THXD7ANcjs.READ_ALOUD_MAX_TAKES; exports.RedactedScoringError = _chunk7THXD7ANcjs.RedactedScoringError; exports.SPEECH_ASSESSMENT_MAX_WORDS = _chunk7THXD7ANcjs.SPEECH_ASSESSMENT_MAX_WORDS; exports.TIMELINE_MAX_CHAPTERS = _chunkZWXQSKCXcjs.TIMELINE_MAX_CHAPTERS; exports.TIMELINE_MAX_ITEMS = _chunkZWXQSKCXcjs.TIMELINE_MAX_ITEMS; exports.TIMELINE_MAX_QUIZZES = _chunkZWXQSKCXcjs.TIMELINE_MAX_QUIZZES; exports.TIMELINE_MAX_TITLE_LENGTH = _chunkZWXQSKCXcjs.TIMELINE_MAX_TITLE_LENGTH; exports.UnknownActivityTypeError = _chunk7THXD7ANcjs.UnknownActivityTypeError; exports.XAPIVerb = _chunk46BXIGLGcjs.XAPIVerb; exports.XAPI_VERB_DISPLAY = _chunk46BXIGLGcjs.XAPI_VERB_DISPLAY; exports.aiAllowedByContent = _chunkMXI26H62cjs.aiAllowedByContent; exports.aiCoachingRequest = _chunkMXI26H62cjs.aiCoachingRequest; exports.aiCritiqueRequest = _chunkMXI26H62cjs.aiCritiqueRequest; exports.aiDraftsRepairRequest = _chunkMXI26H62cjs.aiDraftsRepairRequest; exports.aiDraftsRequest = _chunkMXI26H62cjs.aiDraftsRequest; exports.aiExplanationRequest = _chunkMXI26H62cjs.aiExplanationRequest; exports.aiGradeOf = _chunkMXI26H62cjs.aiGradeOf; exports.aiHintRequest = _chunkMXI26H62cjs.aiHintRequest; exports.aiSupports = _chunkMXI26H62cjs.aiSupports; exports.aiWritingFeedbackRequest = _chunkMXI26H62cjs.aiWritingFeedbackRequest; exports.alignDictation = _chunk7THXD7ANcjs.alignDictation; exports.alignReadAloud = _chunk4YANYTFNcjs.alignReadAloud; exports.assertRedacted = assertRedacted; exports.assertRedactedItemGroup = assertRedactedItemGroup; exports.buildAiFacts = _chunkMXI26H62cjs.buildAiFacts; exports.canonicalJson = canonicalJson; exports.checkAiCoaching = _chunkMXI26H62cjs.checkAiCoaching; exports.checkAiCritique = _chunkMXI26H62cjs.checkAiCritique; exports.checkAiDrafts = _chunkMXI26H62cjs.checkAiDrafts; exports.checkAiExplanation = _chunkMXI26H62cjs.checkAiExplanation; exports.checkAiHint = _chunkMXI26H62cjs.checkAiHint; exports.checkAiWritingFeedback = _chunkMXI26H62cjs.checkAiWritingFeedback; exports.classifyBand = _chunk4YANYTFNcjs.classifyBand; exports.combineDeliveryPolicies = combineDeliveryPolicies; exports.composeAssessmentScore = _chunk4YANYTFNcjs.composeAssessmentScore; exports.composeTimelineScore = composeTimelineScore; exports.computePassThreshold = _chunk4YANYTFNcjs.computePassThreshold; exports.contentHash = contentHash; exports.countWords = _chunk7THXD7ANcjs.countWords; exports.createDraft = _chunkMXI26H62cjs.createDraft; exports.createInteractiveVideoDraft = _chunkMXI26H62cjs.createInteractiveVideoDraft; exports.createItemGroupDraft = _chunkMXI26H62cjs.createItemGroupDraft; exports.critiqueDraft = _chunkMXI26H62cjs.critiqueDraft; exports.critiqueDrafts = _chunkMXI26H62cjs.critiqueDrafts; exports.critiqueItemGroupDraft = _chunkMXI26H62cjs.critiqueItemGroupDraft; exports.defineActivityType = _chunk7THXD7ANcjs.defineActivityType; exports.dictationJsonSchema = _chunkCYCTIXUNcjs.dictationJsonSchema; exports.dictationReferenceWords = _chunk7THXD7ANcjs.dictationReferenceWords; exports.dictationType = _chunk7THXD7ANcjs.dictationType; exports.diffDictationChars = _chunk4YANYTFNcjs.diffDictationChars; exports.diffResponses = diffResponses; exports.entryKeyOf = entryKeyOf; exports.evaluate = _chunk4YANYTFNcjs.evaluate; exports.evaluateTries = _chunk4YANYTFNcjs.evaluateTries; exports.fillInTheBlanksJsonSchema = _chunkCYCTIXUNcjs.fillInTheBlanksJsonSchema; exports.fillInTheBlanksType = _chunk7THXD7ANcjs.fillInTheBlanksType; exports.fingerprint = fingerprint; exports.flattenSequence = flattenSequence; exports.gapSelectJsonSchema = _chunkCYCTIXUNcjs.gapSelectJsonSchema; exports.gapSelectType = _chunk7THXD7ANcjs.gapSelectType; exports.generateDrafts = _chunkMXI26H62cjs.generateDrafts; exports.getActivityTypeDescriptor = _chunk7THXD7ANcjs.getActivityTypeDescriptor; exports.gradeFromRubric = _chunk4YANYTFNcjs.gradeFromRubric; exports.gradeReadAloud = _chunk4YANYTFNcjs.gradeReadAloud; exports.gte = _chunk4YANYTFNcjs.gte; exports.hasGrade = _chunk4YANYTFNcjs.hasGrade; exports.hashSeed = hashSeed; exports.hintRevealsAnswer = _chunkMXI26H62cjs.hintRevealsAnswer; exports.inspectWav = _chunk4YANYTFNcjs.inspectWav; exports.interactiveVideoFromDrafts = _chunkMXI26H62cjs.interactiveVideoFromDrafts; exports.isInteractiveVideoItemType = _chunkZWXQSKCXcjs.isInteractiveVideoItemType; exports.isItemGroup = isItemGroup; exports.itemGroupJsonSchema = _chunkCYCTIXUNcjs.itemGroupJsonSchema; exports.jsonSchemaFor = _chunkCYCTIXUNcjs.jsonSchemaFor; exports.levenshteinDistance = _chunk7THXD7ANcjs.levenshteinDistance; exports.matchText = _chunk7THXD7ANcjs.matchText; exports.multipleChoiceJsonSchema = _chunkCYCTIXUNcjs.multipleChoiceJsonSchema; exports.multipleChoiceType = _chunk7THXD7ANcjs.multipleChoiceType; exports.outcomeFromGrade = _chunk4YANYTFNcjs.outcomeFromGrade; exports.outcomeFromUnscorable = _chunk4YANYTFNcjs.outcomeFromUnscorable; exports.planAttempt = planAttempt; exports.planMediaBudgets = planMediaBudgets; exports.readAiTextResult = _chunkMXI26H62cjs.readAiTextResult; exports.readAloudJsonSchema = _chunkCYCTIXUNcjs.readAloudJsonSchema; exports.readAloudType = _chunk7THXD7ANcjs.readAloudType; exports.readMediaProgress = readMediaProgress; exports.redact = redact; exports.redactItemGroup = redactItemGroup; exports.registerActivityType = _chunk7THXD7ANcjs.registerActivityType; exports.registeredActivityTypes = _chunk7THXD7ANcjs.registeredActivityTypes; exports.resolveDeliveryPolicy = resolveDeliveryPolicy; exports.resolveItemScoringPolicy = _chunk4YANYTFNcjs.resolveItemScoringPolicy; exports.resolvePlaybackPolicy = resolvePlaybackPolicy; exports.restoreAttemptState = restoreAttemptState; exports.restoreMediaPlayLedger = restoreMediaPlayLedger; exports.roundGrade = _chunk4YANYTFNcjs.roundGrade; exports.score = _chunk4YANYTFNcjs.score; exports.scoreTries = _chunk4YANYTFNcjs.scoreTries; exports.scoredItemsFromPlan = scoredItemsFromPlan; exports.seededShuffle = seededShuffle; exports.serializeAttemptState = serializeAttemptState; exports.serializeMediaPlayLedger = serializeMediaPlayLedger; exports.slotMediaKey = slotMediaKey; exports.stimulusJsonSchema = _chunkCYCTIXUNcjs.stimulusJsonSchema; exports.stimulusMediaKey = stimulusMediaKey; exports.validateActivity = _chunkCYCTIXUNcjs.validateActivity; exports.validateDeliveryPolicy = validateDeliveryPolicy; exports.validateDraft = _chunkMXI26H62cjs.validateDraft; exports.validateItemGroup = _chunkZWXQSKCXcjs.validateItemGroup; exports.validateItemGroupDraft = _chunkMXI26H62cjs.validateItemGroupDraft; exports.validateItemScoringPolicy = _chunk4YANYTFNcjs.validateItemScoringPolicy; exports.validateMedia = _chunkCYCTIXUNcjs.validateMedia; exports.validateOptionMedia = _chunkCYCTIXUNcjs.validateOptionMedia; exports.validateSpeechAssessment = _chunk4YANYTFNcjs.validateSpeechAssessment; exports.validateXAPIStatement = _chunk46BXIGLGcjs.validateXAPIStatement; exports.verifyAttemptPlan = verifyAttemptPlan; exports.writtenResponseJsonSchema = _chunkCYCTIXUNcjs.writtenResponseJsonSchema; exports.writtenResponseType = _chunk7THXD7ANcjs.writtenResponseType; exports.xAPIBuilder = _chunk46BXIGLGcjs.xAPIBuilder; exports.xapiDefinitionFor = _chunk46BXIGLGcjs.xapiDefinitionFor;
 //# sourceMappingURL=index.cjs.map