@intellectif/lk-core 1.13.0 → 1.14.0

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

@@ -465,7 +465,8 @@ const BUILT_IN_ACTIVITY_TYPES = [
 	"dictation",
 	"read-aloud",
 	"speaking-response",
-	"matching"
+	"matching",
+	"mark-the-words"
 ];
 /** Whether `type` names an activity type the SDK ships. */
 function isBuiltInActivityType(type) {
@@ -1076,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;
@@ -1090,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) {
@@ -1320,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;
@@ -2364,6 +2365,15 @@ const DRAFT_ISSUE_SEVERITY = {
 	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",
@@ -3127,6 +3137,9 @@ const ITEM_FINDING_SEVERITY = {
 	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",
@@ -3398,7 +3411,7 @@ function critiqueGapSelect(draft) {
 	return findings;
 }
 /** Whether `text` writes out `answer` as whole words — an answer of one short word never counts. */
-function writesOut(text, answer) {
+function writesOut$1(text, answer) {
 	const needle = fold(answer);
 	return needle.length > 0 && !isShort(needle) && containsWords(fold(text), needle);
 }
@@ -3411,7 +3424,7 @@ function critiqueMatching(draft) {
 	const title = written(draft.title);
 	if (title !== void 0 && prompts.some((prompt) => {
 		const answer = answerOf(prompt);
-		return answer !== void 0 && writesOut(title, answer);
+		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",
@@ -3421,7 +3434,7 @@ function critiqueMatching(draft) {
 	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(text, answer)) findings.push(finding("mt_answer_in_prompt", [
+		if (text !== void 0 && answer !== void 0 && writesOut$1(text, answer)) findings.push(finding("mt_answer_in_prompt", [
 			"prompts",
 			index,
 			"text"
@@ -3820,6 +3833,301 @@ 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({
@@ -5036,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({
@@ -5264,6 +5663,19 @@ const RedactedMatchingDataSchema = zod_v4.strictObject({
 	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);
 * authored pass/fail feedback is removed until the grade exists.
@@ -5502,6 +5914,62 @@ 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.
@@ -5832,6 +6300,19 @@ const MATCHING_FIELD_POLICY = {
 		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",
@@ -6032,6 +6513,30 @@ const matchingType = defineActivityType({
 	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
@@ -6209,7 +6714,8 @@ const BUILT_IN_DESCRIPTORS = {
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
 	}),
-	matching: matchingType
+	matching: matchingType,
+	"mark-the-words": markTheWordsType
 };
 // src/schemas/read-schema.ts
 /**
@@ -6463,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() {
@@ -6775,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() {
@@ -6871,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() {
@@ -6896,4 +7438,4 @@ Object.defineProperty(exports, "writtenResponseType", {
 	}
 });
 
-//# sourceMappingURL=registry-DUTE1vtq.cjs.map
+//# sourceMappingURL=registry-Dw19lNo2.cjs.map