@intellectif/lk-core 1.10.0 → 1.11.0

package/dist/item-group-uNAT5EX5.js

@@ -0,0 +1,1338 @@
+import { $ as GROUP_CAPTIONS_REVEAL_DICTATION, B as countWords, Ct as passageWithoutPlaceholders, Mt as maxUnits, Ot as MediaSchema, St as numberedPassage, Tt as revealsAnswer, a as readSchema, bt as containsWords, et as groupCaptionsField, jt as ScriptSchema, kt as RedactedMediaSchema, t as getActivityTypeDescriptor, wt as placeholderOrder, xt as fold$1 } from "./registry-kTqbi4Lb.js";
+import * as z from "zod/v4";
+// src/reading-route/layout.ts
+/** Names the segmentation rules below. A change to them is a new name. */
+const ROUTE_SEGMENTER = "lk-sentences@1";
+const TERMINALS = /* @__PURE__ */ new Set([
+	".",
+	"!",
+	"?",
+	"…",
+	"‼",
+	"⁇",
+	"⁈",
+	"⁉"
+]);
+/** Terminals of scripts written without spaces: a sentence ends at them outright. */
+const CLOSED_TERMINALS = /* @__PURE__ */ new Set([
+	"。",
+	"！",
+	"？",
+	"｡"
+]);
+const CLOSERS = /* @__PURE__ */ new Set([
+	"\"",
+	"'",
+	"”",
+	"’",
+	")",
+	"]",
+	"}",
+	"»",
+	"›",
+	"」",
+	"』",
+	"）"
+]);
+/**
+* Words a full stop follows without ending a sentence. Lower case, without
+* their dots. `etc` is not one: it ends sentences as often as not, and a
+* capital after it says which.
+*/
+const ABBREVIATIONS = /* @__PURE__ */ new Set([
+	"mr",
+	"mrs",
+	"ms",
+	"dr",
+	"prof",
+	"sr",
+	"jr",
+	"st",
+	"mt",
+	"vs",
+	"fig",
+	"figs",
+	"vol",
+	"approx",
+	"ca",
+	"cf",
+	"eg",
+	"ie",
+	"inc",
+	"ltd",
+	"co",
+	"corp",
+	"jan",
+	"feb",
+	"mar",
+	"apr",
+	"jun",
+	"jul",
+	"aug",
+	"sep",
+	"sept",
+	"oct",
+	"nov",
+	"dec",
+	"gen",
+	"gov",
+	"rev",
+	"ed",
+	"eds",
+	"pp",
+	"no"
+]);
+const isSpace = (char) => char !== void 0 && /\s/u.test(char);
+const isLower = (char) => char !== void 0 && /\p{Ll}/u.test(char);
+/** The word before a full stop at `dot`, letters and inner dots only ("e.g", "U.S"). */
+function wordBefore(text, dot) {
+	let start = dot;
+	while (start > 0 && /[\p{L}.]/u.test(text[start - 1])) start -= 1;
+	return text.slice(start, dot);
+}
+/** Whether the full stop at `dot` follows an abbreviation or an initial ("J. K.", "U.S."). */
+function abbreviated(text, dot) {
+	const word = wordBefore(text, dot);
+	if (word === "") return false;
+	const last = word.split(".").at(-1);
+	if (last.length === 1 && /\p{Lu}/u.test(last)) return true;
+	return ABBREVIATIONS.has(word.replaceAll(".", "").toLowerCase());
+}
+/** `range` with whitespace trimmed off both ends; `null` when nothing is left. */
+function trimmed(text, start, end) {
+	let from = start;
+	let to = end;
+	while (from < to && isSpace(text[from])) from += 1;
+	while (to > from && isSpace(text[to - 1])) to -= 1;
+	return from < to ? {
+		start: from,
+		end: to
+	} : null;
+}
+/** The sentences of `text.slice(start, end)`: one paragraph. A line break always ends one. */
+function sentencesIn(text, start, end) {
+	const found = [];
+	let from = start;
+	const close = (to, next) => {
+		const range = trimmed(text, from, to);
+		if (range !== null) found.push(range);
+		from = next;
+	};
+	let index = start;
+	while (index < end) {
+		const char = text[index];
+		if (char === "\n") {
+			close(index, index + 1);
+			index += 1;
+			continue;
+		}
+		if (CLOSED_TERMINALS.has(char)) {
+			let after = index + 1;
+			while (after < end && CLOSERS.has(text[after])) after += 1;
+			close(after, after);
+			index = after;
+			continue;
+		}
+		if (!TERMINALS.has(char)) {
+			index += 1;
+			continue;
+		}
+		let after = index + 1;
+		while (after < end && TERMINALS.has(text[after])) after += 1;
+		while (after < end && CLOSERS.has(text[after])) after += 1;
+		if (after >= end) {
+			close(end, end);
+			index = end;
+			continue;
+		}
+		if (!isSpace(text[after])) {
+			index = after;
+			continue;
+		}
+		let next = after;
+		while (next < end && text[next] !== "\n" && isSpace(text[next])) next += 1;
+		if (!(isLower(text[next]) || char === "." && after === index + 1 && abbreviated(text, index))) close(after, after);
+		index = after;
+	}
+	close(end, end);
+	return found;
+}
+/** The paragraphs of `body`: runs of text between blank lines. */
+function paragraphRanges(body) {
+	const ranges = [];
+	const blank = /\n[^\S\n]*\n\s*/gu;
+	let from = 0;
+	for (const match of body.matchAll(blank)) {
+		const range = trimmed(body, from, match.index);
+		if (range !== null) ranges.push(range);
+		from = match.index + match[0].length;
+	}
+	const last = trimmed(body, from, body.length);
+	if (last !== null) ranges.push(last);
+	return ranges;
+}
+/** How many paragraphs `body` has, by the rules {@link passageLayout} uses. */
+function countParagraphs(body) {
+	return paragraphRanges(body).length;
+}
+/**
+* The passage cut into paragraphs and sentences. Paragraph labels and sections
+* are applied when they fit; the checks report when they do not.
+*/
+function passageLayout(body, route) {
+	const ranges = paragraphRanges(body);
+	const labels = route?.paragraphLabels;
+	const sectionList = route?.sections ?? [];
+	const sections = [];
+	const sectionOf = [];
+	if (sectionList.reduce((total, section) => total + section.paragraphs, 0) === ranges.length) {
+		let first = 0;
+		sectionList.forEach((section, index) => {
+			const last = first + section.paragraphs - 1;
+			sections.push({
+				label: section.label,
+				...section.title !== void 0 ? { title: section.title } : {},
+				first,
+				last
+			});
+			for (let paragraph = first; paragraph <= last; paragraph += 1) sectionOf[paragraph] = index;
+			first = last + 1;
+		});
+	}
+	const labelled = labels !== void 0 && labels.length === ranges.length;
+	const paragraphs = [];
+	const sentences = [];
+	ranges.forEach((range, index) => {
+		const label = labelled ? labels[index] : "";
+		const section = sectionOf[index];
+		paragraphs.push({
+			index,
+			start: range.start,
+			end: range.end,
+			...label !== "" ? { label } : {},
+			...section !== void 0 ? { section } : {}
+		});
+		for (const sentence of sentencesIn(body, range.start, range.end)) sentences.push({
+			index: sentences.length,
+			paragraph: index,
+			...sentence
+		});
+	});
+	return {
+		paragraphs,
+		sentences,
+		sections
+	};
+}
+/** Whether two ranges share at least one character. */
+function overlaps(a, b) {
+	return a.start < b.end && b.start < a.end;
+}
+/** The sentences a range touches, in order. */
+function sentencesTouching(layout, range) {
+	return layout.sentences.filter((sentence) => overlaps(sentence, range)).map((s) => s.index);
+}
+// src/reading-route/questions.ts
+/**
+* The questions of a routed group, read off its items: one per multiple-choice
+* item, one per blank or gap of the others, numbered as on the paper. Read
+* defensively, because the checks run on drafts and on redacted items.
+*/
+const isFields$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (value) => typeof value === "string" ? value : "";
+const list$1 = (value) => Array.isArray(value) ? value.filter(isFields$1) : [];
+/** `itemId`, or `itemId#partId`: a question's name in traces and summaries. */
+function questionKey(itemId, partId) {
+	return partId === void 0 ? itemId : `${itemId}#${partId}`;
+}
+/** The ids of an item's parts in passage order: its blanks or gaps, or none for multiple choice. */
+function partIdsOf(item) {
+	if (!isFields$1(item)) return null;
+	if (item.type === "multiple-choice") return null;
+	const declared = list$1(item.type === "gap-select" ? item.gaps : item.blanks).map((part) => part.id).filter((id) => typeof id === "string" && id !== "");
+	const order = placeholderOrder(text(item.passage)).filter((id) => declared.includes(id));
+	const rest = declared.filter((id) => !order.includes(id));
+	return [.../* @__PURE__ */ new Set([...order, ...rest])];
+}
+/** Every question of the group's items, in paper order. */
+function itemQuestions(items) {
+	const found = [];
+	items.forEach((item, itemIndex) => {
+		if (!isFields$1(item) || typeof item.id !== "string") return;
+		const type = text(item.type);
+		const parts = partIdsOf(item);
+		if (parts === null) {
+			found.push({
+				key: questionKey(item.id),
+				itemId: item.id,
+				itemIndex,
+				position: found.length,
+				type
+			});
+			return;
+		}
+		for (const partId of parts) found.push({
+			key: questionKey(item.id, partId),
+			itemId: item.id,
+			partId,
+			itemIndex,
+			position: found.length,
+			type
+		});
+	});
+	return found;
+}
+/** What the learner reads of an item: its instructions, question or passage, and its options or choices. */
+function learnerTextOf(item) {
+	if (!isFields$1(item)) return "";
+	const parts = [text(item.instructions)];
+	if (item.type === "multiple-choice") parts.push(text(item.question), ...list$1(item.options).map((option) => text(option.text)));
+	else {
+		parts.push(passageWithoutPlaceholders(text(item.passage)));
+		for (const gap of list$1(item.gaps)) parts.push(...list$1(gap.choices).map((choice) => text(choice.text)));
+		for (const bank of list$1(item.banks)) parts.push(...list$1(bank.choices).map((choice) => text(choice.text)));
+	}
+	return parts.filter((part) => part !== "").join("\n");
+}
+/** The options or choices a question offers, by id, with their text and whether each is right. */
+function choicesOf(item, partId) {
+	if (!isFields$1(item)) return [];
+	if (item.type === "multiple-choice") return list$1(item.options).filter((option) => typeof option.id === "string").map((option) => ({
+		id: option.id,
+		text: text(option.text),
+		correct: option.isCorrect === true
+	}));
+	if (item.type !== "gap-select") return [];
+	const gap = list$1(item.gaps).find((candidate) => candidate.id === partId);
+	if (gap === void 0) return [];
+	const bank = list$1(item.banks).find((candidate) => candidate.id === gap.bankId);
+	return (gap.choices !== void 0 ? list$1(gap.choices) : list$1(bank?.choices)).filter((choice) => typeof choice.id === "string").map((choice) => ({
+		id: choice.id,
+		text: text(choice.text),
+		correct: choice.id === gap.correctChoiceId
+	}));
+}
+/** The accepted answers of a blank. */
+function acceptedAnswersOf(item, partId) {
+	if (!isFields$1(item) || item.type !== "fill-in-the-blanks") return [];
+	const blank = list$1(item.blanks).find((candidate) => candidate.id === partId);
+	return Array.isArray(blank?.acceptedAnswers) ? blank.acceptedAnswers.filter((answer) => typeof answer === "string") : [];
+}
+/** 1-based position of a blank or gap among its item's placeholders, for the leak check. */
+function placeholderPosition(item, partId) {
+	if (!isFields$1(item) || partId === void 0) return;
+	const index = placeholderOrder(text(item.passage)).indexOf(partId);
+	return index === -1 ? void 0 : index + 1;
+}
+// src/reading-route/quotes.ts
+const FOLDED = {
+	"‘": "'",
+	"’": "'",
+	"‛": "'",
+	"′": "'",
+	"“": "\"",
+	"”": "\"",
+	"„": "\"",
+	"″": "\""
+};
+function fold(text) {
+	let folded = "";
+	const origin = [];
+	let space = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (/\s/u.test(char)) {
+			if (!space && folded !== "") {
+				folded += " ";
+				origin.push(index);
+			}
+			space = true;
+			continue;
+		}
+		space = false;
+		folded += FOLDED[char] ?? char;
+		origin.push(index);
+	}
+	if (folded.endsWith(" ")) {
+		folded = folded.slice(0, -1);
+		origin.pop();
+	}
+	return {
+		text: folded,
+		origin
+	};
+}
+/** The text of a quote, whichever form it takes. Non-strings read as empty. */
+function quoteText(quote) {
+	if (typeof quote === "string") return quote;
+	if (typeof quote === "object" && quote !== null && typeof quote.text === "string") return quote.text;
+	return "";
+}
+function occurrenceOf(quote) {
+	if (typeof quote !== "object" || quote === null) return;
+	const occurrence = quote.occurrence;
+	return typeof occurrence === "number" ? occurrence : void 0;
+}
+/**
+* Where `quote` is in `body`. Every occurrence is counted, overlapping ones
+* included, so "a a" in "a a a" is ambiguous rather than silently the first.
+*/
+function findQuote(body, quote) {
+	const needle = fold(quoteText(quote)).text;
+	if (needle === "") return {
+		found: false,
+		reason: "empty",
+		count: 0
+	};
+	const hay = fold(body);
+	const starts = [];
+	let at = hay.text.indexOf(needle);
+	while (at !== -1) {
+		starts.push(at);
+		at = hay.text.indexOf(needle, at + 1);
+	}
+	if (starts.length === 0) return {
+		found: false,
+		reason: "missing",
+		count: 0
+	};
+	const occurrence = occurrenceOf(quote);
+	if (occurrence === void 0 && starts.length > 1) return {
+		found: false,
+		reason: "ambiguous",
+		count: starts.length
+	};
+	const chosen = starts[(occurrence ?? 1) - 1];
+	if (chosen === void 0) return {
+		found: false,
+		reason: "occurrence",
+		count: starts.length
+	};
+	return {
+		found: true,
+		range: {
+			start: hay.origin[chosen],
+			end: hay.origin[chosen + needle.length - 1] + 1
+		}
+	};
+}
+/** Whether `phrase` occurs in `text`, by the same folding as quotes, ignoring case. */
+function containsPhrase(text, phrase) {
+	const needle = fold(phrase).text.toLowerCase();
+	return needle !== "" && fold(text).text.toLowerCase().includes(needle);
+}
+// src/reading-route/strategies.ts
+/**
+* The item types a reading route may hold: the three that every common exam
+* reading task is written in. CLOSED on purpose, as an interactive video's
+* list is: a type added later is not silently routable.
+*/
+const READING_ROUTE_ITEM_TYPES = [
+	"multiple-choice",
+	"fill-in-the-blanks",
+	"gap-select"
+];
+/** Whether `type` is one of the item types a reading route may hold. */
+function isReadingRouteItemType(type) {
+	return READING_ROUTE_ITEM_TYPES.includes(type);
+}
+const CHOICE = ["multiple-choice", "gap-select"];
+/**
+* The built-in strategies. Data, versioned with lk-core: a route stores only
+* a strategy's id, so a learner always meets the current steps.
+*/
+const ROUTE_STRATEGIES = Object.freeze({
+	tfng: {
+		id: "tfng",
+		title: "True / False / Not Given",
+		serves: "IELTS identifying information.",
+		itemTypes: CHOICE,
+		moves: [
+			"read-instructions",
+			"keywords",
+			"locate",
+			"read-around",
+			"paraphrase",
+			"decide"
+		],
+		followsOrder: true
+	},
+	ynng: {
+		id: "ynng",
+		title: "Yes / No / Not Given",
+		serves: "IELTS identifying the writer's views or claims.",
+		itemTypes: CHOICE,
+		moves: [
+			"read-instructions",
+			"keywords",
+			"locate",
+			"read-around",
+			"paraphrase",
+			"decide"
+		],
+		followsOrder: true
+	},
+	"multiple-choice": {
+		id: "multiple-choice",
+		title: "Multiple choice",
+		serves: "IELTS multiple choice; Cambridge C1 Advanced and C2 Proficiency Part 5.",
+		itemTypes: ["multiple-choice"],
+		moves: [
+			"keywords",
+			"predict",
+			"locate",
+			"read-around",
+			"paraphrase",
+			"eliminate"
+		],
+		followsOrder: true
+	},
+	"matching-headings": {
+		id: "matching-headings",
+		title: "Matching headings",
+		serves: "IELTS matching headings.",
+		itemTypes: CHOICE,
+		moves: [
+			"survey",
+			"locate",
+			"paraphrase",
+			"eliminate"
+		],
+		followsOrder: false
+	},
+	"matching-information": {
+		id: "matching-information",
+		title: "Matching information",
+		serves: "IELTS matching information (\"Which paragraph contains...\").",
+		itemTypes: CHOICE,
+		moves: [
+			"keywords",
+			"locate",
+			"read-around",
+			"paraphrase"
+		],
+		followsOrder: false
+	},
+	"matching-features": {
+		id: "matching-features",
+		title: "Matching features",
+		serves: "IELTS matching features (people, dates, places to statements).",
+		itemTypes: CHOICE,
+		moves: [
+			"keywords",
+			"locate",
+			"read-around",
+			"paraphrase"
+		],
+		followsOrder: false
+	},
+	"multiple-matching": {
+		id: "multiple-matching",
+		title: "Multiple matching",
+		serves: "Cambridge C1 Advanced Part 8 and C2 Proficiency Part 7.",
+		itemTypes: CHOICE,
+		moves: [
+			"survey",
+			"keywords",
+			"locate",
+			"read-around",
+			"paraphrase"
+		],
+		followsOrder: false
+	},
+	"sentence-endings": {
+		id: "sentence-endings",
+		title: "Matching sentence endings",
+		serves: "IELTS matching sentence endings.",
+		itemTypes: CHOICE,
+		moves: [
+			"keywords",
+			"predict",
+			"locate",
+			"read-around",
+			"eliminate"
+		],
+		followsOrder: true
+	},
+	completion: {
+		id: "completion",
+		title: "Completion",
+		serves: "IELTS sentence, note, table and flow-chart completion, and short answers.",
+		itemTypes: ["fill-in-the-blanks"],
+		moves: [
+			"read-instructions",
+			"keywords",
+			"predict",
+			"locate",
+			"read-around",
+			"check-answer"
+		],
+		followsOrder: true
+	},
+	"summary-word-list": {
+		id: "summary-word-list",
+		title: "Summary completion from a list",
+		serves: "IELTS summary completion with a list of words.",
+		itemTypes: ["gap-select"],
+		moves: [
+			"keywords",
+			"predict",
+			"locate",
+			"read-around",
+			"paraphrase",
+			"check-answer"
+		],
+		followsOrder: false
+	},
+	"gapped-text": {
+		id: "gapped-text",
+		title: "Gapped text",
+		serves: "Cambridge C1 Advanced Part 7 and C2 Proficiency Part 6.",
+		itemTypes: CHOICE,
+		moves: [
+			"survey",
+			"locate",
+			"cohesion",
+			"eliminate"
+		],
+		followsOrder: false
+	},
+	"cross-text": {
+		id: "cross-text",
+		title: "Cross-text matching",
+		serves: "Cambridge C1 Advanced Part 6.",
+		itemTypes: CHOICE,
+		moves: [
+			"survey",
+			"keywords",
+			"locate",
+			"compare-views"
+		],
+		followsOrder: false
+	}
+});
+/** Every built-in strategy id, in the library's order. */
+const ROUTE_STRATEGY_IDS = Object.freeze(Object.keys(ROUTE_STRATEGIES));
+/** Whether `id` names a built-in strategy. */
+function isRouteStrategyId(id) {
+	return typeof id === "string" && Object.hasOwn(ROUTE_STRATEGIES, id);
+}
+/** The most characters an author's note on a step may have. */
+const ROUTE_NOTE_MAX_LENGTH = 280;
+/** The longest word limit a completion question may set. */
+const ROUTE_WORD_LIMIT_MAX = 10;
+// src/reading-route/check.ts
+/**
+* The rules a reading route keeps, beyond its shape: every question of the
+* group has exactly one entry, every quote is in the passage once, the words
+* an author adds never give the answer away, and the strategy fits the item.
+*
+* One list of rules serves the stored schema (every rule refuses) and the
+* draft checks (each code with its own severity), so the two cannot drift.
+* Read defensively: drafts and redacted groups reach it as they are.
+*/
+const isFields = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unset = (value) => value === void 0 || value === null || typeof value === "string" && value.trim() === "";
+const list = (value) => Array.isArray(value) ? value : [];
+/**
+* Whether an author's note gives a question's answer away. For a choice, a
+* note that names the right option and not every other one; naming them all —
+* "True if it agrees, False if it contradicts, Not Given if it is silent" — is
+* the rule, not the answer.
+*/
+function noteRevealsAnswer(item, partId, note) {
+	const accepted = acceptedAnswersOf(item, partId);
+	if (accepted.length > 0) {
+		const passage = numberedPassage(typeof item.passage === "string" ? item.passage : "");
+		const position = placeholderPosition(item, partId);
+		return accepted.some((answer) => revealsAnswer(note, answer, passage, position));
+	}
+	const choices = choicesOf(item, partId);
+	const words = fold$1(note);
+	const named = choices.filter((choice) => containsWords(words, fold$1(choice.text)));
+	return named.some((choice) => choice.correct) && named.length < choices.length;
+}
+/**
+* Every rule the route of `group` breaks. `scope: 'redacted'` checks only what
+* a learner's copy still carries: the evidence, key words, traps and notes are
+* gone from it.
+*/
+function routeIssues(group, scope = "content") {
+	if (!isFields(group) || !isFields(group.route)) return [];
+	const route = group.route;
+	const issues = [];
+	const add = (code, path, message) => {
+		issues.push({
+			code,
+			path,
+			message
+		});
+	};
+	const stimulus = isFields(group.stimulus) ? group.stimulus : void 0;
+	const body = typeof stimulus?.body === "string" ? stimulus.body : "";
+	if (stimulus !== void 0 && !unset(stimulus.kind) && stimulus.kind !== "text" && stimulus.kind !== "mixed") add("ig_route_stimulus_kind", ["stimulus", "kind"], "A reading route needs a text to read: make the stimulus a text.");
+	else if (stimulus !== void 0 && body.trim() === "") add("ig_route_body_required", ["stimulus", "body"], "Add the passage the questions are about.");
+	if (group.timeline !== void 0 && group.timeline !== null) add("ig_route_with_timeline", ["route"], "A group is a reading route or an interactive video, not both.");
+	if (group.shuffle === "within-group") add("ig_route_shuffle", ["shuffle"], "A reading route keeps its questions in paper order: many answers follow the order of the text.");
+	const items = list(group.items);
+	items.forEach((item, index) => {
+		if (isFields(item) && !unset(item.type) && !isReadingRouteItemType(item.type)) add("ig_route_item_type", [
+			"items",
+			index,
+			"type"
+		], `A reading route holds ${READING_ROUTE_ITEM_TYPES.join(", ")} questions; "${String(item.type)}" is not one of them.`);
+	});
+	const itemsById = /* @__PURE__ */ new Map();
+	for (const item of items) if (isFields(item) && typeof item.id === "string") itemsById.set(item.id, item);
+	if (body !== "" && route.paragraphLabels !== void 0) {
+		const paragraphs = countParagraphs(body);
+		if (!Array.isArray(route.paragraphLabels) || route.paragraphLabels.length !== paragraphs) add("ig_route_paragraph_labels", ["route", "paragraphLabels"], `The passage has ${paragraphs} paragraphs (separated by blank lines); give one label for each, or "" to leave one unlabelled.`);
+	}
+	if (body !== "" && Array.isArray(route.sections)) {
+		const paragraphs = countParagraphs(body);
+		const covered = route.sections.reduce((total, section) => total + (isFields(section) && typeof section.paragraphs === "number" ? section.paragraphs : 0), 0);
+		if (covered !== paragraphs) add("ig_route_sections", ["route", "sections"], `The sections cover ${covered} paragraphs, but the passage has ${paragraphs}.`);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	list(route.questions).forEach((raw, index) => {
+		const at = (...rest) => [
+			"route",
+			"questions",
+			index,
+			...rest
+		];
+		if (!isFields(raw)) return;
+		const itemId = typeof raw.itemId === "string" ? raw.itemId : void 0;
+		const item = itemId === void 0 ? void 0 : itemsById.get(itemId);
+		if (itemId === void 0 || item === void 0) {
+			add("ig_route_question_item_unknown", at("itemId"), `No item of this group has the id "${String(raw.itemId)}".`);
+			return;
+		}
+		const parts = partIdsOf(item);
+		const partId = typeof raw.partId === "string" && raw.partId !== "" ? raw.partId : void 0;
+		if (parts === null && partId !== void 0) {
+			add("ig_route_question_part_not_allowed", at("partId"), "A multiple-choice item is one question: leave out partId.");
+			return;
+		}
+		if (parts !== null && partId === void 0) {
+			add("ig_route_question_part_required", at("partId"), "Name the blank or gap this question is: each one is a question of its own.");
+			return;
+		}
+		if (parts !== null && partId !== void 0 && !parts.includes(partId)) {
+			add("ig_route_question_part_unknown", at("partId"), `Item "${itemId}" has no blank or gap "${partId}".`);
+			return;
+		}
+		const key = questionKey(itemId, partId);
+		if (seen.has(key)) {
+			add("ig_route_question_duplicate", at(), `Question "${key}" has two entries; keep one.`);
+			return;
+		}
+		seen.add(key);
+		const type = item.type;
+		if (unset(raw.strategy)) add("ig_route_strategy_required", at("strategy"), "Choose the reading strategy this question practises.");
+		else if (!isRouteStrategyId(raw.strategy)) add("ig_route_strategy_unknown", at("strategy"), `"${String(raw.strategy)}" is not a reading strategy.`);
+		else if (isReadingRouteItemType(type) && !ROUTE_STRATEGIES[raw.strategy].itemTypes.includes(type)) add("ig_route_strategy_item_type", at("strategy"), `The ${ROUTE_STRATEGIES[raw.strategy].title} strategy is written as ${ROUTE_STRATEGIES[raw.strategy].itemTypes.join(" or ")}, not ${String(type)}.`);
+		if (raw.wordLimit !== void 0) {
+			if (type !== "fill-in-the-blanks") add("ig_route_word_limit_type", at("wordLimit"), "Only a question the learner writes has a word limit.");
+			else if (typeof raw.wordLimit === "number") {
+				const limit = raw.wordLimit;
+				for (const answer of acceptedAnswersOf(item, partId)) if (countWords(answer) > limit) add("ig_route_answer_over_limit", at("wordLimit"), `The accepted answer "${answer}" is longer than ${limit} word${limit === 1 ? "" : "s"}: a learner who writes it would lose the mark.`);
+			}
+		}
+		if (scope === "redacted") return;
+		const quote = (value, path) => {
+			if (body === "") return;
+			const match = findQuote(body, value);
+			if (match.found) return;
+			const words = quoteText(value);
+			if (match.reason === "ambiguous") add("ig_route_quote_ambiguous", path, `"${words}" appears ${match.count} times in the passage. Quote more words, or say which occurrence: { "text": ..., "occurrence": 2 }.`);
+			else add("ig_route_quote_not_found", path, match.reason === "occurrence" ? `"${words}" appears only ${match.count} time${match.count === 1 ? "" : "s"} in the passage.` : `"${words}" is not in the passage. Copy the words exactly as the passage writes them.`);
+		};
+		const evidence = list(raw.evidence);
+		if (evidence.length === 0) add("ig_route_evidence_required", at("evidence"), "Quote where the passage justifies the answer — for a Not Given answer, where it discusses the topic.");
+		evidence.forEach((value, at2) => {
+			quote(value, at("evidence", at2));
+		});
+		const visible = learnerTextOf(item);
+		list(raw.keywords).forEach((keyword, at2) => {
+			if (!isFields(keyword)) return;
+			if (typeof keyword.question === "string" && !containsPhrase(visible, keyword.question)) add("ig_route_keyword_not_in_question", at("keywords", at2, "question"), `"${keyword.question}" is not in the question. Copy the words as the question writes them.`);
+			if (keyword.passage !== void 0) quote(keyword.passage, at("keywords", at2, "passage"));
+		});
+		list(raw.links).forEach((link, at2) => {
+			if (isFields(link)) {
+				quote(link.from, at("links", at2, "from"));
+				quote(link.to, at("links", at2, "to"));
+			}
+		});
+		const choices = choicesOf(item, partId);
+		list(raw.traps).forEach((trap, at2) => {
+			if (!isFields(trap)) return;
+			const choice = choices.find((candidate) => candidate.id === trap.optionId);
+			if (choice === void 0) add("ig_route_trap_option_unknown", at("traps", at2, "optionId"), `This question has no option or choice "${String(trap.optionId)}".`);
+			else if (choice.correct) add("ig_route_trap_on_answer", at("traps", at2, "optionId"), "A trap is a wrong option; this one is the answer.");
+			if (trap.lure !== void 0) quote(trap.lure, at("traps", at2, "lure"));
+		});
+		if (isFields(raw.notes) && isRouteStrategyId(raw.strategy)) {
+			const moves = ROUTE_STRATEGIES[raw.strategy].moves;
+			for (const [move, note] of Object.entries(raw.notes)) {
+				const path = at("notes", move);
+				if (!moves.includes(move) || move === "survey") {
+					add("ig_route_note_move_unknown", path, `The ${ROUTE_STRATEGIES[raw.strategy].title} strategy has no "${move}" step for a question.`);
+					continue;
+				}
+				if (typeof note !== "string") continue;
+				if (note.length > 280) add("ig_route_note_too_long", path, `Keep a step's note to 280 characters.`);
+				else if (noteRevealsAnswer(item, partId, note)) add("ig_route_note_reveals_answer", path, "This note gives the answer away. Say where to look and why, not what to answer.");
+			}
+		}
+	});
+	for (const question of itemQuestions(items)) if (!seen.has(question.key) && itemsById.has(question.itemId) && isReadingRouteItemType(question.type)) add("ig_route_question_missing", ["route", "questions"], question.partId === void 0 ? `Question "${question.itemId}" has no route entry.` : `Blank or gap "${question.partId}" of "${question.itemId}" has no route entry.`);
+	return issues;
+}
+// src/timeline-limits.ts
+/**
+* The bounds of an interactive video — an item group with a `timeline`.
+*
+* A leaf module on purpose: the schemas, the authoring checks and the timeline
+* helpers all read these, and nothing here may import any of them back.
+*/
+/**
+* The item types an interactive video may present. CLOSED on purpose: a type
+* added to the SDK later, or a custom type a host registers, is not silently
+* embeddable. Each one here was chosen, and each works inside a paused video —
+* a read-aloud's and a spoken answer's microphone included, because every quiz
+* pauses the video first.
+*
+* A question's own media is allowed as on any other item, under its own
+* playback policy: a picture to describe, or a recording to answer, which
+* plays only when the learner presses play while the video is paused. A
+* dictation must carry its own recording (the timeline rule).
+*
+* `speaking-response` joined in 1.10.0: a host with an exhaustive `switch` or
+* `Record` over {@link InteractiveVideoItemType} needs one more entry.
+*/
+const INTERACTIVE_VIDEO_ITEM_TYPES = [
+	"multiple-choice",
+	"fill-in-the-blanks",
+	"gap-select",
+	"dictation",
+	"read-aloud",
+	"speaking-response"
+];
+/** Whether `type` is one of the item types an interactive video may present. */
+function isInteractiveVideoItemType(type) {
+	return INTERACTIVE_VIDEO_ITEM_TYPES.includes(type);
+}
+/** The most quizzes one video may hold. */
+const TIMELINE_MAX_QUIZZES = 100;
+/**
+* The most questions one interactive video may hold, across all its quizzes.
+* The player keeps every one of them mounted, so an answer survives the
+* learner rewinding past its quiz.
+*/
+const TIMELINE_MAX_ITEMS = 200;
+/** The most chapters one video may hold. */
+const TIMELINE_MAX_CHAPTERS = 100;
+/** The longest quiz or chapter title, in UTF-16 units. A title sits on one line of the player. */
+const TIMELINE_MAX_TITLE_LENGTH = 120;
+// src/schemas/item-group.ts
+/**
+* An authored slot key.
+*
+* A `.` is rejected here, not at render time: `flattenSequence` uses the first
+* `.` to separate a group from its item, so a key containing one would produce
+* an ambiguous slot id. `keyOf` already threw on it — this moves the rejection
+* to `validateItemGroup`, where an author finds it, instead of leaving it to
+* surface when a learner opens the paper. Content that would newly fail
+* validation already threw at flatten time, so it can never have been sat.
+*/
+const SlotKeySchema = z.string().min(1).refine((key) => !key.includes("."), { error: "slotKey must not contain \".\" — that character separates a group from its item in a slot id, so a key containing one would make the slot ambiguous." });
+function hasBody(stimulus) {
+	return typeof stimulus.body === "string" && stimulus.body.trim().length > 0;
+}
+/** Which media types can carry a stimulus of each kind. `text`/`mixed` accept any. */
+function mediaFits(kind, mediaType) {
+	switch (kind) {
+		case "audio": return mediaType === "audio";
+		case "video": return mediaType === "video" || mediaType === "embed";
+		case "image": return mediaType === "image";
+		default: return true;
+	}
+}
+/**
+* Zod schema for a {@link Stimulus}. Loose: unknown keys preserved.
+*
+* The semantic guards exist because a stimulus that does not carry what its
+* `kind` promises is an authoring error that must not reach an exam: an
+* "audio" stimulus with no recording renders as a blank panel above six
+* listening questions. Unrepresentable in JSON Schema; dropped from
+* `stimulusJsonSchema` by design.
+*/
+const StimulusSchema = z.looseObject({
+	id: z.string().min(1),
+	kind: z.enum([
+		"text",
+		"audio",
+		"video",
+		"image",
+		"mixed"
+	]),
+	title: z.string().optional(),
+	body: z.string().optional(),
+	bodyHtml: z.string().optional(),
+	media: MediaSchema.optional(),
+	transcript: z.string().optional(),
+	script: ScriptSchema.optional(),
+	locale: z.string().optional(),
+	attribution: z.string().optional()
+}).refine((stimulus) => stimulus.bodyHtml === void 0 || hasBody(stimulus), {
+	error: "bodyHtml requires a plain-text body: it is the accessible fallback rendered when no sanitiser is supplied.",
+	path: ["body"]
+}).refine((stimulus) => stimulus.kind !== "text" && stimulus.kind !== "mixed" || hasBody(stimulus), {
+	error: "A text or mixed stimulus needs a non-empty body.",
+	path: ["body"]
+}).refine((stimulus) => stimulus.kind === "text" || stimulus.media !== void 0, {
+	error: "An audio, video, image or mixed stimulus needs media.",
+	path: ["media"]
+}).refine((stimulus) => stimulus.media === void 0 || mediaFits(stimulus.kind, stimulus.media.type), {
+	error: "media.type does not fit the stimulus kind: audio needs audio; video needs video or embed; image needs image.",
+	path: ["media", "type"]
+});
+const TimelineTitleSchema = maxUnits(z.string(), 120).refine((title) => title.trim().length > 0, { error: "A title must not be empty." });
+/** Seconds from the start of the video. zod rejects NaN and ±Infinity itself. */
+const TimelineTimeSchema = z.number().min(0, { error: "A time is 0 seconds or more." });
+/**
+* A quiz. STRICT, like every part of a timeline: a misspelt `requried` would
+* otherwise be kept and the quiz silently optional on a paper that believed it
+* was required.
+*/
+const TimelineCueSchema = z.strictObject({
+	id: maxUnits(z.string().min(1), 64),
+	at: TimelineTimeSchema,
+	itemIds: z.array(z.string().min(1)).min(1).max(200),
+	title: TimelineTitleSchema.optional(),
+	required: z.boolean().optional()
+});
+const TimelineChapterSchema = z.strictObject({
+	at: TimelineTimeSchema,
+	title: TimelineTitleSchema
+});
+/**
+* A timeline on its own: its quizzes, chapters and navigation. The rules that
+* need the group — every item in exactly one quiz, a video stimulus, the five
+* item types — are {@link timelineIssues}, which both group schemas run.
+*/
+const MediaTimelineSchema = z.strictObject({
+	cues: z.array(TimelineCueSchema).max(100),
+	chapters: z.array(TimelineChapterSchema).max(100).optional(),
+	navigation: z.enum(["free", "no-skip-ahead"]).optional()
+}).check((ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	ctx.value.cues.forEach((cue, index) => {
+		if (seen.has(cue.id)) ctx.issues.push({
+			code: "custom",
+			input: cue.id,
+			message: `Quiz id "${cue.id}" is used twice: events, drafts and the contents panel name a quiz by its id.`,
+			path: [
+				"cues",
+				index,
+				"id"
+			]
+		});
+		seen.add(cue.id);
+	});
+	const chapters = ctx.value.chapters ?? [];
+	chapters.forEach((chapter, index) => {
+		const previous = chapters[index - 1];
+		if (previous !== void 0 && chapter.at <= previous.at) ctx.issues.push({
+			code: "custom",
+			input: chapter.at,
+			message: "Chapter times must be strictly increasing.",
+			path: [
+				"chapters",
+				index,
+				"at"
+			]
+		});
+	});
+});
+/** Words copied from the passage: the words, or the words and which occurrence of them. */
+const RouteQuoteSchema = z.union([z.string().min(1), z.strictObject({
+	text: z.string().min(1),
+	occurrence: z.number().int().min(1).optional()
+})]);
+const ROUTE_TRAP_KINDS = [
+	"word-match",
+	"opposite",
+	"partial",
+	"outside-knowledge",
+	"too-general",
+	"too-specific",
+	"not-the-question"
+];
+const ROUTE_MOVE_IDS = [
+	"read-instructions",
+	"survey",
+	"keywords",
+	"predict",
+	"locate",
+	"read-around",
+	"paraphrase",
+	"decide",
+	"eliminate",
+	"cohesion",
+	"check-answer",
+	"compare-views"
+];
+const RouteSectionSchema = z.strictObject({
+	label: z.string().min(1),
+	title: z.string().optional(),
+	paragraphs: z.number().int().min(1)
+});
+/**
+* One question of a route. STRICT, like every part of a route: a misspelt
+* `evidense` would otherwise leave a question with no evidence and no error.
+* The rules that need the passage or the items are {@link routeIssues}.
+*/
+const RouteQuestionSchema = z.strictObject({
+	itemId: z.string().min(1),
+	partId: z.string().min(1).optional(),
+	strategy: z.enum(ROUTE_STRATEGY_IDS),
+	evidence: z.array(RouteQuoteSchema).min(1),
+	evidenceMatch: z.enum(["any", "all"]).optional(),
+	keywords: z.array(z.strictObject({
+		question: z.string().min(1),
+		passage: RouteQuoteSchema.optional()
+	})).optional(),
+	links: z.array(z.strictObject({
+		from: RouteQuoteSchema,
+		to: RouteQuoteSchema
+	})).optional(),
+	wordLimit: z.number().int().min(1).max(10).optional(),
+	traps: z.array(z.strictObject({
+		optionId: z.string().min(1),
+		kind: z.enum(ROUTE_TRAP_KINDS),
+		lure: RouteQuoteSchema.optional()
+	})).optional(),
+	notes: z.partialRecord(z.enum(ROUTE_MOVE_IDS), maxUnits(z.string().min(1), 280)).optional()
+});
+/** A route on its own. The rules that span the route, the passage and the items are {@link routeIssues}, which both group schemas run. */
+const ReadingRouteSchema = z.strictObject({
+	routeVersion: z.literal("1.0"),
+	startAt: z.number().int().min(1).optional(),
+	paragraphLabels: z.array(z.string()).optional(),
+	sections: z.array(RouteSectionSchema).min(1).optional(),
+	questions: z.array(RouteQuestionSchema)
+});
+/** A route as a learner's copy carries it: which question practises which strategy, and nothing that locates an answer. */
+const RedactedReadingRouteSchema = z.strictObject({
+	routeVersion: z.literal("1.0"),
+	startAt: z.number().int().min(1).optional(),
+	paragraphLabels: z.array(z.string()).optional(),
+	sections: z.array(RouteSectionSchema).min(1).optional(),
+	questions: z.array(z.strictObject({
+		itemId: z.string().min(1),
+		partId: z.string().min(1).optional(),
+		strategy: z.enum(ROUTE_STRATEGY_IDS),
+		wordLimit: z.number().int().min(1).max(10).optional()
+	}))
+});
+/** A URL only this document can resolve, or one that inlines the bytes. */
+function isLocalOnlyUrl(url) {
+	return typeof url === "string" && /^(data|blob):/i.test(url);
+}
+/**
+* The rules of an interactive video that span the timeline, the stimulus and
+* the items. Run by the content schema and, for everything but the two
+* authoring-only rules, by the strict redacted schema — a projection built by
+* hand never passed through the content schema.
+*
+* Items are read defensively: the redacted schema leaves them opaque, and each
+* is proven against its own type's schema elsewhere.
+*/
+function timelineIssues(group, scope) {
+	const timeline = group.timeline;
+	if (timeline === void 0) return [];
+	const issues = [];
+	const media = group.stimulus.media;
+	if (group.stimulus.kind !== "video") issues.push({
+		path: ["stimulus", "kind"],
+		input: group.stimulus.kind,
+		message: "An interactive video needs a video stimulus: quizzes open at moments of a video, and nothing else has them."
+	});
+	else if (media !== void 0 && media.type !== "video") issues.push({
+		path: [
+			"stimulus",
+			"media",
+			"type"
+		],
+		input: media.type,
+		message: "An interactive video needs a video file. An embedded provider player cannot be paused at the moment a quiz opens."
+	});
+	if (group.shuffle === "within-group") issues.push({
+		path: ["shuffle"],
+		input: group.shuffle,
+		message: "An interactive video presents its questions in the order its quizzes open; shuffle: \"within-group\" cannot apply to it."
+	});
+	if (group.items.length > 200) issues.push({
+		path: ["items"],
+		input: group.items.length,
+		message: `An interactive video holds at most 200 questions.`
+	});
+	const itemIds = /* @__PURE__ */ new Map();
+	group.items.forEach((item, index) => {
+		const { id, type, media: itemMedia } = item ?? {};
+		if (typeof id === "string") itemIds.set(id, index);
+		if (!isInteractiveVideoItemType(type)) issues.push({
+			path: [
+				"items",
+				index,
+				"type"
+			],
+			input: type,
+			message: `An interactive video may hold only ${INTERACTIVE_VIDEO_ITEM_TYPES.join(", ")} questions.`
+		});
+		if (scope === "content" && type === "dictation" && itemMedia === void 0) issues.push({
+			path: [
+				"items",
+				index,
+				"media"
+			],
+			input: itemMedia,
+			message: "A dictation inside an interactive video needs its own recording."
+		});
+	});
+	const placed = /* @__PURE__ */ new Set();
+	timeline.cues.forEach((cue, cueIndex) => {
+		cue.itemIds.forEach((itemId, position) => {
+			const path = [
+				"timeline",
+				"cues",
+				cueIndex,
+				"itemIds",
+				position
+			];
+			if (!itemIds.has(itemId)) issues.push({
+				path,
+				input: itemId,
+				message: `No item in this group has the id "${itemId}".`
+			});
+			else if (placed.has(itemId)) issues.push({
+				path,
+				input: itemId,
+				message: `Item "${itemId}" is placed twice: every question belongs to exactly one quiz.`
+			});
+			placed.add(itemId);
+		});
+	});
+	for (const [itemId, index] of itemIds) if (!placed.has(itemId)) issues.push({
+		path: ["items", index],
+		input: itemId,
+		message: `Item "${itemId}" is in no quiz, so the video would never show it.`
+	});
+	if (scope === "content" && media !== void 0) {
+		const urls = [
+			[media.url, [
+				"stimulus",
+				"media",
+				"url"
+			]],
+			[media.poster, [
+				"stimulus",
+				"media",
+				"poster"
+			]],
+			...(media.tracks ?? []).map((track, index) => [track.src, [
+				"stimulus",
+				"media",
+				"tracks",
+				index,
+				"src"
+			]])
+		];
+		for (const [url, path] of urls) if (isLocalOnlyUrl(url)) issues.push({
+			path,
+			input: url,
+			message: "An interactive video is stored and served: its URLs cannot be data: or blob: URLs."
+		});
+	}
+	return issues;
+}
+/**
+* The structural minimum of an item as seen by the CONTAINER schema. Each
+* item's own contract is checked against its registered schema by
+* {@link validateItemGroup} — a zod schema cannot dispatch on a registry
+* that consumers extend at runtime.
+*/
+const ItemShapeSchema = z.looseObject({
+	type: z.string().min(1),
+	id: z.string().min(1),
+	slotKey: SlotKeySchema.optional()
+});
+/**
+* Zod schema for an {@link ItemGroup} CONTAINER. Loose: unknown keys
+* preserved. Validates the group's own fields and the stimulus in full, and
+* each item only structurally (`type` and `id`); use {@link validateItemGroup}
+* to validate the items against their registered schemas as well.
+*/
+const ItemGroupSchema = z.looseObject({
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("item-group"),
+	id: z.string().min(1),
+	title: z.string().optional(),
+	slotKey: SlotKeySchema.optional(),
+	stimulus: StimulusSchema,
+	items: z.array(ItemShapeSchema).min(1),
+	shuffle: z.enum(["none", "within-group"]).optional(),
+	timeline: MediaTimelineSchema.optional(),
+	route: ReadingRouteSchema.optional()
+}).refine((group) => group.items.every((item) => item.type !== "item-group"), {
+	error: "Item groups do not nest: every item must be an activity.",
+	path: ["items"]
+}).refine((group) => new Set(group.items.map((item) => item.id)).size === group.items.length, {
+	error: "Item ids must be unique within a group.",
+	path: ["items"]
+}).check((ctx) => {
+	for (const issue of timelineIssues(ctx.value, "content")) ctx.issues.push({
+		code: "custom",
+		...issue
+	});
+	for (const { path, message } of routeIssues(ctx.value, "content")) ctx.issues.push({
+		code: "custom",
+		input: ctx.value.route,
+		path,
+		message
+	});
+});
+/** Strict learner-safe stimulus: everything but the author-only `transcript`. */
+const RedactedStimulusSchema = z.strictObject({
+	id: z.string().min(1),
+	kind: z.enum([
+		"text",
+		"audio",
+		"video",
+		"image",
+		"mixed"
+	]),
+	title: z.string().optional(),
+	body: z.string().optional(),
+	bodyHtml: z.string().optional(),
+	media: RedactedMediaSchema.optional(),
+	locale: z.string().optional(),
+	attribution: z.string().optional()
+});
+/**
+* Strict learner-safe item group. Items are left opaque here — each is proven
+* learner-safe by `assertRedacted` against its OWN type's redacted schema,
+* which is the only place that knowledge lives. The one exception is the one
+* rule that spans the container and an item: a captioned stimulus recording
+* played to a dictation is not learner-safe, because the captions are the
+* dictation's answer.
+*/
+const RedactedItemGroupSchema = z.strictObject({
+	redacted: z.literal(true),
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("item-group"),
+	id: z.string().min(1),
+	title: z.string().optional(),
+	slotKey: SlotKeySchema.optional(),
+	stimulus: RedactedStimulusSchema,
+	items: z.array(z.unknown()).min(1),
+	shuffle: z.enum(["none", "within-group"]).optional(),
+	timeline: MediaTimelineSchema.optional(),
+	route: RedactedReadingRouteSchema.optional()
+}).check((ctx) => {
+	for (const issue of timelineIssues(ctx.value, "redacted")) ctx.issues.push({
+		code: "custom",
+		...issue
+	});
+	for (const { path, message } of routeIssues(ctx.value, "redacted")) ctx.issues.push({
+		code: "custom",
+		input: ctx.value.route,
+		path,
+		message
+	});
+	const captions = groupCaptionsField(ctx.value);
+	if (captions !== void 0) ctx.issues.push({
+		code: "custom",
+		input: ctx.value.stimulus.media?.[captions],
+		message: GROUP_CAPTIONS_REVEAL_DICTATION,
+		path: [
+			"stimulus",
+			"media",
+			captions
+		]
+	});
+});
+function toValidationErrors(issues, prefix) {
+	return issues.map((issue) => ({
+		path: [...prefix, ...issue.path.map(String)],
+		message: issue.message,
+		code: issue.code
+	}));
+}
+/**
+* Validates an item group in full: the container and stimulus against
+* {@link ItemGroupSchema}, then every item against the schema registered for
+* its `type`. Errors from items are reported at `items.<index>.…`.
+*
+* Unlike `validateActivity`, an item whose type is not registered is REPORTED
+* (code `unknown_activity_type`) rather than thrown: a group is validated as
+* a whole, and an author fixing a six-item group wants every problem listed,
+* not the first one that happened to throw.
+*/
+function validateItemGroup(data) {
+	const container = ItemGroupSchema.safeParse(data);
+	if (!container.success) return {
+		success: false,
+		errors: toValidationErrors(container.error.issues, [])
+	};
+	const errors = [];
+	const items = [];
+	container.data.items.forEach((item, index) => {
+		const descriptor = getActivityTypeDescriptor(item.type);
+		if (descriptor === void 0) {
+			errors.push({
+				path: [
+					"items",
+					String(index),
+					"type"
+				],
+				message: `Activity type "${item.type}" is not registered`,
+				code: "unknown_activity_type"
+			});
+			return;
+		}
+		const parsed = readSchema(descriptor.schema, item, `Activity type "${descriptor.type}"`);
+		if (!parsed.success) {
+			errors.push(...toValidationErrors(parsed.issues, ["items", String(index)]));
+			return;
+		}
+		items.push(parsed.data);
+	});
+	const captions = groupCaptionsField(container.data);
+	if (captions !== void 0) errors.push({
+		path: [
+			"stimulus",
+			"media",
+			captions
+		],
+		message: GROUP_CAPTIONS_REVEAL_DICTATION,
+		code: "custom"
+	});
+	if (errors.length > 0) return {
+		success: false,
+		errors
+	};
+	return {
+		success: true,
+		data: {
+			...container.data,
+			items
+		}
+	};
+}
+export { questionKey as C, passageLayout as D, overlaps as E, sentencesTouching as O, itemQuestions as S, countParagraphs as T, isReadingRouteItemType as _, INTERACTIVE_VIDEO_ITEM_TYPES as a, quoteText as b, TIMELINE_MAX_QUIZZES as c, routeIssues as d, READING_ROUTE_ITEM_TYPES as f, ROUTE_WORD_LIMIT_MAX as g, ROUTE_STRATEGY_IDS as h, validateItemGroup as i, TIMELINE_MAX_TITLE_LENGTH as l, ROUTE_STRATEGIES as m, RedactedItemGroupSchema as n, TIMELINE_MAX_CHAPTERS as o, ROUTE_NOTE_MAX_LENGTH as p, StimulusSchema as r, TIMELINE_MAX_ITEMS as s, ItemGroupSchema as t, isInteractiveVideoItemType as u, isRouteStrategyId as v, ROUTE_SEGMENTER as w, choicesOf as x, findQuote as y };
+
+//# sourceMappingURL=item-group-uNAT5EX5.js.map