@intellectif/lk-core 1.12.0 → 1.14.0

package/dist/{registry-DgLcT4rZ.cjs → registry-Dw19lNo2.cjs}

@@ -464,7 +464,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) {
@@ -1075,7 +1077,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;
@@ -1089,7 +1091,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) {
@@ -1319,12 +1321,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;
@@ -2349,6 +2351,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",
@@ -3108,6 +3133,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",
@@ -3378,6 +3410,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`,
@@ -3767,6 +3833,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 = zod_v4.looseObject({
+	id: zod_v4.string().min(1),
+	label: zod_v4.string().min(1).optional(),
+	text: zod_v4.string().min(1)
+});
+/** Zod schema for one prompt. Whether its `correctOptionId` exists is checked on the activity. */
+const MatchingPromptSchema = zod_v4.looseObject({
+	id: zod_v4.string().min(1),
+	text: zod_v4.string().min(1),
+	correctOptionId: zod_v4.string().min(1),
+	feedback: zod_v4.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 = zod_v4.looseObject({
+	schemaVersion: zod_v4.literal("1.0"),
+	type: zod_v4.literal("matching"),
+	id: zod_v4.string().min(1),
+	title: zod_v4.string().min(1),
+	instructions: zod_v4.string().optional(),
+	optionsTitle: zod_v4.string().optional(),
+	prompts: zod_v4.array(MatchingPromptSchema).min(1),
+	options: zod_v4.array(MatchingOptionSchema).min(2),
+	optionUse: zod_v4.enum(["once", "many"]).optional(),
+	scoringStrategy: zod_v4.enum(["all-or-nothing", "partial"]),
+	shuffleOptions: zod_v4.boolean().optional(),
+	media: MediaSchema.optional(),
+	feedback: FeedbackSchema.optional(),
+	passThreshold: zod_v4.number().min(0).max(1).optional(),
+	locale: zod_v4.string().optional(),
+	learningObjectives: zod_v4.array(zod_v4.string()).optional(),
+	difficultyLevel: zod_v4.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
@@ -4770,6 +5344,97 @@ const GapSelectDataSchema = zod_v4.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 = zod_v4.looseObject({
+	text: zod_v4.string().min(1),
+	occurrence: zod_v4.number().int().min(1).optional(),
+	feedback: zod_v4.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 = zod_v4.looseObject({
+	schemaVersion: zod_v4.literal("1.0"),
+	type: zod_v4.literal("mark-the-words"),
+	id: zod_v4.string().min(1),
+	title: zod_v4.string().min(1),
+	instructions: zod_v4.string().optional(),
+	text: zod_v4.string().min(1),
+	targets: zod_v4.array(MarkTheWordsTargetSchema).min(1),
+	scoringStrategy: zod_v4.enum(["all-or-nothing", "partial"]),
+	media: MediaSchema.optional(),
+	feedback: FeedbackSchema.optional(),
+	passThreshold: zod_v4.number().min(0).max(1).optional(),
+	locale: zod_v4.string().optional(),
+	learningObjectives: zod_v4.array(zod_v4.string()).optional(),
+	difficultyLevel: zod_v4.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 = zod_v4.looseObject({
@@ -4968,6 +5633,48 @@ const RedactedGapSelectDataSchema = zod_v4.strictObject({
 	presentation: zod_v4.literal("dropdown").optional(),
 	shuffleChoices: zod_v4.boolean().optional()
 });
+/** A redacted matching option: unchanged, because the learner picks from the list. */
+const RedactedMatchingOptionSchema = zod_v4.strictObject({
+	id: zod_v4.string().min(1),
+	label: zod_v4.string().min(1).optional(),
+	text: zod_v4.string().min(1)
+});
+/** A redacted prompt: what the learner reads; `correctOptionId` and feedback are gone. */
+const RedactedMatchingPromptSchema = zod_v4.strictObject({
+	id: zod_v4.string().min(1),
+	text: zod_v4.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 = zod_v4.strictObject({
+	...redactedBase,
+	type: zod_v4.literal("matching"),
+	instructions: zod_v4.string().optional(),
+	optionsTitle: zod_v4.string().optional(),
+	prompts: zod_v4.array(RedactedMatchingPromptSchema).min(1),
+	options: zod_v4.array(RedactedMatchingOptionSchema).min(2),
+	optionUse: zod_v4.enum(["once", "many"]).optional(),
+	shuffleOptions: zod_v4.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 = zod_v4.strictObject({
+	...redactedBase,
+	type: zod_v4.literal("mark-the-words"),
+	instructions: zod_v4.string().optional(),
+	text: zod_v4.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);
@@ -5207,6 +5914,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
@@ -5469,6 +6274,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",
@@ -5649,6 +6493,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
@@ -5825,7 +6713,9 @@ const BUILT_IN_DESCRIPTORS = {
 		],
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
-	})
+	}),
+	matching: matchingType,
+	"mark-the-words": markTheWordsType
 };
 // src/schemas/read-schema.ts
 /**
@@ -6079,6 +6969,18 @@ Object.defineProperty(exports, "LEVEL_PROBABILITY_TOLERANCE", {
 		return LEVEL_PROBABILITY_TOLERANCE;
 	}
 });
+Object.defineProperty(exports, "MARK_THE_WORDS_MAX_WORDS", {
+	enumerable: true,
+	get: function() {
+		return MARK_THE_WORDS_MAX_WORDS;
+	}
+});
+Object.defineProperty(exports, "MARK_THE_WORDS_TOKENIZER", {
+	enumerable: true,
+	get: function() {
+		return MARK_THE_WORDS_TOKENIZER;
+	}
+});
 Object.defineProperty(exports, "MEDIA_FIELD_POLICY", {
 	enumerable: true,
 	get: function() {
@@ -6391,6 +7293,24 @@ Object.defineProperty(exports, "levenshteinDistance", {
 		return levenshteinDistance;
 	}
 });
+Object.defineProperty(exports, "markTargetIndices", {
+	enumerable: true,
+	get: function() {
+		return markTargetIndices;
+	}
+});
+Object.defineProperty(exports, "markTheWordsFromMarkup", {
+	enumerable: true,
+	get: function() {
+		return markTheWordsFromMarkup;
+	}
+});
+Object.defineProperty(exports, "markableWords", {
+	enumerable: true,
+	get: function() {
+		return markableWords;
+	}
+});
 Object.defineProperty(exports, "matchText", {
 	enumerable: true,
 	get: function() {
@@ -6487,6 +7407,12 @@ Object.defineProperty(exports, "registeredActivityTypes", {
 		return registeredActivityTypes;
 	}
 });
+Object.defineProperty(exports, "resolveMarkTarget", {
+	enumerable: true,
+	get: function() {
+		return resolveMarkTarget;
+	}
+});
 Object.defineProperty(exports, "revealsAnswer", {
 	enumerable: true,
 	get: function() {
@@ -6512,4 +7438,4 @@ Object.defineProperty(exports, "writtenResponseType", {
 	}
 });
 
-//# sourceMappingURL=registry-DgLcT4rZ.cjs.map
+//# sourceMappingURL=registry-Dw19lNo2.cjs.map