@intellectif/lk-core 1.12.0 → 1.14.0

package/dist/{registry-BClnM5V3.js → registry-CroAI5nc.js}

@@ -442,7 +442,9 @@ const BUILT_IN_ACTIVITY_TYPES = [
 	"gap-select",
 	"dictation",
 	"read-aloud",
-	"speaking-response"
+	"speaking-response",
+	"matching",
+	"mark-the-words"
 ];
 /** Whether `type` names an activity type the SDK ships. */
 function isBuiltInActivityType(type) {
@@ -1053,7 +1055,7 @@ function containsUnspacedScript(text) {
 }
 /** What is drawn onto the character before it: a match never ends just before one. */
 const EXTENDING_RE = new RegExp(`^[\\p{M}${JOINERS}${TAGS}]$`, "u");
-const WORD = 1;
+const WORD$1 = 1;
 const UNSPACED = 2;
 const EXTENDING = 4;
 const KNOWN = 8;
@@ -1067,7 +1069,7 @@ const KNOWN = 8;
 */
 const FLAGS = [];
 function flagsOfCharacter(character) {
-	return KNOWN | (WORD_RE.test(character) ? WORD : 0) | (UNSPACED_CHARACTER_RE.test(character) ? UNSPACED : 0) | (EXTENDING_RE.test(character) ? EXTENDING : 0);
+	return KNOWN | (WORD_RE.test(character) ? WORD$1 : 0) | (UNSPACED_CHARACTER_RE.test(character) ? UNSPACED : 0) | (EXTENDING_RE.test(character) ? EXTENDING : 0);
 }
 /** The flags of the code point that starts at UTF-16 index `index` of `text`. */
 function flagsAt(text, index) {
@@ -1297,12 +1299,12 @@ function isAsciiWordUnit(unit) {
 }
 function isWordAt(text, index) {
 	const unit = text.charCodeAt(index);
-	return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & WORD) !== 0;
+	return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & WORD$1) !== 0;
 }
 /** A word character of a script that separates its words with spaces. */
 function isSpacedWordAt(text, index) {
 	const unit = text.charCodeAt(index);
-	return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & 3) === WORD;
+	return unit < 128 ? isAsciiWordUnit(unit) : (flagsAt(text, index) & 3) === WORD$1;
 }
 function isExtendingAt(text, index) {
 	return text.charCodeAt(index) >= 128 && (flagsAt(text, index) & EXTENDING) !== 0;
@@ -2327,6 +2329,29 @@ const DRAFT_ISSUE_SEVERITY = {
 	gs_choice_text_required: "incomplete",
 	gs_correct_choice_required: "incomplete",
 	gs_correct_choice_unknown: "invalid",
+	mt_prompts_required: "incomplete",
+	mt_prompt_id_required: "invalid",
+	mt_prompt_id_duplicate: "invalid",
+	mt_prompt_text_required: "incomplete",
+	mt_options_too_few: "incomplete",
+	mt_option_id_required: "invalid",
+	mt_option_id_duplicate: "invalid",
+	mt_option_text_required: "incomplete",
+	mt_option_label_required: "incomplete",
+	mt_option_label_duplicate: "invalid",
+	mt_option_use_invalid: "invalid",
+	mt_correct_option_required: "incomplete",
+	mt_correct_option_unknown: "invalid",
+	mt_option_reused: "invalid",
+	mw_text_required: "incomplete",
+	mw_text_too_long: "invalid",
+	mw_targets_required: "incomplete",
+	mw_target_text_required: "incomplete",
+	mw_target_no_words: "invalid",
+	mw_target_not_found: "invalid",
+	mw_target_ambiguous: "incomplete",
+	mw_target_occurrence_invalid: "invalid",
+	mw_target_overlap: "invalid",
 	wr_prompt_required: "incomplete",
 	wr_min_words_required: "incomplete",
 	wr_min_words_invalid: "invalid",
@@ -3086,6 +3111,13 @@ const ITEM_FINDING_SEVERITY = {
 	gs_choices_duplicate: "warning",
 	gs_bank_no_distractor: "warning",
 	gs_answer_in_passage: "warning",
+	mt_title_reveals_answer: "warning",
+	mt_options_duplicate: "warning",
+	mt_answer_in_prompt: "warning",
+	mt_no_distractor: "warning",
+	mw_title_reveals_answer: "warning",
+	mw_targets_dense: "warning",
+	mw_target_elsewhere: "advice",
 	wr_criterion_name_duplicate: "warning",
 	wr_levels_unreadable: "warning",
 	ra_text_long_for_time: "warning",
@@ -3356,6 +3388,40 @@ function critiqueGapSelect(draft) {
 	});
 	return findings;
 }
+/** Whether `text` writes out `answer` as whole words — an answer of one short word never counts. */
+function writesOut$1(text, answer) {
+	const needle = fold(answer);
+	return needle.length > 0 && !isShort(needle) && containsWords(fold(text), needle);
+}
+function critiqueMatching(draft) {
+	const findings = [];
+	const prompts = listOf(draft.prompts);
+	const options = listOf(draft.options);
+	const optionText = (option) => isRecord(option) ? written(option.text) : void 0;
+	const answerOf = (prompt) => isRecord(prompt) ? optionText(options.find((option) => isRecord(option) && option.id === prompt.correctOptionId)) : void 0;
+	const title = written(draft.title);
+	if (title !== void 0 && prompts.some((prompt) => {
+		const answer = answerOf(prompt);
+		return answer !== void 0 && writesOut$1(title, answer);
+	})) findings.push(finding("mt_title_reveals_answer", ["title"], "The title, which the learner sees, contains the answer to a prompt."));
+	for (const { first, second } of duplicates(options, optionText)) findings.push(finding("mt_options_duplicate", [
+		"options",
+		second,
+		"text"
+	], `Options ${ordinal(first)} and ${ordinal(second)} read the same, so a learner cannot tell them apart.`));
+	prompts.forEach((prompt, index) => {
+		const text = isRecord(prompt) ? written(prompt.text) : void 0;
+		const answer = answerOf(prompt);
+		if (text !== void 0 && answer !== void 0 && writesOut$1(text, answer)) findings.push(finding("mt_answer_in_prompt", [
+			"prompts",
+			index,
+			"text"
+		], `Prompt ${ordinal(index)} contains "${answer}", the option that answers it, word for word.`));
+	});
+	const promptCount = prompts.filter(isRecord).length;
+	if (draft.optionUse === "once" && promptCount >= 2 && options.length <= promptCount) findings.push(finding("mt_no_distractor", ["options"], `Each option is used once, and there are ${options.length} options for ${promptCount} prompts, so the last prompt is answered by elimination. Add an option that answers no prompt.`));
+	return findings;
+}
 /** Why a criterion's levels cannot be graded on, said to the author. */
 const LEVELS_PROBLEM = {
 	"not-a-list": (criterion) => `Criterion ${criterion}'s levels are not a list`,
@@ -3745,6 +3811,514 @@ function pairsOneToOne(placeholders, gaps) {
 	if (new Set(ids).size !== ids.length || placeholders.size !== ids.length) return false;
 	return ids.every((id) => typeof id === "string" && placeholders.get(id) === 1);
 }
+// src/mark-the-words.ts
+/**
+* The words of a mark-the-words text, and where an author's targets fall
+* among them. A leaf module: the schema, the scorer, the draft checks and the
+* component all read it, and it imports nothing.
+*
+* A learner marks words, never characters, and a response records a word by
+* its position — so how a text is cut into words is part of every stored
+* answer. The cut is the SDK's own (`lk-words@1`), not `Intl.Segmenter`,
+* whose word boundaries change with the ICU a runtime ships: the same text
+* must be the same words in every browser and on every server, now and when
+* the answer is graded again later.
+*/
+/** The name of the word cut. A change to it is a major: stored answers name words by position. */
+const MARK_THE_WORDS_TOKENIZER = "lk-words@1";
+/** The most words a mark-the-words text may have. */
+const MARK_THE_WORDS_MAX_WORDS = 1500;
+/**
+* A word: a run of letters, marks and digits, which may hold an apostrophe or
+* a hyphen between two such runs — "don't", "well-known", "1960s". Punctuation
+* and spaces are never part of one and can never be marked.
+*/
+const WORD = /[\p{L}\p{M}\p{N}]+(?:['’ʼ\-‐][\p{L}\p{M}\p{N}]+)*/gu;
+/** Every markable word of `text`, in order, cut by `lk-words@1`. */
+function markableWords(text) {
+	const words = [];
+	for (const match of text.matchAll(WORD)) words.push({
+		index: words.length,
+		text: match[0],
+		start: match.index,
+		end: match.index + match[0].length
+	});
+	return words;
+}
+/** A word as compared with a target's: composed, and with one apostrophe and one hyphen. */
+function wordKey(word) {
+	return word.normalize("NFC").replace(/[’ʼ]/g, "'").replace(/‐/g, "-");
+}
+/** Every place `needle` appears in `words`, as the position of its first word. */
+function placesOf(words, needle) {
+	const places = [];
+	for (let at = 0; at + needle.length <= words.length; at += 1) if (needle.every((word, offset) => words[at + offset] === word)) places.push(at);
+	return places;
+}
+/**
+* Where a target falls among `words`. Its text must be whole words of the text,
+* in order — case, accents and punctuation as written, apart from the kind of
+* apostrophe — and must say which appearance it means when there are several.
+*/
+function resolveMarkTarget(words, target) {
+	const needle = markableWords(typeof target.text === "string" ? target.text : "").map((word) => wordKey(word.text));
+	if (needle.length === 0) return {
+		ok: false,
+		problem: "no-words",
+		found: 0
+	};
+	const places = placesOf(words.map((word) => wordKey(word.text)), needle);
+	if (places.length === 0) return {
+		ok: false,
+		problem: "not-found",
+		found: 0
+	};
+	const occurrence = target.occurrence;
+	let at;
+	if (occurrence === void 0) {
+		if (places.length > 1) return {
+			ok: false,
+			problem: "ambiguous",
+			found: places.length
+		};
+		at = places[0];
+	} else {
+		at = typeof occurrence === "number" && Number.isInteger(occurrence) && occurrence >= 1 ? places[occurrence - 1] : void 0;
+		if (at === void 0) return {
+			ok: false,
+			problem: "no-such-occurrence",
+			found: places.length
+		};
+	}
+	return {
+		ok: true,
+		indices: needle.map((_, offset) => at + offset)
+	};
+}
+/**
+* The word positions of each target of an item, in target order; a target
+* that falls nowhere has none. Read defensively: the scorer is reachable with
+* content an older build stored.
+*/
+function markTargetIndices(data) {
+	const words = markableWords(typeof data.text === "string" ? data.text : "");
+	return (Array.isArray(data.targets) ? data.targets : []).map((target) => {
+		if (typeof target !== "object" || target === null) return [];
+		const found = resolveMarkTarget(words, target);
+		return found.ok ? found.indices : [];
+	});
+}
+/**
+* A text and its targets from markup that stars each target, as an H5P "Mark
+* the Words" text does: `I *went* home and *had gone* to bed.` A `\*` is a
+* literal star. Each target names its appearance only where its words appear
+* more than once in the text.
+*
+* @throws Error when a star is left open.
+*/
+function markTheWordsFromMarkup(markup) {
+	let text = "";
+	const spans = [];
+	let open = null;
+	for (let at = 0; at < markup.length; at += 1) {
+		const char = markup[at];
+		if (char === "\\" && markup[at + 1] === "*") {
+			text += "*";
+			at += 1;
+		} else if (char === "*") {
+			if (open === null) open = text.length;
+			else {
+				spans.push({
+					start: open,
+					end: text.length
+				});
+				open = null;
+			}
+		} else text += char;
+	}
+	if (open !== null) throw new Error("markTheWordsFromMarkup: a * is opened and never closed.");
+	const words = markableWords(text);
+	const keys = words.map((word) => wordKey(word.text));
+	const targets = [];
+	for (const span of spans) {
+		const inside = words.filter((word) => word.start >= span.start && word.end <= span.end);
+		const first = inside[0];
+		if (first === void 0) continue;
+		const quote = text.slice(first.start, inside.at(-1).end);
+		const places = placesOf(keys, inside.map((word) => wordKey(word.text)));
+		targets.push(places.length > 1 ? {
+			text: quote,
+			occurrence: places.indexOf(first.index) + 1
+		} : { text: quote });
+	}
+	return {
+		text,
+		targets
+	};
+}
+// src/authoring/mark-the-words.ts
+/**
+* Draft support for `mark-the-words`.
+*
+* A new draft has an empty text and no targets, and `scoringStrategy` starts
+* at `all-or-nothing`, as on every built-in. An editor usually lets the author
+* click the words to mark; `markTheWordsFromMarkup` turns starred text into
+* the same `text` and `targets`.
+*/
+const markTheWordsAuthoring = {
+	createDraft: ({ newId }) => ({
+		schemaVersion: "1.0",
+		type: "mark-the-words",
+		id: newId(),
+		title: "",
+		text: "",
+		targets: [],
+		scoringStrategy: "all-or-nothing"
+	}),
+	checkDraft: checkMarkTheWordsDraft,
+	critique: critiqueMarkTheWords
+};
+/** The words of a draft's text, or `null` when there is no usable text to resolve targets in. */
+function wordsOf(draft) {
+	if (typeof draft.text !== "string") return null;
+	const words = markableWords(draft.text);
+	return words.length === 0 || words.length > 1500 ? null : words;
+}
+function checkMarkTheWordsDraft(draft) {
+	const issues = checkIdentity(draft, "mark-the-words");
+	issues.push(...checkScoringStrategy(draft));
+	const text = draft.text;
+	if (isUnwritten(text)) issues.push(issue("mw_text_required", ["text"], "Write the text the learner marks words in."));
+	else if (typeof text === "string") {
+		const count = markableWords(text).length;
+		if (count === 0) issues.push(issue("mw_text_required", ["text"], "The text has no word to mark yet. Write it out."));
+		else if (count > 1500) issues.push(issue("mw_text_too_long", ["text"], `The text has ${count} words; at most ${MARK_THE_WORDS_MAX_WORDS} can be marked in. Split it.`));
+	}
+	const targets = isUnset(draft.targets) ? [] : draft.targets;
+	if (Array.isArray(targets)) {
+		if (targets.length === 0) issues.push(issue("mw_targets_required", ["targets"], "Choose at least one word to mark."));
+		issues.push(...checkTargets(targets, wordsOf(draft)));
+	}
+	issues.push(...checkSharedOptional(draft));
+	return issues;
+}
+/**
+* Every target, each at its own path, where the schema reports it. Against
+* the text only when the text is usable: an unwritten one is already
+* reported, and every target would only restate that it is not found.
+*/
+function checkTargets(targets, words) {
+	const issues = [];
+	const owner = /* @__PURE__ */ new Map();
+	for (const [index, target] of targets.entries()) {
+		if (!isRecord(target)) continue;
+		const ordinal = index + 1;
+		const occurrence = target.occurrence;
+		const occurrenceWellFormed = isUnset(occurrence) || typeof occurrence === "number" && Number.isInteger(occurrence) && occurrence >= 1;
+		if (!occurrenceWellFormed) issues.push(issue("mw_target_occurrence_invalid", [
+			"targets",
+			index,
+			"occurrence"
+		], `Target ${ordinal}'s appearance must be a whole number from 1, or left out.`));
+		if (isUnwritten(target.text)) {
+			issues.push(issue("mw_target_text_required", [
+				"targets",
+				index,
+				"text"
+			], `Write the word or words target ${ordinal} marks.`));
+			continue;
+		}
+		if (typeof target.text !== "string" || words === null || !occurrenceWellFormed) continue;
+		const found = resolveMarkTarget(words, {
+			text: target.text,
+			...isUnset(occurrence) ? {} : { occurrence }
+		});
+		if (!found.ok) {
+			issues.push(targetProblem(found.problem, found.found, index, target.text));
+			continue;
+		}
+		if (found.indices.some((word) => owner.has(word))) {
+			issues.push(issue("mw_target_overlap", ["targets", index], `Target ${ordinal} shares a word with target ${owner.get(found.indices.find((word) => owner.has(word))) + 1}. A word belongs to one target at most.`));
+			continue;
+		}
+		for (const word of found.indices) owner.set(word, index);
+	}
+	return issues;
+}
+function targetProblem(problem, count, index, text) {
+	const ordinal = index + 1;
+	switch (problem) {
+		case "no-words": return issue("mw_target_no_words", [
+			"targets",
+			index,
+			"text"
+		], `Target ${ordinal} has no word in it: punctuation alone cannot be marked.`);
+		case "not-found": return issue("mw_target_not_found", [
+			"targets",
+			index,
+			"text"
+		], `"${text}" is not in the text as whole words. Copy it from the text, with the same capitals and accents.`);
+		case "ambiguous": return issue("mw_target_ambiguous", [
+			"targets",
+			index,
+			"text"
+		], `"${text}" appears ${count} times in the text. Say which one target ${ordinal} is, with its appearance (1 to ${count}).`);
+		case "no-such-occurrence": return issue("mw_target_occurrence_invalid", [
+			"targets",
+			index,
+			"occurrence"
+		], `"${text}" appears ${count === 1 ? "once" : `${count} times`} in the text, so it has no such appearance.`);
+	}
+}
+/** Whether `text` writes out `answer` as whole words — a short answer never counts. */
+function writesOut(text, answer) {
+	const needle = fold(answer);
+	return needle.length > 0 && !isShort(needle) && containsWords(fold(text), needle);
+}
+function critiqueMarkTheWords(draft) {
+	const findings = [];
+	const words = wordsOf(draft);
+	const targets = Array.isArray(draft.targets) ? draft.targets : [];
+	if (words === null) return findings;
+	const keys = words.map((word) => wordKey(word.text));
+	const resolved = targets.map((target) => {
+		if (!isRecord(target) || typeof target.text !== "string") return null;
+		const found = resolveMarkTarget(words, {
+			text: target.text,
+			...typeof target.occurrence === "number" ? { occurrence: target.occurrence } : {}
+		});
+		return found.ok ? found.indices : null;
+	});
+	const marked = new Set(resolved.flatMap((indices) => indices ?? []));
+	const title = typeof draft.title === "string" ? draft.title : "";
+	if (resolved.some((indices) => indices !== null && writesOut(title, indices.map((word) => words[word].text).join(" ")))) findings.push(finding("mw_title_reveals_answer", ["title"], "The title, which the learner sees, contains a word to mark."));
+	if (marked.size > 0 && marked.size * 2 > words.length) {
+		const everything = Math.round((2 * marked.size - words.length) / marked.size * 100);
+		findings.push(finding("mw_targets_dense", ["targets"], `${marked.size} of the text's ${words.length} words are to be marked, so a learner who marks every word scores ${everything}%. Mark fewer, or use a longer text.`));
+	}
+	resolved.forEach((indices, index) => {
+		if (indices === null) return;
+		const needle = indices.map((word) => keys[word]);
+		for (let at = 0; at + needle.length <= keys.length; at += 1) if (needle.every((key, offset) => keys[at + offset] === key) && !indices.includes(at) && !marked.has(at)) {
+			findings.push(finding("mw_target_elsewhere", ["targets", index], `"${needle.length === 1 ? words[indices[0]].text : indices.map((word) => words[word].text).join(" ")}" also appears where it is not to be marked. A learner who marks it there loses a mark: check that is meant.`));
+			return;
+		}
+	});
+	return findings;
+}
+// src/schemas/matching.ts
+/** Zod schema for one option of the shared list. Loose: a consumer sidecar survives validation. */
+const MatchingOptionSchema = z.looseObject({
+	id: z.string().min(1),
+	label: z.string().min(1).optional(),
+	text: z.string().min(1)
+});
+/** Zod schema for one prompt. Whether its `correctOptionId` exists is checked on the activity. */
+const MatchingPromptSchema = z.looseObject({
+	id: z.string().min(1),
+	text: z.string().min(1),
+	correctOptionId: z.string().min(1),
+	feedback: z.string().optional()
+});
+/** Labels compared as a learner reads them: `"A"`, `" a "` and `"a"` are one key. */
+function labelKey(label) {
+	return label.trim().toLowerCase();
+}
+/** Whether every element of `values` is distinct. */
+const distinct = (values) => new Set(values).size === values.length;
+/**
+* Zod schema validating the full Matching data contract.
+*
+* Five semantic guards, each an authoring error that would otherwise reach a
+* learner:
+*
+* 1. **Prompt ids are unique** — the scorer looks a match up by prompt id, so a
+*    duplicate makes one prompt unscoreable.
+* 2. **Option ids are unique** — an answer key naming an id two options share
+*    means two right answers nobody wrote.
+* 3. **Option labels are unique**, ignoring case and surrounding space — two
+*    options both labelled "C" cannot be told apart by the key the learner
+*    answers with.
+* 4. **Every `correctOptionId` names an option.** An answer key pointing at an
+*    option nobody can pick is a prompt that cannot be passed.
+* 5. **Under `optionUse: 'once'`, no option answers two prompts.** Otherwise
+*    the item says each option is used once while its own key uses one twice.
+*/
+const MatchingDataSchema = z.looseObject({
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("matching"),
+	id: z.string().min(1),
+	title: z.string().min(1),
+	instructions: z.string().optional(),
+	optionsTitle: z.string().optional(),
+	prompts: z.array(MatchingPromptSchema).min(1),
+	options: z.array(MatchingOptionSchema).min(2),
+	optionUse: z.enum(["once", "many"]).optional(),
+	scoringStrategy: z.enum(["all-or-nothing", "partial"]),
+	shuffleOptions: z.boolean().optional(),
+	media: MediaSchema.optional(),
+	feedback: FeedbackSchema.optional(),
+	passThreshold: z.number().min(0).max(1).optional(),
+	locale: z.string().optional(),
+	learningObjectives: z.array(z.string()).optional(),
+	difficultyLevel: z.literal([
+		1,
+		2,
+		3,
+		4,
+		5
+	]).optional(),
+	ai: AiPermissionsSchema.optional()
+}).refine((data) => distinct(data.prompts.map((prompt) => prompt.id)), {
+	error: "Prompt ids must be unique.",
+	path: ["prompts"]
+}).refine((data) => distinct(data.options.map((option) => option.id)), {
+	error: "Option ids must be unique.",
+	path: ["options"]
+}).refine((data) => distinct(data.options.map((option) => option.label).filter((label) => label !== void 0).map(labelKey)), {
+	error: "Option labels must be unique.",
+	path: ["options"]
+}).refine((data) => {
+	const ids = new Set(data.options.map((option) => option.id));
+	return data.prompts.every((prompt) => ids.has(prompt.correctOptionId));
+}, {
+	error: "Each prompt needs a `correctOptionId` that is one of the options.",
+	path: ["prompts"]
+}).refine((data) => data.optionUse !== "once" || distinct(data.prompts.map((prompt) => prompt.correctOptionId)), {
+	error: "With `optionUse: \"once\"`, no option may be the answer to more than one prompt.",
+	path: ["prompts"]
+});
+// src/authoring/matching.ts
+/** Mirrors `MatchingDataSchema`: `options.min(2)`. */
+const MIN_OPTIONS$1 = 2;
+const OPTION_USES = ["once", "many"];
+/**
+* Draft support for `matching`.
+*
+* A new draft has no prompts and no options, and `scoringStrategy` starts at
+* `all-or-nothing`, as on every built-in: partial credit is the author's to
+* give — though an exam's matching task is marked prompt by prompt, so one
+* copied from a paper wants `partial`.
+*
+* As in gap-select, no answer is pre-selected: a prompt's `correctOptionId`
+* starts unwritten, and the draft stays `incomplete` until someone says which
+* option answers each prompt.
+*/
+const matchingAuthoring = {
+	createDraft: ({ newId }) => ({
+		schemaVersion: "1.0",
+		type: "matching",
+		id: newId(),
+		title: "",
+		prompts: [],
+		options: [],
+		scoringStrategy: "all-or-nothing"
+	}),
+	checkDraft: checkMatchingDraft,
+	critique: critiqueMatching
+};
+function checkMatchingDraft(draft) {
+	const issues = checkIdentity(draft, "matching");
+	issues.push(...checkScoringStrategy(draft));
+	if (!isUnset(draft.optionUse) && !OPTION_USES.includes(draft.optionUse)) issues.push(issue("mt_option_use_invalid", ["optionUse"], "Say whether each option is used \"once\" or \"many\" times, or leave it out for \"many\"."));
+	const options = isUnset(draft.options) ? [] : draft.options;
+	const optionIds = /* @__PURE__ */ new Set();
+	if (Array.isArray(options)) issues.push(...checkOptions(options, optionIds));
+	const prompts = isUnset(draft.prompts) ? [] : draft.prompts;
+	if (Array.isArray(prompts)) issues.push(...checkPrompts(prompts, optionIds, draft.optionUse === "once"));
+	issues.push(...checkSharedOptional(draft));
+	return issues;
+}
+/**
+* The shared list. Its uniqueness rules are reported at `options`, where the
+* schema reports them; what is missing from one option, at that option.
+*/
+function checkOptions(options, optionIds) {
+	const issues = [];
+	const atOptions = [];
+	if (options.length < MIN_OPTIONS$1) issues.push(issue("mt_options_too_few", ["options"], `Add at least ${MIN_OPTIONS$1} options to the list the prompts are matched with.`));
+	const repeatedIds = /* @__PURE__ */ new Set();
+	const labels = /* @__PURE__ */ new Map();
+	const repeatedLabels = /* @__PURE__ */ new Set();
+	for (const [index, option] of options.entries()) {
+		if (!isRecord(option)) continue;
+		const ordinal = index + 1;
+		if (isMissingId(option.id)) issues.push(issue("mt_option_id_required", [
+			"options",
+			index,
+			"id"
+		], `Option ${ordinal} has no id.`));
+		else if (typeof option.id === "string") {
+			if (optionIds.has(option.id)) repeatedIds.add(option.id);
+			optionIds.add(option.id);
+		}
+		if (isUnwritten(option.text)) issues.push(issue("mt_option_text_required", [
+			"options",
+			index,
+			"text"
+		], `Write the text of option ${ordinal}.`));
+		if (typeof option.label === "string" && option.label.trim() === "") issues.push(issue("mt_option_label_required", [
+			"options",
+			index,
+			"label"
+		], `Write the label of option ${ordinal}, such as "A" or "iv", or remove it.`));
+		else if (typeof option.label === "string") {
+			const key = labelKey(option.label);
+			if (labels.has(key)) repeatedLabels.add(labels.get(key));
+			else labels.set(key, option.label.trim());
+		}
+	}
+	for (const id of repeatedIds) atOptions.push(issue("mt_option_id_duplicate", ["options"], `More than one option has the id "${id}".`));
+	for (const label of repeatedLabels) atOptions.push(issue("mt_option_label_duplicate", ["options"], `More than one option is labelled "${label}". Learners answer with the label, so each needs its own.`));
+	return [...issues, ...atOptions];
+}
+/**
+* Every prompt. Its uniqueness rule and its answer key against the list are
+* reported at `prompts`, where the schema reports them; a missing id, text or
+* key, at the prompt's own field.
+*/
+function checkPrompts(prompts, optionIds, once) {
+	const issues = [];
+	const atPrompts = [];
+	if (prompts.length === 0) issues.push(issue("mt_prompts_required", ["prompts"], "Add at least one prompt to match with an option."));
+	const seen = /* @__PURE__ */ new Set();
+	const repeated = /* @__PURE__ */ new Set();
+	const answering = /* @__PURE__ */ new Map();
+	for (const [index, prompt] of prompts.entries()) {
+		if (!isRecord(prompt)) continue;
+		const ordinal = index + 1;
+		const name = typeof prompt.id === "string" && prompt.id !== "" ? `"${prompt.id}"` : ordinal;
+		if (isMissingId(prompt.id)) issues.push(issue("mt_prompt_id_required", [
+			"prompts",
+			index,
+			"id"
+		], `Prompt ${ordinal} has no id.`));
+		else if (typeof prompt.id === "string") {
+			if (seen.has(prompt.id)) repeated.add(prompt.id);
+			seen.add(prompt.id);
+		}
+		if (isUnwritten(prompt.text)) issues.push(issue("mt_prompt_text_required", [
+			"prompts",
+			index,
+			"text"
+		], `Write the text of prompt ${ordinal}.`));
+		const key = prompt.correctOptionId;
+		if (isUnwritten(key)) issues.push(issue("mt_correct_option_required", [
+			"prompts",
+			index,
+			"correctOptionId"
+		], `Choose the option that answers prompt ${name}.`));
+		else if (typeof key === "string") {
+			if (!optionIds.has(key)) atPrompts.push(issue("mt_correct_option_unknown", ["prompts"], `Prompt ${name} is answered by "${key}", which is not one of the options.`));
+			answering.set(key, [...answering.get(key) ?? [], String(name)]);
+		}
+	}
+	for (const id of repeated) atPrompts.push(issue("mt_prompt_id_duplicate", ["prompts"], `More than one prompt has the id "${id}".`));
+	if (once) {
+		for (const [optionId, names] of answering) if (names.length > 1) atPrompts.push(issue("mt_option_reused", ["prompts"], `Option "${optionId}" answers prompts ${names.join(" and ")}, but each option is used once. Choose another answer, or let options be used more than once.`));
+	}
+	return [...issues, ...atPrompts];
+}
 // src/schemas/multiple-choice.ts
 /**
 * Zod schema for a single Multiple Choice option. Loose: unknown keys are
@@ -4748,6 +5322,97 @@ const GapSelectDataSchema = z.looseObject({
 	error: "Each gap needs unique choice ids and a `correctChoiceId` that is one of the choices it offers.",
 	path: ["gaps"]
 });
+// src/schemas/mark-the-words.ts
+/** Zod schema for one target. Loose: a consumer sidecar survives validation. */
+const MarkTheWordsTargetSchema = z.looseObject({
+	text: z.string().min(1),
+	occurrence: z.number().int().min(1).optional(),
+	feedback: z.string().optional()
+});
+/** What the schema says when a target falls on no words of the text. */
+const MARK_TARGET_MESSAGES = {
+	"no-words": "A target must contain a word: punctuation alone cannot be marked.",
+	"not-found": "A target must be whole words of the text, in order, written as the text writes them.",
+	ambiguous: "These words appear more than once in the text: say which appearance with `occurrence`.",
+	"no-such-occurrence": "The text does not have that many appearances of these words."
+};
+/**
+* Zod schema validating the full Mark the Words data contract.
+*
+* Beyond the shape, three guards, each reported at the field it is about:
+*
+* 1. **The text has a word to mark**, and at most 1500 of them.
+* 2. **Every target falls on whole words of the text** — once, or at the
+*    appearance its `occurrence` names. A target that could be either of two
+*    places is refused: which one is marked right would be a guess.
+* 3. **No two targets share a word.** A word marked once cannot count twice.
+*/
+const MarkTheWordsDataSchema = z.looseObject({
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("mark-the-words"),
+	id: z.string().min(1),
+	title: z.string().min(1),
+	instructions: z.string().optional(),
+	text: z.string().min(1),
+	targets: z.array(MarkTheWordsTargetSchema).min(1),
+	scoringStrategy: z.enum(["all-or-nothing", "partial"]),
+	media: MediaSchema.optional(),
+	feedback: FeedbackSchema.optional(),
+	passThreshold: z.number().min(0).max(1).optional(),
+	locale: z.string().optional(),
+	learningObjectives: z.array(z.string()).optional(),
+	difficultyLevel: z.literal([
+		1,
+		2,
+		3,
+		4,
+		5
+	]).optional(),
+	ai: AiPermissionsSchema.optional()
+}).superRefine((data, ctx) => {
+	const words = markableWords(data.text);
+	if (words.length === 0) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "The text has no word to mark."
+		});
+		return;
+	}
+	if (words.length > 1500) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: `The text may have at most ${MARK_THE_WORDS_MAX_WORDS} words; it has ${words.length}.`
+		});
+		return;
+	}
+	const owner = /* @__PURE__ */ new Map();
+	data.targets.forEach((target, index) => {
+		const found = resolveMarkTarget(words, target);
+		if (!found.ok) {
+			ctx.addIssue({
+				code: "custom",
+				path: [
+					"targets",
+					index,
+					found.problem === "no-such-occurrence" ? "occurrence" : "text"
+				],
+				message: MARK_TARGET_MESSAGES[found.problem]
+			});
+			return;
+		}
+		if (found.indices.some((word) => owner.has(word))) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["targets", index],
+				message: "Two targets share a word: each word belongs to one target at most."
+			});
+			return;
+		}
+		for (const word of found.indices) owner.set(word, index);
+	});
+});
 // src/schemas/written-response.ts
 /** Zod schema for a single rubric criterion. Loose: unknown keys preserved. */
 const WrittenResponseRubricCriterionSchema = z.looseObject({
@@ -4946,6 +5611,48 @@ const RedactedGapSelectDataSchema = z.strictObject({
 	presentation: z.literal("dropdown").optional(),
 	shuffleChoices: z.boolean().optional()
 });
+/** A redacted matching option: unchanged, because the learner picks from the list. */
+const RedactedMatchingOptionSchema = z.strictObject({
+	id: z.string().min(1),
+	label: z.string().min(1).optional(),
+	text: z.string().min(1)
+});
+/** A redacted prompt: what the learner reads; `correctOptionId` and feedback are gone. */
+const RedactedMatchingPromptSchema = z.strictObject({
+	id: z.string().min(1),
+	text: z.string().min(1)
+});
+/**
+* Redacted Matching data. As in Gap Select, the list the learner picks from
+* survives in full and only the key is withheld: each prompt's
+* `correctOptionId`. `optionUse` survives because it changes what the learner
+* may do — an exam says "You may use any letter more than once" in its
+* instructions, and the component moves an option used once. `scoringStrategy`
+* stays answer-key, as on every type.
+*/
+const RedactedMatchingDataSchema = z.strictObject({
+	...redactedBase,
+	type: z.literal("matching"),
+	instructions: z.string().optional(),
+	optionsTitle: z.string().optional(),
+	prompts: z.array(RedactedMatchingPromptSchema).min(1),
+	options: z.array(RedactedMatchingOptionSchema).min(2),
+	optionUse: z.enum(["once", "many"]).optional(),
+	shuffleOptions: z.boolean().optional()
+});
+/**
+* Redacted Mark the Words data: the text, and nothing about which words are
+* right — not the targets, not even how many there are, since a count tells a
+* learner when to stop. `scoringStrategy` stays answer-key, as on every type:
+* whether a wrong mark costs anything is the difference between marking
+* carefully and marking everything.
+*/
+const RedactedMarkTheWordsDataSchema = z.strictObject({
+	...redactedBase,
+	type: z.literal("mark-the-words"),
+	instructions: z.string().optional(),
+	text: z.string().min(1)
+});
 /**
 * Redacted Written Response data: the prompt, word bounds and rubric are
 * learner-visible (a rubric tells the learner what they are graded on);
@@ -5185,6 +5892,104 @@ function scoreGapSelect(data, response) {
 		details
 	};
 }
+// src/scoring/activity-scorers/mark-the-words.ts
+/**
+* Scores a Mark the Words response.
+*
+* Each target is found when every one of its words is marked. Every marked
+* word that belongs to no target is a wrong mark, and costs one target's
+* worth: `partial` is (targets found − wrong marks) / targets, never below 0,
+* so marking every word is not a strategy. `all-or-nothing` is 1 only with
+* every target found and no wrong mark.
+*
+* A position that names no word, repeats one, or is not a whole number (a
+* tampered payload, or a text edited after the attempt) is ignored: it marks
+* nothing, right or wrong.
+*
+* Details: one per target (`t1`, `t2`… in target order) — `correct`, or
+* `incorrect` when only some of its words are marked, or `incorrect-omission`
+* when none are — with the target's word positions as `correctResponse`; then
+* one per wrong mark (`w` and the word's position), `incorrect`, with no
+* correct response. A review reads both to mark the text.
+*/
+function scoreMarkTheWords(data, response) {
+	const count = markableWords(data.text).length;
+	const raw = Array.isArray(response.marked) ? response.marked : [];
+	const marked = new Set(raw.filter((word) => typeof word === "number" && Number.isInteger(word) && word >= 0).filter((word) => word < count));
+	const targets = markTargetIndices(data);
+	const inTargets = new Set(targets.flat());
+	const details = [];
+	let found = 0;
+	targets.forEach((words, index) => {
+		const hit = words.filter((word) => marked.has(word));
+		const correct = words.length > 0 && hit.length === words.length;
+		if (correct) found += 1;
+		details.push({
+			itemId: `t${index + 1}`,
+			outcome: correct ? "correct" : hit.length > 0 ? "incorrect" : "incorrect-omission",
+			learnerResponse: hit.map(String),
+			correctResponse: words.map(String),
+			weight: 1
+		});
+	});
+	const wrong = [...marked].filter((word) => !inTargets.has(word)).sort((a, b) => a - b);
+	for (const word of wrong) details.push({
+		itemId: `w${word}`,
+		outcome: "incorrect",
+		learnerResponse: [String(word)],
+		correctResponse: [],
+		weight: 1
+	});
+	const total = targets.length;
+	return {
+		score: total === 0 ? 0 : data.scoringStrategy === "all-or-nothing" ? found === total && wrong.length === 0 ? 1 : 0 : Math.max(0, found - wrong.length) / total,
+		maxScore: 1,
+		feedback: null,
+		details
+	};
+}
+// src/scoring/activity-scorers/matching.ts
+/**
+* Scores a Matching response.
+*
+* Each prompt is an identity comparison between the option the learner matched
+* it with and `correctOptionId`, as a gap select's gap is. A prompt with no
+* match, or matched with an id that is not an option (a tampered payload, or
+* content edited after the attempt), is scored incorrect and reported as
+* `incorrect-omission`, so an unanswered prompt stays distinguishable from a
+* wrong one downstream.
+*
+* Under `optionUse: 'once'` a response that uses one option twice is scored
+* prompt by prompt like any other: the SDK's component never produces one, and
+* a second use earns nothing the key does not give it, since the key uses each
+* option at most once.
+*/
+function scoreMatching(data, response) {
+	const optionIds = new Set(data.options.map((option) => option.id));
+	const details = [];
+	const perPromptCorrect = [];
+	for (const prompt of data.prompts) {
+		const raw = response.matches[prompt.id];
+		const matched = typeof raw === "string" ? raw : "";
+		const answered = matched !== "" && optionIds.has(matched);
+		const correct = answered && matched === prompt.correctOptionId;
+		perPromptCorrect.push(correct);
+		details.push({
+			itemId: prompt.id,
+			outcome: correct ? "correct" : answered ? "incorrect" : "incorrect-omission",
+			learnerResponse: [matched],
+			correctResponse: [prompt.correctOptionId],
+			weight: 1
+		});
+	}
+	const correctPrompts = perPromptCorrect.filter(Boolean).length;
+	return {
+		score: data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perPromptCorrect) : partialBlankStrategy(correctPrompts, data.prompts.length),
+		maxScore: 1,
+		feedback: null,
+		details
+	};
+}
 // src/scoring/activity-scorers/multiple-choice.ts
 /**
 * Scores a Multiple Choice response. Pure; trusts its typed inputs (validation
@@ -5447,6 +6252,45 @@ const GAP_SELECT_FIELD_POLICY = {
 		feedback: "answer-key"
 	}
 };
+/**
+* Matching: as in Gap Select, the list the learner picks from is public, key
+* by key, and each prompt's `correctOptionId` is the one field withheld.
+* `optionUse` is public because it changes what the learner may do: the
+* component moves an option used once, and the paper says so.
+*/
+const MATCHING_FIELD_POLICY = {
+	...SHARED_PUBLIC_FIELDS,
+	instructions: "public",
+	optionsTitle: "public",
+	optionUse: "public",
+	shuffleOptions: "public",
+	scoringStrategy: "answer-key",
+	feedback: FEEDBACK_FIELD_POLICY,
+	options: {
+		id: "public",
+		label: "public",
+		text: "public"
+	},
+	prompts: {
+		id: "public",
+		text: "public",
+		correctOptionId: "answer-key",
+		feedback: "answer-key"
+	}
+};
+/**
+* Mark the Words: the text is what the learner marks in, so it is public; the
+* targets are the key, as one leaf — their number included, since a count
+* tells a learner when to stop marking.
+*/
+const MARK_THE_WORDS_FIELD_POLICY = {
+	...SHARED_PUBLIC_FIELDS,
+	instructions: "public",
+	text: "public",
+	targets: "answer-key",
+	scoringStrategy: "answer-key",
+	feedback: FEEDBACK_FIELD_POLICY
+};
 const FILL_IN_THE_BLANKS_FIELD_POLICY = {
 	...SHARED_PUBLIC_FIELDS,
 	instructions: "public",
@@ -5627,6 +6471,50 @@ const gapSelectType = defineActivityType({
 	authoring: gapSelectAuthoring,
 	mediaSlots: () => MAIN_MEDIA
 });
+/** Built-in Matching descriptor. */
+const matchingType = defineActivityType({
+	type: "matching",
+	schema: MatchingDataSchema,
+	scoring: {
+		kind: "sync",
+		score: scoreMatching
+	},
+	isAnswered: (response) => Object.values(response?.matches ?? {}).some((optionId) => optionId !== ""),
+	fieldPolicy: MATCHING_FIELD_POLICY,
+	redactedSchema: RedactedMatchingDataSchema,
+	interop: {
+		xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+		xapiInteractionType: "matching",
+		correctResponsesPattern: (data) => [data.prompts.map((prompt) => `${prompt.id}[.]${prompt.correctOptionId}`).join("[,]")]
+	},
+	interactions: ["option-matched", "submitted"],
+	authoring: matchingAuthoring,
+	mediaSlots: () => MAIN_MEDIA
+});
+/** Built-in Mark the Words descriptor. */
+const markTheWordsType = defineActivityType({
+	type: "mark-the-words",
+	schema: MarkTheWordsDataSchema,
+	scoring: {
+		kind: "sync",
+		score: scoreMarkTheWords
+	},
+	isAnswered: (response) => Array.isArray(response?.marked) && response.marked.length > 0,
+	fieldPolicy: MARK_THE_WORDS_FIELD_POLICY,
+	redactedSchema: RedactedMarkTheWordsDataSchema,
+	interop: {
+		xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+		xapiInteractionType: "choice",
+		correctResponsesPattern: (data) => [markTargetIndices(data).flat().sort((a, b) => a - b).join("[,]")]
+	},
+	interactions: [
+		"word-marked",
+		"word-unmarked",
+		"submitted"
+	],
+	authoring: markTheWordsAuthoring,
+	mediaSlots: () => MAIN_MEDIA
+});
 /**
 * Built-in Dictation descriptor. Graded synchronously: the score is the
 * character-level similarity of the typed text to the transcript, a pure
@@ -5803,7 +6691,9 @@ const BUILT_IN_DESCRIPTORS = {
 		],
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
-	})
+	}),
+	matching: matchingType,
+	"mark-the-words": markTheWordsType
 };
 // src/schemas/read-schema.ts
 /**
@@ -5967,6 +6857,6 @@ function getActivityTypeDescriptor(type) {
 function registeredActivityTypes() {
 	return [...registry.keys()];
 }
-export { GROUP_CAPTIONS_REVEAL_DICTATION as $, keyPositionFinding as A, SCRIPT_MAX_TURNS as At, countWords as B, READ_ALOUD_MAX_REFERENCE_LENGTH as C, passageWithoutPlaceholders as Ct, SPEECH_ASSESSMENT_MAX_WORDS as D, PLACEHOLDER_RE as Dt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as E, FillInTheBlanksDataSchema as Et, matchText as F, isMissingId as G, checkMedia as H, LEVEL_PROBABILITY_TOLERANCE as I, isUnwritten as J, isRecord as K, levelDistribution as L, normaliseFinding as M, maxUnits as Mt, policyFor as N, MultipleChoiceDataSchema as O, MediaSchema as Ot, levenshteinDistance as P, DictationDataSchema as Q, levelKey as R, READ_ALOUD_MAX_DIMENSION_WEIGHT as S, numberedPassage as St, READ_ALOUD_MAX_TAKES as T, revealsAnswer as Tt, coveredPathsOf as U, DRAFT_ISSUE_SEVERITY as V, covers as W, pathKey as X, issue as Y, refusesEmpty as Z, GapSelectDataSchema as _, BUILT_IN_ACTIVITY_TYPES as _t, readSchema as a, STEP as at, ReadAloudDataSchema as b, containsWords as bt, dictationType as c, dictationReferenceWords as ct, multipleChoiceType as d, DICTATION_MAX_EQUIVALENCE_LENGTH as dt, groupCaptionsField as et, readAloudType as f, DICTATION_MAX_TEXT_LENGTH as ft, WrittenResponseDataSchema as g, withValidationScope as gt, defineActivityType as h, normalizeDictationText as ht, isOwnSchema as i, UnknownActivityTypeError as it, finding as j, ScriptSchema as jt, MultipleChoiceOptionMediaSchema as k, RedactedMediaSchema as kt, fillInTheBlanksType as l, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as lt, guardOf as m, codePointLength as mt, registerActivityType as n, DeferredScoringError as nt, standardJsonSchemaOf as o, alignDictation as ot, writtenResponseType as p, DICTATION_MAX_TRANSCRIPT_LENGTH as pt, isUnset as q, registeredActivityTypes as r, RedactedScoringError as rt, MEDIA_FIELD_POLICY as s, alignSequences as st, getActivityTypeDescriptor as t, ActivitySchemaError as tt, gapSelectType as u, DICTATION_MAX_EQUIVALENCES as ut, SPEAKING_MEASURES as v, everyBuiltInTypeHandled as vt, READ_ALOUD_MAX_SECONDS as w, placeholderOrder as wt, CANONICAL_LOCALE_RE as x, fold as xt, SpeakingResponseDataSchema as y, isBuiltInActivityType as yt, readRubricLevels as z };
+export { isUnset as $, MARK_THE_WORDS_MAX_WORDS as A, placeholderOrder as At, levenshteinDistance as B, READ_ALOUD_MAX_REFERENCE_LENGTH as C, BUILT_IN_ACTIVITY_TYPES as Ct, SPEECH_ASSESSMENT_MAX_WORDS as D, fold as Dt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as E, containsWords as Et, resolveMarkTarget as F, RedactedMediaSchema as Ft, readRubricLevels as G, LEVEL_PROBABILITY_TOLERANCE as H, keyPositionFinding as I, SCRIPT_MAX_TURNS as It, checkMedia as J, countWords as K, finding as L, ScriptSchema as Lt, markTargetIndices as M, FillInTheBlanksDataSchema as Mt, markTheWordsFromMarkup as N, PLACEHOLDER_RE as Nt, MultipleChoiceDataSchema as O, numberedPassage as Ot, markableWords as P, MediaSchema as Pt, isRecord as Q, normaliseFinding as R, maxUnits as Rt, READ_ALOUD_MAX_DIMENSION_WEIGHT as S, withValidationScope as St, READ_ALOUD_MAX_TAKES as T, isBuiltInActivityType as Tt, levelDistribution as U, matchText as V, levelKey as W, covers as X, coveredPathsOf as Y, isMissingId as Z, GapSelectDataSchema as _, DICTATION_MAX_EQUIVALENCE_LENGTH as _t, readSchema as a, GROUP_CAPTIONS_REVEAL_DICTATION as at, ReadAloudDataSchema as b, codePointLength as bt, dictationType as c, DeferredScoringError as ct, multipleChoiceType as d, STEP as dt, isUnwritten as et, readAloudType as f, alignDictation as ft, WrittenResponseDataSchema as g, DICTATION_MAX_EQUIVALENCES as gt, defineActivityType as h, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as ht, isOwnSchema as i, DictationDataSchema as it, MARK_THE_WORDS_TOKENIZER as j, revealsAnswer as jt, MultipleChoiceOptionMediaSchema as k, passageWithoutPlaceholders as kt, fillInTheBlanksType as l, RedactedScoringError as lt, guardOf as m, dictationReferenceWords as mt, registerActivityType as n, pathKey as nt, standardJsonSchemaOf as o, groupCaptionsField as ot, writtenResponseType as p, alignSequences as pt, DRAFT_ISSUE_SEVERITY as q, registeredActivityTypes as r, refusesEmpty as rt, MEDIA_FIELD_POLICY as s, ActivitySchemaError as st, getActivityTypeDescriptor as t, issue as tt, gapSelectType as u, UnknownActivityTypeError as ut, SPEAKING_MEASURES as v, DICTATION_MAX_TEXT_LENGTH as vt, READ_ALOUD_MAX_SECONDS as w, everyBuiltInTypeHandled as wt, CANONICAL_LOCALE_RE as x, normalizeDictationText as xt, SpeakingResponseDataSchema as y, DICTATION_MAX_TRANSCRIPT_LENGTH as yt, policyFor as z };
 
-//# sourceMappingURL=registry-BClnM5V3.js.map
+//# sourceMappingURL=registry-CroAI5nc.js.map