@intellectif/lk-core 1.13.0 → 1.14.0

package/dist/{registry-Cn2it-y7.js → registry-CroAI5nc.js}

@@ -443,7 +443,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) {
@@ -1054,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;
@@ -1068,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) {
@@ -1298,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;
@@ -2342,6 +2343,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",
@@ -3105,6 +3115,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",
@@ -3376,7 +3389,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);
 }
@@ -3389,7 +3402,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",
@@ -3399,7 +3412,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"
@@ -3798,6 +3811,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 = z.looseObject({
@@ -5014,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({
@@ -5242,6 +5641,19 @@ const RedactedMatchingDataSchema = z.strictObject({
 	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);
 * authored pass/fail feedback is removed until the grade exists.
@@ -5480,6 +5892,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.
@@ -5810,6 +6278,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",
@@ -6010,6 +6491,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
@@ -6187,7 +6692,8 @@ const BUILT_IN_DESCRIPTORS = {
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
 	}),
-	matching: matchingType
+	matching: matchingType,
+	"mark-the-words": markTheWordsType
 };
 // src/schemas/read-schema.ts
 /**
@@ -6351,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-Cn2it-y7.js.map
+//# sourceMappingURL=registry-CroAI5nc.js.map