@intellectif/lk-core 1.11.0 → 1.13.0

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

@@ -464,7 +464,8 @@ const BUILT_IN_ACTIVITY_TYPES = [
 	"gap-select",
 	"dictation",
 	"read-aloud",
-	"speaking-response"
+	"speaking-response",
+	"matching"
 ];
 /** Whether `type` names an activity type the SDK ships. */
 function isBuiltInActivityType(type) {
@@ -2304,6 +2305,7 @@ const DRAFT_ISSUE_SEVERITY = {
 	ig_route_stimulus_kind: "invalid",
 	ig_route_body_required: "incomplete",
 	ig_route_with_timeline: "invalid",
+	ig_route_quiz_mixed: "invalid",
 	ig_route_shuffle: "invalid",
 	ig_route_item_type: "invalid",
 	ig_route_question_item_unknown: "invalid",
@@ -2348,6 +2350,20 @@ 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",
 	wr_prompt_required: "incomplete",
 	wr_min_words_required: "incomplete",
 	wr_min_words_invalid: "invalid",
@@ -3107,6 +3123,10 @@ 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",
 	wr_criterion_name_duplicate: "warning",
 	wr_levels_unreadable: "warning",
 	ra_text_long_for_time: "warning",
@@ -3377,6 +3397,40 @@ 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) {
+	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(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(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`,
@@ -3766,6 +3820,219 @@ 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/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
@@ -4967,6 +5234,35 @@ 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 Written Response data: the prompt, word bounds and rubric are
 * learner-visible (a rubric tells the learner what they are graded on);
@@ -5206,6 +5502,48 @@ function scoreGapSelect(data, response) {
 		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
@@ -5468,6 +5806,32 @@ 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"
+	}
+};
 const FILL_IN_THE_BLANKS_FIELD_POLICY = {
 	...SHARED_PUBLIC_FIELDS,
 	instructions: "public",
@@ -5648,6 +6012,26 @@ 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 Dictation descriptor. Graded synchronously: the score is the
 * character-level similarity of the typed text to the transcript, a pure
@@ -5824,7 +6208,8 @@ const BUILT_IN_DESCRIPTORS = {
 		],
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
-	})
+	}),
+	matching: matchingType
 };
 // src/schemas/read-schema.ts
 /**
@@ -6511,4 +6896,4 @@ Object.defineProperty(exports, "writtenResponseType", {
 	}
 });
 
-//# sourceMappingURL=registry-RPfZZEqi.cjs.map
+//# sourceMappingURL=registry-DUTE1vtq.cjs.map