@intellectif/lk-core 1.7.0 → 1.9.0

package/dist/{ai-writing-B7oMCt66.js → ai-writing-DQjI9EFN.js}

@@ -1,6 +1,6 @@
-import { A as normaliseFinding, B as coveredPathsOf, F as levelKey, G as isUnwritten, H as isMissingId, I as readRubricLevels, J as refusesEmpty, K as issue, L as countWords, N as LEVEL_PROBABILITY_TOLERANCE, O as keyPositionFinding, P as levelDistribution, R as DRAFT_ISSUE_SEVERITY, U as isRecord$6, V as covers, W as isUnset, X as GROUP_CAPTIONS_REVEAL_DICTATION, Z as groupCaptionsField, _t as containsWords, a as readSchema, bt as placeholderOrder, k as finding, pt as withValidationScope, q as pathKey, rt as alignDictation, t as getActivityTypeDescriptor, tt as UnknownActivityTypeError, vt as fold, xt as revealsAnswer, yt as numberedPassage, z as checkMedia } from "./registry-D92hz9iA.js";
-import { F as isGradeInRange, _ as gradeFromRubric, c as validateSpeechAssessment, r as score, s as alignReadAloud } from "./scoring-DD1GHcLI.js";
-import { a as INTERACTIVE_VIDEO_ITEM_TYPES, i as validateItemGroup, t as ItemGroupSchema, u as isInteractiveVideoItemType } from "./item-group-CeDk7mfM.js";
+import { $ as GROUP_CAPTIONS_REVEAL_DICTATION, A as keyPositionFinding, B as countWords, Ct as passageWithoutPlaceholders, Dt as PLACEHOLDER_RE, G as isMissingId, H as checkMedia, I as LEVEL_PROBABILITY_TOLERANCE, J as isUnwritten, K as isRecord$8, L as levelDistribution, M as normaliseFinding, N as policyFor, R as levelKey, St as numberedPassage, Tt as revealsAnswer, U as coveredPathsOf, V as DRAFT_ISSUE_SEVERITY, W as covers, X as pathKey, Y as issue, Z as refusesEmpty, a as readSchema, bt as containsWords, et as groupCaptionsField, gt as withValidationScope, it as UnknownActivityTypeError, j as finding, ot as alignDictation, q as isUnset, t as getActivityTypeDescriptor, v as SPEAKING_MEASURES, wt as placeholderOrder, xt as fold, z as readRubricLevels } from "./registry-Bw9grsCN.js";
+import { C as canonicalJson, I as isGradeInRange, c as alignReadAloud, g as seededShuffle, l as validateSpeechAssessment, r as score, v as gradeFromRubric } from "./scoring-BGKdff2i.js";
+import { a as INTERACTIVE_VIDEO_ITEM_TYPES, i as validateItemGroup, t as ItemGroupSchema, u as isInteractiveVideoItemType } from "./item-group-CKZk3txt.js";
 // src/ai-material.ts
 /**
 * What a model is told about the group a question sits in: the material the
@@ -28,7 +28,7 @@ const MEDIA_TYPES = {
 	video: true,
 	embed: true
 };
-const isRecord$5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A string with something in it, as written; otherwise nothing. */
 const filled = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
 /**
@@ -62,17 +62,17 @@ function cut(text) {
 * and a signed address must not end up in a prompt. Each field is read once.
 */
 function materialFacts(group) {
-	if (!isRecord$5(group)) return null;
+	if (!isRecord$7(group)) return null;
 	const stimulus = group.stimulus;
-	if (!isRecord$5(stimulus)) return null;
+	if (!isRecord$7(stimulus)) return null;
 	const kind = stimulus.kind;
 	if (typeof kind !== "string" || !Object.hasOwn(KINDS$2, kind)) return null;
 	const title = filled(stimulus.title) ?? filled(group.title);
 	const body = filled(stimulus.body);
 	const text = body === void 0 ? void 0 : cut(body);
 	const rawMedia = stimulus.media;
-	const mediaType = isRecord$5(rawMedia) ? rawMedia.type : void 0;
-	const alt = isRecord$5(rawMedia) ? filled(rawMedia.alt) : void 0;
+	const mediaType = isRecord$7(rawMedia) ? rawMedia.type : void 0;
+	const alt = isRecord$7(rawMedia) ? filled(rawMedia.alt) : void 0;
 	const media = typeof mediaType === "string" && Object.hasOwn(MEDIA_TYPES, mediaType) ? {
 		type: mediaType,
 		...alt !== void 0 ? { alt } : {}
@@ -254,7 +254,7 @@ function isAnswerOption(detail, chosen) {
 	}
 }
 const firstString = (value) => Array.isArray(value) ? value[0] : value;
-const listOf$1 = (value) => value === void 0 ? null : Array.isArray(value) ? [...value] : [value];
+const listOf$4 = (value) => value === void 0 ? null : Array.isArray(value) ? [...value] : [value];
 /** The response a learner has before touching anything. */
 function emptyResponse(type) {
 	switch (type) {
@@ -337,7 +337,7 @@ function buildAiFacts(data, response, details) {
 				blanks: placeholderOrder(item.passage).map((id, index) => {
 					const blank = blanks.get(id);
 					const detail = byId.get(id);
-					const accepted = full && Array.isArray(blank?.acceptedAnswers) ? [...blank.acceptedAnswers] : listOf$1(detail?.correctResponse);
+					const accepted = full && Array.isArray(blank?.acceptedAnswers) ? [...blank.acceptedAnswers] : listOf$4(detail?.correctResponse);
 					return {
 						id,
 						position: index + 1,
@@ -747,7 +747,7 @@ function aiCoachingRequest(input) {
 		...learnerLocale !== void 0 ? { learnerLocale } : {}
 	};
 }
-const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A symbol as it is compared: composed, and without the spaces around it. */
 const symbolKey = (symbol) => symbol.normalize("NFC").trim();
 /**
@@ -796,7 +796,7 @@ function checkAiCoaching(raw, request) {
 		});
 		const seen = /* @__PURE__ */ new Set();
 		for (const entry of entries) {
-			if (!isRecord$4(entry) || typeof entry.itemId !== "string" || typeof entry.tip !== "string") return {
+			if (!isRecord$6(entry) || typeof entry.itemId !== "string" || typeof entry.tip !== "string") return {
 				ok: false,
 				refusal: "malformed"
 			};
@@ -844,7 +844,7 @@ function checkAiCoaching(raw, request) {
 /** A sound a model names, checked against the sounds the engine reported for the word. */
 function checkSound(raw, fact) {
 	if (raw === void 0 || raw === null) return;
-	if (!isRecord$4(raw) || typeof raw.expected !== "string" || raw.heard !== void 0 && raw.heard !== null && typeof raw.heard !== "string") return {
+	if (!isRecord$6(raw) || typeof raw.expected !== "string" || raw.heard !== void 0 && raw.heard !== null && typeof raw.heard !== "string") return {
 		ok: false,
 		refusal: "malformed"
 	};
@@ -877,13 +877,13 @@ const MAIN_KINDS = [
 	"image",
 	"embed"
 ];
-function isRecord$3(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function valueAt(root, path) {
 	let at = root;
 	for (const key of path) {
-		if (typeof key === "number" ? !Array.isArray(at) : !isRecord$3(at)) return;
+		if (typeof key === "number" ? !Array.isArray(at) : !isRecord$5(at)) return;
 		at = at[key];
 	}
 	return at;
@@ -896,7 +896,7 @@ function slotsOf(item) {
 	return Array.isArray(slots) ? slots : [];
 }
 function holderRefs(holder, path, kindOfSlot, owner) {
-	if (!isRecord$3(holder)) return [];
+	if (!isRecord$5(holder)) return [];
 	const main = typeof holder.type === "string" && MAIN_KINDS.includes(holder.type) ? holder.type : kindOfSlot;
 	const refs = [];
 	const add = (field, kind, url) => {
@@ -911,7 +911,7 @@ function holderRefs(holder, path, kindOfSlot, owner) {
 	if (main !== void 0) add(["url"], main, typeof holder.url === "string" ? holder.url : null);
 	if (typeof holder.captionsUrl === "string") add(["captionsUrl"], "captions", holder.captionsUrl);
 	if (Array.isArray(holder.tracks)) holder.tracks.forEach((track, index) => {
-		if (isRecord$3(track) && typeof track.src === "string") refs.push({
+		if (isRecord$5(track) && typeof track.src === "string") refs.push({
 			path: [
 				...path,
 				"tracks",
@@ -929,7 +929,7 @@ function holderRefs(holder, path, kindOfSlot, owner) {
 	return refs;
 }
 function activityRefs(item, base) {
-	if (!isRecord$3(item)) return [];
+	if (!isRecord$5(item)) return [];
 	const owner = typeof item.id === "string" ? { activityId: item.id } : {};
 	return slotsOf(item).flatMap((slot) => holderRefs(valueAt(item, slot.path), [...base, ...slot.path], slot.kind, owner));
 }
@@ -954,11 +954,11 @@ function activityRefs(item, base) {
 * ```
 */
 function listMediaRefs(entry) {
-	if (!isRecord$3(entry)) return [];
+	if (!isRecord$5(entry)) return [];
 	if (entry.type !== "item-group") return activityRefs(entry, []);
 	const refs = [];
 	const stimulus = entry.stimulus;
-	if (isRecord$3(stimulus)) {
+	if (isRecord$5(stimulus)) {
 		const owner = typeof stimulus.id === "string" ? { stimulusId: stimulus.id } : {};
 		refs.push(...holderRefs(stimulus.media, ["stimulus", "media"], void 0, owner));
 	}
@@ -1018,7 +1018,7 @@ function mapMediaRefs(entry, fn) {
 /** A holder's own text: its transcript, else its script as "Speaker: text" lines. */
 function ownText(holder) {
 	if (typeof holder.transcript === "string" && holder.transcript.trim() !== "") return holder.transcript;
-	const turns = Array.isArray(holder.script) ? holder.script.flatMap((turn) => isRecord$3(turn) && typeof turn.speaker === "string" && typeof turn.text === "string" && turn.text.trim() !== "" ? [`${turn.speaker.trim()}: ${turn.text.trim()}`] : []) : [];
+	const turns = Array.isArray(holder.script) ? holder.script.flatMap((turn) => isRecord$5(turn) && typeof turn.speaker === "string" && typeof turn.text === "string" && turn.text.trim() !== "" ? [`${turn.speaker.trim()}: ${turn.text.trim()}`] : []) : [];
 	return turns.length > 0 ? turns.join("\n") : null;
 }
 /**
@@ -1036,14 +1036,14 @@ function ownText(holder) {
 * ```
 */
 function transcriptOf(holder) {
-	if (!isRecord$3(holder)) return null;
-	return ownText(holder) ?? (isRecord$3(holder.media) ? ownText(holder.media) : null);
+	if (!isRecord$5(holder)) return null;
+	return ownText(holder) ?? (isRecord$5(holder.media) ? ownText(holder.media) : null);
 }
 // src/authoring/recordings.ts
-const written$1 = (value) => typeof value === "string" && value.trim() !== "";
+const written$2 = (value) => typeof value === "string" && value.trim() !== "";
 /** The script's turns that have a speaker and words, or none. */
-function turnsOf(script) {
-	return Array.isArray(script) ? script.flatMap((turn) => isRecord$6(turn) && typeof turn.speaker === "string" && written$1(turn.text) ? [{
+function turnsOf$1(script) {
+	return Array.isArray(script) ? script.flatMap((turn) => isRecord$8(turn) && typeof turn.speaker === "string" && written$2(turn.text) ? [{
 		speaker: turn.speaker,
 		text: turn.text
 	}] : []) : [];
@@ -1051,24 +1051,24 @@ function turnsOf(script) {
 const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /** A transcript's words, with each `Speaker:` label of the script's speakers taken out. */
 function transcriptWords(transcript, speakers) {
-	const labels = [...new Set(speakers.map((speaker) => speaker.trim()).filter(written$1))];
+	const labels = [...new Set(speakers.map((speaker) => speaker.trim()).filter(written$2))];
 	const unlabelled = labels.length === 0 ? transcript : transcript.replace(new RegExp(`(^|\\s)(?:${labels.map(escaped).join("|")})\\s*:`, "giu"), "$1");
 	return fold(unlabelled);
 }
 /** What a recording says, as words: its transcript, or else its script's turns. */
 function spokenWords(holder) {
-	const turns = turnsOf(holder.script);
-	if (written$1(holder.transcript)) return transcriptWords(holder.transcript, turns.map((turn) => turn.speaker));
+	const turns = turnsOf$1(holder.script);
+	if (written$2(holder.transcript)) return transcriptWords(holder.transcript, turns.map((turn) => turn.speaker));
 	return turns.length > 0 ? fold(turns.map((turn) => turn.text).join(" ")) : null;
 }
 const sameWords = (a, b) => a.length === b.length && a.every((word, index) => word === b[index]);
 /** One object's own rules: text on media with nothing to say, and a transcript its script contradicts. */
 function holderFindings(holder, path) {
-	if (!isRecord$6(holder)) return [];
+	if (!isRecord$8(holder)) return [];
 	const findings = [];
-	const turns = turnsOf(holder.script);
-	if ((written$1(holder.transcript) || turns.length > 0) && (holder.type === "image" || holder.type === "embed")) findings.push(finding("media_transcript_unused", [...path, written$1(holder.transcript) ? "transcript" : "script"], `A transcript or a script on ${holder.type === "image" ? "a picture" : "an embedded player"} has nothing to describe, and nothing reads it. Put it on the recording it belongs to.`));
-	if (written$1(holder.transcript) && turns.length > 0) {
+	const turns = turnsOf$1(holder.script);
+	if ((written$2(holder.transcript) || turns.length > 0) && (holder.type === "image" || holder.type === "embed")) findings.push(finding("media_transcript_unused", [...path, written$2(holder.transcript) ? "transcript" : "script"], `A transcript or a script on ${holder.type === "image" ? "a picture" : "an embedded player"} has nothing to describe, and nothing reads it. Put it on the recording it belongs to.`));
+	if (written$2(holder.transcript) && turns.length > 0) {
 		const fromTranscript = transcriptWords(holder.transcript, turns.map((turn) => turn.speaker));
 		if (!sameWords(fromTranscript, fold(turns.map((turn) => turn.text).join(" ")))) findings.push(finding("media_script_differs", [...path, "script"], "The script and the transcript say different words. AI facts read the transcript, and a voice reads the script: make them say the same."));
 	}
@@ -1088,20 +1088,777 @@ function recordingFindings(item) {
 	const findings = listMediaRefs(item).filter((ref) => ref.path[ref.path.length - 1] === "url").flatMap((ref) => holderFindings(ref.holder, ref.path.slice(0, -1)));
 	const field = typeof item.type === "string" ? SPOKEN_FIELD[item.type] : void 0;
 	const media = item.media;
-	if (field === void 0 || !isRecord$6(media)) return findings;
+	if (field === void 0 || !isRecord$8(media)) return findings;
 	const said = spokenWords(media);
-	const accepted = [item[field], ...item.type === "dictation" && Array.isArray(item.acceptedTranscripts) ? item.acceptedTranscripts : []].filter(written$1);
-	if (said !== null && accepted.length > 0 && !accepted.some((text) => sameWords(said, fold(text)))) findings.push(finding("media_transcript_differs", ["media", written$1(media.transcript) ? "transcript" : "script"], `The recording's transcript says different words from the item's \`${field}\`, which is what the recording is meant to say.`));
+	const accepted = [item[field], ...item.type === "dictation" && Array.isArray(item.acceptedTranscripts) ? item.acceptedTranscripts : []].filter(written$2);
+	if (said !== null && accepted.length > 0 && !accepted.some((text) => sameWords(said, fold(text)))) findings.push(finding("media_transcript_differs", ["media", written$2(media.transcript) ? "transcript" : "script"], `The recording's transcript says different words from the item's \`${field}\`, which is what the recording is meant to say.`));
 	return findings;
 }
 /** A group's material: its own transcript against its script, and its media's rules. */
 function stimulusFindings(stimulus) {
-	if (!isRecord$6(stimulus)) return [];
+	if (!isRecord$8(stimulus)) return [];
 	return [...holderFindings({
 		transcript: stimulus.transcript,
 		script: stimulus.script
 	}, ["stimulus"]), ...holderFindings(stimulus.media, ["stimulus", "media"])];
 }
+// src/variant-rules.ts
+const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const listOf$3 = (value) => Array.isArray(value) ? value : [];
+const stringOf$3 = (value) => typeof value === "string" ? value : "";
+const same = (a, b) => canonicalJson(a ?? null) === canonicalJson(b ?? null);
+/**
+* A passage's blanks or gaps in the order its placeholders appear, each with
+* its index in the list: the order a learner meets them, which is how two
+* items are compared and how a model writes them. The list's own order where
+* the passage does not name each of them once.
+*/
+function inPassageOrder(item, field) {
+	const list = listOf$3(item[field]);
+	const found = (typeof item.passage === "string" ? placeholderOrder(item.passage) : []).map((id) => list.findIndex((one) => isRecord$4(one) && one.id === id));
+	if (found.length === list.length && found.every((at) => at !== -1) && new Set(found).size === found.length) return found.map((at) => ({
+		at,
+		value: list[at]
+	}));
+	return list.map((value, at) => ({
+		at,
+		value
+	}));
+}
+/**
+* How alike two texts must be to count as one copying the other: the share of
+* their word triples (3-word shingles) they have in common, as Jaccard
+* similarity. 0.5 means half of everything either text says, three words at a
+* time, is in the other.
+*/
+const AI_VARIANT_NEAR_COPY_THRESHOLD = .5;
+/** Texts shorter than this, in words, are compared whole: word triples say nothing about them. */
+const SHORT_TEXT_WORDS = 6;
+/**
+* The words of a text as every comparison here reads them: placeholders
+* (`{{1}}`) taken out, compatibility forms read as what they stand for, accents
+* and case ignored, and punctuation — typographic quotes included — gone.
+*/
+function wordsOf(text) {
+	return fold(passageWithoutPlaceholders(text));
+}
+function triples(words) {
+	const found = /* @__PURE__ */ new Set();
+	for (let at = 0; at + 3 <= words.length; at += 1) found.add(`${words[at]} ${words[at + 1]} ${words[at + 2]}`);
+	return found;
+}
+/**
+* How alike two texts are, from 0 to 1: the Jaccard similarity of their word
+* triples, or — when either has fewer than six words — 1 if they read the same
+* and 0 if not. A text with no words is like nothing.
+*/
+function textSimilarity(a, b) {
+	const left = wordsOf(a);
+	const right = wordsOf(b);
+	if (left.length === 0 || right.length === 0) return 0;
+	if (left.length < SHORT_TEXT_WORDS || right.length < SHORT_TEXT_WORDS) return left.join(" ") === right.join(" ") ? 1 : 0;
+	const one = triples(left);
+	const two = triples(right);
+	let shared = 0;
+	for (const triple of one) if (two.has(triple)) shared += 1;
+	return shared / (one.size + two.size - shared);
+}
+/** A similarity as a message shows it: two decimals. */
+const shownScore = (score) => score.toFixed(2);
+const RECORDING_TYPES = [
+	"audio",
+	"video",
+	"embed"
+];
+/** A recording's words: its script's turns, speakers left out, else its transcript. */
+function recordingText(holder) {
+	const turns = listOf$3(holder.script).flatMap((turn) => isRecord$4(turn) && typeof turn.text === "string" && turn.text.trim() !== "" ? [turn.text] : []);
+	if (turns.length > 0) return {
+		field: "script",
+		text: turns.join("\n")
+	};
+	return typeof holder.transcript === "string" && holder.transcript.trim() !== "" ? {
+		field: "transcript",
+		text: holder.transcript
+	} : null;
+}
+function mediaTexts(media, at) {
+	if (!isRecord$4(media) || !RECORDING_TYPES.includes(stringOf$3(media.type))) return [];
+	const said = recordingText(media);
+	return said === null ? [] : [{
+		path: [...at, said.field],
+		kind: "material",
+		band: "material",
+		text: said.text
+	}];
+}
+/** The fields an activity type keeps its own text in, and what each is. */
+const OWN_TEXT = {
+	"multiple-choice": {
+		field: "question",
+		kind: "stem"
+	},
+	"fill-in-the-blanks": {
+		field: "passage",
+		kind: "stem"
+	},
+	"gap-select": {
+		field: "passage",
+		kind: "stem"
+	},
+	"written-response": {
+		field: "prompt",
+		kind: "stem"
+	},
+	dictation: {
+		field: "transcript",
+		kind: "spoken"
+	},
+	"read-aloud": {
+		field: "referenceText",
+		kind: "spoken"
+	}
+};
+/**
+* Every text of an entry a near copy or a length is judged on: an item's own
+* text and what its recording says; for an item group, its stimulus's passage
+* and recording, then each item's under `items.N`. A dictation's or a
+* read-aloud's recording says the item's own text, so it is not read twice.
+*/
+function textsOf(entry) {
+	if (!isRecord$4(entry)) return [];
+	if (entry.type === "item-group") {
+		const stimulus = isRecord$4(entry.stimulus) ? entry.stimulus : {};
+		const own = recordingText(stimulus);
+		return [
+			...typeof stimulus.body === "string" && stimulus.body.trim() !== "" ? [{
+				path: ["stimulus", "body"],
+				kind: "material",
+				band: "material",
+				text: stimulus.body
+			}] : [],
+			...own !== null ? [{
+				path: ["stimulus", own.field],
+				kind: "material",
+				band: "material",
+				text: own.text
+			}] : mediaTexts(stimulus.media, ["stimulus", "media"]),
+			...listOf$3(entry.items).flatMap((item, index) => textsOf(item).map((found) => ({
+				...found,
+				path: [
+					"items",
+					String(index),
+					...found.path
+				]
+			})))
+		];
+	}
+	const own = OWN_TEXT[stringOf$3(entry.type)];
+	if (own === void 0) return [];
+	const text = entry[own.field];
+	return [...typeof text === "string" && text.trim() !== "" ? [{
+		path: [own.field],
+		kind: own.kind,
+		band: "item",
+		text
+	}] : [], ...own.kind === "spoken" ? [] : mediaTexts(entry.media, ["media"])];
+}
+/** A key as compared: folded, and kept in its case when its blank matches case. */
+function keyOf(text, caseSensitive = false) {
+	if (!caseSensitive) return fold(text).join(" ");
+	return text.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function choiceText(item, gap) {
+	const own = listOf$3(gap.choices);
+	const bank = listOf$3(item.banks).find((one) => isRecord$4(one) && one.id === gap.bankId);
+	const right = (own.length > 0 ? own : isRecord$4(bank) ? listOf$3(bank.choices) : []).find((choice) => isRecord$4(choice) && choice.id === gap.correctChoiceId);
+	return isRecord$4(right) && typeof right.text === "string" ? right.text : void 0;
+}
+/** The right answers of one item (not a group), slot by slot. */
+function keysOf(item) {
+	if (!isRecord$4(item)) return [];
+	const slots = [];
+	const add = (slot, path, written, caseSensitive = false) => {
+		const answers = [...new Set(written.map((one) => keyOf(one, caseSensitive)))].filter((one) => one !== "");
+		if (answers.length > 0) slots.push({
+			slot,
+			path,
+			answers,
+			shown: written[0].trim()
+		});
+	};
+	if (item.type === "multiple-choice") {
+		const options = listOf$3(item.options);
+		const first = options.findIndex((option) => isRecord$4(option) && option.isCorrect === true);
+		add("options", [
+			"options",
+			String(first),
+			"text"
+		], options.flatMap((option) => isRecord$4(option) && option.isCorrect === true && typeof option.text === "string" ? [option.text] : []));
+	} else if (item.type === "fill-in-the-blanks") inPassageOrder(item, "blanks").forEach(({ at, value: blank }, position) => {
+		if (isRecord$4(blank)) add(`blanks.${position}`, [
+			"blanks",
+			String(at),
+			"acceptedAnswers"
+		], listOf$3(blank.acceptedAnswers).filter((one) => typeof one === "string"), policyFor(blank).caseSensitive === true);
+	});
+	else if (item.type === "gap-select") inPassageOrder(item, "gaps").forEach(({ at, value: gap }, position) => {
+		const text = isRecord$4(gap) ? choiceText(item, gap) : void 0;
+		if (text !== void 0) add(`gaps.${position}`, [
+			"gaps",
+			String(at),
+			"correctChoiceId"
+		], [text]);
+	});
+	return slots;
+}
+/** The answers two key slots share, as the first slot writes them. */
+function sharedAnswers(a, b) {
+	return a.answers.filter((answer) => b.answers.includes(answer));
+}
+/** A multiple choice's options as a set of texts, for "the same options in another order". */
+function optionSet(item) {
+	if (!isRecord$4(item) || item.type !== "multiple-choice") return null;
+	const texts = listOf$3(item.options).map((option) => isRecord$4(option) ? fold(stringOf$3(option.text)).join(" ") : "");
+	return texts.length === 0 || texts.some((one) => one === "") ? null : [...texts].sort();
+}
+/**
+* How far a parallel text may stray from its exemplar's length, in words:
+* `ratio` of the exemplar's words either way, and never less than `minWords`.
+* Material — a passage, a listening script, what a recording says — is held
+* closer than an item's own text, because how much a candidate reads or hears
+* is what makes one form of a part harder than another.
+*/
+const AI_VARIANT_LENGTH_BANDS = {
+	material: {
+		ratio: .1,
+		minWords: 5
+	},
+	item: {
+		ratio: .25,
+		minWords: 2
+	}
+};
+/** Inclusive bounds, in words, for a text the exemplar writes in `words` words. */
+function lengthBand(words, band, tolerance = {}) {
+	const rule = AI_VARIANT_LENGTH_BANDS[band];
+	const asked = tolerance[band];
+	const ratio = typeof asked === "number" && Number.isFinite(asked) && asked >= 0 ? asked : rule.ratio;
+	const leeway = Math.max(words * ratio, rule.minWords);
+	return [Math.max(0, Math.ceil(words - leeway - 1e-9)), Math.floor(words + leeway + 1e-9)];
+}
+/** Every text of an entry with its band: path, kind and bounds. */
+function lengthTargets(entry, tolerance) {
+	return textsOf(entry).map((found) => {
+		const words = wordsOf(found.text).length;
+		return {
+			path: found.path,
+			band: found.band,
+			words,
+			bounds: lengthBand(words, found.band, tolerance)
+		};
+	});
+}
+/** The texts of `candidate` whose length falls outside the band of the same text in `exemplar`. */
+function lengthMisses(exemplar, candidate, tolerance) {
+	const theirs = new Map(textsOf(candidate).map((found) => [found.path.join("."), found]));
+	return lengthTargets(exemplar, tolerance).flatMap((target) => {
+		const found = theirs.get(target.path.join("."));
+		if (found === void 0) return [];
+		const words = wordsOf(found.text).length;
+		return words < target.bounds[0] || words > target.bounds[1] ? [{
+			path: target.path,
+			band: target.band,
+			words,
+			bounds: target.bounds,
+			exemplarWords: target.words
+		}] : [];
+	});
+}
+const count = (n, what) => `${n} ${what}${n === 1 ? "" : "s"}`;
+/** A script's speakers, by name, and its turns. */
+function scriptShape(holder) {
+	const turns = listOf$3(holder.script).filter(isRecord$4);
+	if (turns.length === 0) return null;
+	return {
+		speakers: new Set(turns.map((turn) => stringOf$3(turn.speaker).trim().toLowerCase())).size,
+		turns: turns.length
+	};
+}
+/** The script a stimulus carries, on itself or on its media. */
+function stimulusScript(stimulus) {
+	return scriptShape(stimulus) ?? (isRecord$4(stimulus.media) ? scriptShape(stimulus.media) : null);
+}
+/** How many turns a script of `turns` turns may have in a variant: within a quarter, at least one either way. */
+function turnBand(turns) {
+	const leeway = Math.max(turns * .25, 1);
+	return [Math.max(1, Math.ceil(turns - leeway - 1e-9)), Math.floor(turns + leeway + 1e-9)];
+}
+const mediaKind = (media) => isRecord$4(media) && typeof media.type === "string" ? media.type : null;
+function isOneWord(answer) {
+	const trimmed = answer.trim();
+	return trimmed !== "" && !/\s/.test(trimmed);
+}
+/**
+* Which bank each gap draws on, by the bank's position, or `null` for a gap
+* with its own choices: in passage order.
+*/
+function gapBanks(item) {
+	const banks = listOf$3(item.banks);
+	return inPassageOrder(item, "gaps").map(({ value: gap }) => {
+		if (!isRecord$4(gap) || listOf$3(gap.choices).length > 0) return null;
+		const at = banks.findIndex((bank) => isRecord$4(bank) && bank.id === gap.bankId);
+		return at === -1 ? null : at;
+	});
+}
+/**
+* The structure a variant must keep, as plain facts a model can be told: the
+* counts it must hit. Read from the exemplar; nothing here is checked.
+*/
+function structureTargets(entry) {
+	if (!isRecord$4(entry)) return {};
+	switch (entry.type) {
+		case "item-group": {
+			const stimulus = isRecord$4(entry.stimulus) ? entry.stimulus : {};
+			const script = stimulusScript(stimulus);
+			return {
+				stimulus: stringOf$3(stimulus.kind),
+				items: listOf$3(entry.items).map((item) => ({
+					type: isRecord$4(item) ? stringOf$3(item.type) : "",
+					...structureTargets(item)
+				})),
+				...script !== null ? {
+					speakers: script.speakers,
+					turns: turnBand(script.turns)
+				} : {}
+			};
+		}
+		case "multiple-choice": {
+			const options = listOf$3(entry.options);
+			const media = options.map((option) => isRecord$4(option) ? mediaKind(option.media) : null);
+			return {
+				mode: stringOf$3(entry.mode),
+				options: options.length,
+				correct: options.filter((option) => isRecord$4(option) && option.isCorrect === true).length,
+				...media.some((one) => one !== null) ? { optionMedia: media } : {}
+			};
+		}
+		case "fill-in-the-blanks": return { blanks: inPassageOrder(entry, "blanks").map(({ value: blank }) => {
+			const answers = isRecord$4(blank) ? listOf$3(blank.acceptedAnswers).filter((one) => typeof one === "string") : [];
+			return {
+				oneWord: answers.length > 0 && answers.every(isOneWord),
+				acceptedAnswers: [Math.max(1, answers.length - 2), answers.length + 2]
+			};
+		}) };
+		case "gap-select": {
+			const banks = listOf$3(entry.banks);
+			const drawn = gapBanks(entry);
+			return {
+				gaps: inPassageOrder(entry, "gaps").map(({ value: gap }, index) => drawn[index] !== null ? { bank: drawn[index] } : { choices: isRecord$4(gap) ? listOf$3(gap.choices).length : 0 }),
+				...banks.length > 0 ? { banks: banks.map((bank) => ({ choices: isRecord$4(bank) ? listOf$3(bank.choices).length : 0 })) } : {}
+			};
+		}
+		case "written-response": return {
+			minWords: entry.minWords,
+			maxWords: entry.maxWords,
+			...isRecord$4(entry.rubric) ? { criteria: listOf$3(entry.rubric.criteria).map((criterion) => isRecord$4(criterion) ? stringOf$3(criterion.name) : "") } : {}
+		};
+		default: return {};
+	}
+}
+/** The settings two items must share to be scored alike, per type. */
+const SCORED_ALIKE = {
+	"multiple-choice": ["mode", "scoringStrategy"],
+	"fill-in-the-blanks": ["scoringStrategy"],
+	"gap-select": ["scoringStrategy", "presentation"],
+	dictation: ["tolerance", "hints"],
+	"read-aloud": [
+		"recording",
+		"scoring",
+		"locale"
+	],
+	"written-response": [
+		"rubric",
+		"minWords",
+		"maxWords",
+		"languageTarget"
+	]
+};
+const DIFFERS = {
+	mode: "The mode differs",
+	scoringStrategy: "The scoring strategy differs",
+	presentation: "The presentation differs",
+	tolerance: "The tolerance differs",
+	hints: "The hints differ",
+	recording: "The recording bounds differ",
+	scoring: "The scored dimensions differ",
+	locale: "The locale differs",
+	rubric: "The rubric differs",
+	minWords: "The minimum word count differs",
+	maxWords: "The maximum word count differs",
+	languageTarget: "The language target differs"
+};
+function itemMisses(exemplar, candidate) {
+	const misses = [];
+	const miss = (path, message) => misses.push({
+		path: path.map(String),
+		message
+	});
+	const type = stringOf$3(exemplar.type);
+	for (const field of SCORED_ALIKE[type] ?? []) if (!same(exemplar[field], candidate[field])) miss([field], `${DIFFERS[field]} from the exemplar's.`);
+	if (exemplar.shuffle === true !== (candidate.shuffle === true)) miss(["shuffle"], "Shuffling differs from the exemplar.");
+	if (mediaKind(exemplar.media) !== mediaKind(candidate.media)) miss(["media"], `The exemplar has ${mediaKind(exemplar.media) ?? "no"} media; this has ${mediaKind(candidate.media) ?? "none"}.`);
+	if (type === "dictation" || type === "read-aloud") {
+		if (isRecord$4(exemplar.slowMedia) !== isRecord$4(candidate.slowMedia)) miss(["slowMedia"], isRecord$4(exemplar.slowMedia) ? "The exemplar has a slow recording; this has none." : "This has a slow recording; the exemplar has none.");
+	}
+	if (type === "multiple-choice") {
+		const mine = listOf$3(exemplar.options);
+		const theirs = listOf$3(candidate.options);
+		if (mine.length !== theirs.length) miss(["options"], `${count(theirs.length, "option")}; the exemplar has ${mine.length}.`);
+		const right = (list) => list.filter((option) => isRecord$4(option) && option.isCorrect === true).length;
+		if (right(mine) !== right(theirs)) miss(["options"], `${count(right(theirs), "correct option")}; the exemplar has ${right(mine)}.`);
+		const media = (list) => list.map((option) => isRecord$4(option) ? mediaKind(option.media) : null).filter((one) => one !== null).sort().join(",");
+		if (media(mine) !== media(theirs)) miss(["options"], "The options with media differ from the exemplar's.");
+	} else if (type === "fill-in-the-blanks") {
+		const mine = inPassageOrder(exemplar, "blanks");
+		const theirs = inPassageOrder(candidate, "blanks");
+		if (mine.length !== theirs.length) miss(["blanks"], `${count(theirs.length, "blank")}; the exemplar has ${mine.length}.`);
+		mine.forEach(({ value: blank }, index) => {
+			const at = theirs[index]?.at;
+			const other = theirs[index]?.value;
+			if (!isRecord$4(blank) || !isRecord$4(other)) return;
+			const policy = (one) => ({
+				match: one.match,
+				caseSensitive: one.caseSensitive,
+				trimWhitespace: one.trimWhitespace
+			});
+			if (!same(policy(blank), policy(other))) miss(["blanks", at], `Blank ${index + 1} matches answers differently from the exemplar's.`);
+			const answers = (one) => listOf$3(one.acceptedAnswers).filter((answer) => typeof answer === "string");
+			const exemplarAnswers = answers(blank);
+			const candidateAnswers = answers(other);
+			if (exemplarAnswers.length > 0 && exemplarAnswers.every(isOneWord) && !candidateAnswers.every(isOneWord)) miss([
+				"blanks",
+				at,
+				"acceptedAnswers"
+			], `Blank ${index + 1} takes one word in the exemplar; every answer here must be one word.`);
+			if (Math.abs(candidateAnswers.length - exemplarAnswers.length) > 2) miss([
+				"blanks",
+				at,
+				"acceptedAnswers"
+			], `Blank ${index + 1} accepts ${count(candidateAnswers.length, "answer")}; the exemplar accepts ${exemplarAnswers.length}, and two more or fewer is the most.`);
+		});
+	} else if (type === "gap-select") {
+		const mine = inPassageOrder(exemplar, "gaps");
+		const theirs = inPassageOrder(candidate, "gaps");
+		if (mine.length !== theirs.length) miss(["gaps"], `${count(theirs.length, "gap")}; the exemplar has ${mine.length}.`);
+		const myBanks = listOf$3(exemplar.banks);
+		const theirBanks = listOf$3(candidate.banks);
+		if (myBanks.length !== theirBanks.length) miss(["banks"], `${count(theirBanks.length, "bank")}; the exemplar has ${myBanks.length}.`);
+		myBanks.forEach((bank, index) => {
+			const other = theirBanks[index];
+			const size = (one) => isRecord$4(one) ? listOf$3(one.choices).length : 0;
+			if (other !== void 0 && size(bank) !== size(other)) miss([
+				"banks",
+				index,
+				"choices"
+			], `Bank ${index + 1} offers ${count(size(other), "choice")}; the exemplar's offers ${size(bank)}.`);
+		});
+		const myDraws = gapBanks(exemplar);
+		const theirDraws = gapBanks(candidate);
+		mine.forEach(({ value: gap }, index) => {
+			const at = theirs[index]?.at;
+			const other = theirs[index]?.value;
+			if (at === void 0) return;
+			if (myDraws[index] !== theirDraws[index]) miss(["gaps", at], `Gap ${index + 1} draws on its choices differently from the exemplar's.`);
+			else if (myDraws[index] === null) {
+				const size = (one) => isRecord$4(one) ? listOf$3(one.choices).length : 0;
+				if (size(gap) !== size(other)) miss([
+					"gaps",
+					at,
+					"choices"
+				], `Gap ${index + 1} offers ${count(size(other), "choice")}; the exemplar's offers ${size(gap)}.`);
+			}
+		});
+		if (exemplar.shuffleChoices === true !== (candidate.shuffleChoices === true)) miss(["shuffleChoices"], "Shuffling the choices differs from the exemplar.");
+	}
+	return misses;
+}
+/**
+* How `candidate`'s structure differs from `exemplar`'s: what makes the two
+* no parallel items — the type, the counts a learner answers (options and how
+* many are right, blanks, gaps, banks, a part's items and speakers), and the
+* settings that score them. Empty when they are parallel. Lengths, copies and
+* keys are not structure; see {@link lengthMisses}, {@link textSimilarity} and
+* {@link keysOf}.
+*/
+function structureMisses(exemplar, candidate) {
+	if (!isRecord$4(exemplar) || !isRecord$4(candidate)) return [];
+	if (exemplar.type !== candidate.type) return [{
+		path: ["type"],
+		message: `This is ${stringOf$3(candidate.type) || "no type"}; the exemplar is ${stringOf$3(exemplar.type)}.`
+	}];
+	if (exemplar.type !== "item-group") return itemMisses(exemplar, candidate);
+	const misses = [];
+	const mine = isRecord$4(exemplar.stimulus) ? exemplar.stimulus : {};
+	const theirs = isRecord$4(candidate.stimulus) ? candidate.stimulus : {};
+	if (mine.kind !== theirs.kind) misses.push({
+		path: ["stimulus", "kind"],
+		message: `The material is ${stringOf$3(theirs.kind) || "of no kind"}; the exemplar's is ${stringOf$3(mine.kind)}.`
+	});
+	const myScript = stimulusScript(mine);
+	const theirScript = stimulusScript(theirs);
+	if (myScript !== null) {
+		if (theirScript === null) misses.push({
+			path: ["stimulus", "script"],
+			message: "The exemplar's recording has a script; this has none."
+		});
+		else {
+			if (theirScript.speakers !== myScript.speakers) misses.push({
+				path: ["stimulus", "script"],
+				message: `${count(theirScript.speakers, "speaker")}; the exemplar has ${myScript.speakers}.`
+			});
+			const [low, high] = turnBand(myScript.turns);
+			if (theirScript.turns < low || theirScript.turns > high) misses.push({
+				path: ["stimulus", "script"],
+				message: `${count(theirScript.turns, "turn")}; the exemplar has ${myScript.turns}, so ${low} to ${high}.`
+			});
+		}
+	}
+	if ((exemplar.shuffle ?? "none") !== (candidate.shuffle ?? "none")) misses.push({
+		path: ["shuffle"],
+		message: "Shuffling differs from the exemplar."
+	});
+	const myItems = listOf$3(exemplar.items);
+	const theirItems = listOf$3(candidate.items);
+	if (myItems.length !== theirItems.length) misses.push({
+		path: ["items"],
+		message: `${count(theirItems.length, "item")}; the exemplar has ${myItems.length}.`
+	});
+	myItems.forEach((item, index) => {
+		const other = theirItems[index];
+		if (other !== void 0) for (const found of structureMisses(item, other)) misses.push({
+			path: [
+				"items",
+				String(index),
+				...found.path
+			],
+			message: found.message
+		});
+	});
+	return misses;
+}
+// src/authoring/paper.ts
+/**
+* The paper critic: what only a whole paper shows, over every item of a set —
+* loose questions and the items of groups alike. Each finding sits at one of
+* the items involved and names the others in `related`.
+*/
+const listOf$2 = (value) => Array.isArray(value) ? value : [];
+const stringOf$2 = (value) => typeof value === "string" ? value : "";
+const key = (path) => path.join(".");
+function itemsOf(entries) {
+	return entries.flatMap((entry, index) => {
+		if (!isRecord$8(entry)) return [];
+		if (entry.type === "item-group") {
+			const group = [String(index)];
+			return listOf$2(entry.items).flatMap((item, at) => isRecord$8(item) ? [{
+				path: [
+					...group,
+					"items",
+					String(at)
+				],
+				item,
+				group
+			}] : []);
+		}
+		return typeof entry.type === "string" ? [{
+			path: [String(index)],
+			item: entry
+		}] : [];
+	});
+}
+/** The single-answer multiple choices a learner can see the key position of: unshuffled. */
+function singleAnswer(item) {
+	if (item.type !== "multiple-choice" || item.mode !== "single") return null;
+	const options = listOf$2(item.options);
+	const keys = options.flatMap((option, index) => isRecord$8(option) && option.isCorrect === true ? [index] : []);
+	return keys.length === 1 ? {
+		key: keys[0],
+		options
+	} : null;
+}
+/** Questions a position needs before "more than half" reads as a habit, not chance. */
+const POSITION_BIAS_MINIMUM = 6;
+/** Keys a set needs before "never here" reads as a habit. */
+const POSITION_NEVER_MINIMUM = 8;
+const letter = (position) => position < 26 ? String.fromCharCode(65 + position) : String(position + 1);
+function keyPositionBias(items) {
+	const placed = items.flatMap((one) => {
+		if (one.item.shuffle === true) return [];
+		const single = singleAnswer(one.item);
+		return single === null ? [] : [{
+			one,
+			key: single.key,
+			size: single.options.length
+		}];
+	});
+	if (placed.length < POSITION_BIAS_MINIMUM || placed.every((at) => at.key === placed[0]?.key)) return [];
+	const counts = /* @__PURE__ */ new Map();
+	for (const at of placed) counts.set(at.key, [...counts.get(at.key) ?? [], at.one]);
+	for (const [position, holders] of counts) if (holders.length * 2 > placed.length) return [{
+		...finding("set_key_position_bias", [], `${holders.length} of ${placed.length} single-answer questions put the right option at ${letter(position)}. Spread the keys across positions, or shuffle the options.`),
+		related: holders.map((one) => one.path)
+	}];
+	if (placed.length >= POSITION_NEVER_MINIMUM) {
+		const everywhere = Math.min(...placed.map((at) => at.size));
+		for (let position = 0; position < everywhere; position += 1) if (!counts.has(position)) return [{
+			...finding("set_key_position_bias", [], `None of ${placed.length} single-answer questions puts the right option at ${letter(position)}, which every one of them has. A learner can rule it out.`),
+			related: placed.map((at) => at.one.path)
+		}];
+	}
+	return [];
+}
+const LONGEST_MINIMUM = 5;
+const LONGEST_SHARE = .6;
+function keyLongestBias(items) {
+	const judged = items.flatMap((one) => {
+		const single = singleAnswer(one.item);
+		if (single === null || single.options.length < 3 || !single.options.every((option) => isRecord$8(option) && option.media === void 0 && typeof option.text === "string" && option.text.trim() !== "")) return [];
+		const lengths = single.options.map((option) => [...stringOf$2(option.text).trim()].length);
+		const keyLength = lengths[single.key];
+		return [{
+			one,
+			longest: lengths.every((length, index) => index === single.key || length < keyLength)
+		}];
+	});
+	const longest = judged.filter((at) => at.longest);
+	if (judged.length < LONGEST_MINIMUM || longest.length < judged.length * LONGEST_SHARE) return [];
+	return [{
+		...finding("set_key_longest_bias", [], `In ${longest.length} of ${judged.length} single-answer questions the right option is the longest. A learner who picks the longest option scores well without knowing the answers.`),
+		related: longest.map((at) => at.one.path)
+	}];
+}
+/** Stems shorter than this are not compared: "Choose the correct answer." repeats by design. */
+const STEM_MINIMUM_WORDS = 6;
+function stemDuplicates(items) {
+	const stems = items.flatMap((one) => textsOf(one.item).filter((text) => text.kind !== "material" && wordsOf(text.text).length >= STEM_MINIMUM_WORDS).map((text) => ({
+		one,
+		path: [...one.path, ...text.path],
+		text: text.text
+	})));
+	const findings = [];
+	stems.forEach((later, at) => {
+		let best;
+		for (const earlier of stems.slice(0, at)) {
+			if (earlier.one === later.one) continue;
+			const score = textSimilarity(earlier.text, later.text);
+			if (score >= .5 && (best === void 0 || score > best.score)) best = {
+				path: earlier.path,
+				score
+			};
+		}
+		if (best !== void 0) findings.push({
+			...finding("set_stem_duplicate", later.path, best.score === 1 ? "This reads the same as another item of the set. One piece of knowledge answers both." : `This reads like another item of the set (similarity ${shownScore(best.score)}). One piece of knowledge may answer both.`),
+			related: [best.path]
+		});
+	});
+	return findings;
+}
+/**
+* The 100 most common English words (Oxford English Corpus), with the forms
+* of be, have and do: a key that is one of them is everywhere, so finding it
+* in another item says nothing.
+*/
+const COMMON_WORDS = new Set(`the be to of and a in that have i it for not on with he as you do at this but his by from they we say her she or an will my one all would there their what so up out if about who get which go me when make can like time no just him know take people into year your good some could them see other than then now look only come its over think also back after use two how our work first well way even new want because any these give day most us is are was were been being am has had having does did done`.split(" "));
+/** Whether an answer is worth looking for in other items: more than two characters, and not a common word alone. */
+function distinctive(words) {
+	return words.join(" ").length > 2 && !(words.length === 1 && COMMON_WORDS.has(words[0]));
+}
+/** What a learner reads or hears of an item: its own text, and its options' and choices'. */
+function placeOf(one) {
+	const item = one.item;
+	const texts = [
+		...textsOf(item).map((text) => text.text),
+		...listOf$2(item.options).map((option) => isRecord$8(option) ? stringOf$2(option.text) : ""),
+		...listOf$2(item.gaps).flatMap((gap) => isRecord$8(gap) ? listOf$2(gap.choices).map((choice) => isRecord$8(choice) ? stringOf$2(choice.text) : "") : []),
+		...listOf$2(item.banks).flatMap((bank) => isRecord$8(bank) ? listOf$2(bank.choices).map((choice) => isRecord$8(choice) ? stringOf$2(choice.text) : "") : [])
+	];
+	return {
+		path: one.path,
+		owner: key(one.path),
+		words: fold(passageWithoutPlaceholders(texts.join("\n")))
+	};
+}
+/** An item's own words, where its answer must not already be: its stem, not its options. */
+function ownWords(item) {
+	return fold(passageWithoutPlaceholders(textsOf(item).filter((text) => text.kind !== "material").map((text) => text.text).join("\n")));
+}
+function answersInOtherItems(entries, items) {
+	const places = [...items.map(placeOf), ...entries.flatMap((entry, index) => {
+		if (!isRecord$8(entry) || entry.type !== "item-group") return [];
+		const material = textsOf({
+			type: "item-group",
+			stimulus: entry.stimulus
+		}).map((text) => text.text).join("\n");
+		return material === "" ? [] : [{
+			path: [String(index), "stimulus"],
+			owner: `group:${index}`,
+			words: fold(material)
+		}];
+	})];
+	const findings = [];
+	for (const one of items) {
+		const own = ownWords(one.item);
+		const ownGroup = one.group !== void 0 ? `group:${one.group[0]}` : void 0;
+		const reported = /* @__PURE__ */ new Set();
+		for (const slot of keysOf(one.item)) for (const answer of slot.answers) {
+			const words = fold(answer);
+			if (!distinctive(words) || containsWords(own, words)) continue;
+			for (const place of places) {
+				if (place.owner === key(one.path) || place.owner === ownGroup || reported.has(place.owner)) continue;
+				if (containsWords(place.words, words)) {
+					reported.add(place.owner);
+					findings.push({
+						...finding("set_item_answers_item", [...one.path, ...slot.path], `The answer "${answer}" is printed elsewhere in the set: a learner can find it there.`),
+						related: [place.path]
+					});
+				}
+			}
+		}
+	}
+	return findings;
+}
+const REPEATED_KEY_MINIMUM = 3;
+function repeatedKeys(items) {
+	const holders = /* @__PURE__ */ new Map();
+	for (const one of items) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const slot of keysOf(one.item)) for (const answer of slot.answers) if (!seen.has(answer)) {
+			seen.add(answer);
+			holders.set(answer, [...holders.get(answer) ?? [], [...one.path, ...slot.path]]);
+		}
+	}
+	return [...holders].flatMap(([answer, paths]) => paths.length >= REPEATED_KEY_MINIMUM ? [{
+		...finding("set_key_repeated", paths[0], `"${answer}" is the answer to ${paths.length} items. The set tests less than its length suggests.`),
+		related: paths.slice(1)
+	}] : []);
+}
+/**
+* What only a whole paper shows, over every item of `entries` — loose
+* questions and the items of groups: keys clustered in one position, keys
+* that are the longest option, stems that repeat, an answer printed in another
+* item, and one answer to many items. Paths are from the set's root.
+*/
+function paperFindings(entries) {
+	const items = itemsOf(entries);
+	return [
+		...keyPositionBias(items),
+		...keyLongestBias(items),
+		...stemDuplicates(items),
+		...answersInOtherItems(entries, items),
+		...repeatedKeys(items)
+	];
+}
 // src/authoring/item-group.ts
 /**
 * A new, empty reading or listening testlet for an editor to start from.
@@ -1197,7 +1954,7 @@ function createInteractiveVideoDraft(context) {
 * {@link validateItemGroupDraft} already reports it.
 */
 function critiqueItemGroupDraft(draft) {
-	if (!isRecord$6(draft)) return [];
+	if (!isRecord$8(draft)) return [];
 	const items = Array.isArray(draft.items) ? draft.items : [];
 	return withValidationScope(() => [
 		...stimulusFindings(draft.stimulus),
@@ -1213,11 +1970,15 @@ function critiqueItemGroupDraft(draft) {
 * skipped.
 */
 function critiqueDrafts(entries) {
-	return withValidationScope(() => [...entries.flatMap((entry, index) => repathed(isRecord$6(entry) && entry.type === "item-group" ? critiqueItemGroupDraft(entry) : critiqueItem(entry), [index])), ...keyPositionFinding(entries, [])]);
+	return withValidationScope(() => [
+		...entries.flatMap((entry, index) => repathed(isRecord$8(entry) && entry.type === "item-group" ? critiqueItemGroupDraft(entry) : critiqueItem(entry), [index])),
+		...keyPositionFinding(entries, []),
+		...paperFindings(entries)
+	]);
 }
 /** One item's findings, or none for an item the critic cannot place. */
 function critiqueItem(item) {
-	if (!isRecord$6(item) || typeof item.type !== "string") return [];
+	if (!isRecord$8(item) || typeof item.type !== "string") return [];
 	if (getActivityTypeDescriptor(item.type) === void 0) return [];
 	return critiqueDraft(item.type, item);
 }
@@ -1230,7 +1991,7 @@ function validateItemGroupDraft(draft) {
 }
 function validateItemGroupDraftInScope(draft) {
 	const issues = [];
-	if (!isRecord$6(draft)) {
+	if (!isRecord$8(draft)) {
 		issues.push(issue("ig_not_an_object", [], "A group must be an object with a stimulus and its items."));
 		return {
 			status: "invalid",
@@ -1238,7 +1999,7 @@ function validateItemGroupDraftInScope(draft) {
 		};
 	}
 	issues.push(...checkGroupIdentity(draft));
-	if (isRecord$6(draft.stimulus)) issues.push(...checkStimulus(draft.stimulus));
+	if (isRecord$8(draft.stimulus)) issues.push(...checkStimulus(draft.stimulus));
 	else if (isUnset(draft.stimulus)) issues.push(issue("ig_stimulus_required", ["stimulus"], "Add the passage, recording or image the questions are about."));
 	issues.push(...checkItems(draft));
 	if (draft.timeline !== void 0 && draft.timeline !== null) issues.push(...checkTimeline(draft));
@@ -1288,10 +2049,10 @@ function validateItemGroupDraftInScope(draft) {
 function checkTimeline(draft) {
 	const issues = [];
 	const timeline = draft.timeline;
-	if (!isRecord$6(timeline)) return issues;
-	const stimulus = isRecord$6(draft.stimulus) ? draft.stimulus : void 0;
+	if (!isRecord$8(timeline)) return issues;
+	const stimulus = isRecord$8(draft.stimulus) ? draft.stimulus : void 0;
 	if (stimulus !== void 0 && !isUnwritten(stimulus.kind) && stimulus.kind !== "video") issues.push(issue("ig_timeline_stimulus_kind", ["stimulus", "kind"], "An interactive video needs a video: quizzes open at moments of it."));
-	else if (stimulus !== void 0 && isRecord$6(stimulus.media) && !isUnwritten(stimulus.media.type) && stimulus.media.type !== "video") issues.push(issue("ig_timeline_stimulus_kind", [
+	else if (stimulus !== void 0 && isRecord$8(stimulus.media) && !isUnwritten(stimulus.media.type) && stimulus.media.type !== "video") issues.push(issue("ig_timeline_stimulus_kind", [
 		"stimulus",
 		"media",
 		"type"
@@ -1300,7 +2061,7 @@ function checkTimeline(draft) {
 	const items = Array.isArray(draft.items) ? draft.items : [];
 	const itemIndexById = /* @__PURE__ */ new Map();
 	items.forEach((item, index) => {
-		if (!isRecord$6(item)) return;
+		if (!isRecord$8(item)) return;
 		if (typeof item.id === "string" && item.id !== "") itemIndexById.set(item.id, index);
 		const type = item.type;
 		if (typeof type === "string" && type !== "" && type !== "item-group" && !isInteractiveVideoItemType(type) && getActivityTypeDescriptor(type) !== void 0) issues.push(issue("ig_timeline_item_type", [
@@ -1318,7 +2079,7 @@ function checkTimeline(draft) {
 	const quizIds = /* @__PURE__ */ new Set();
 	const placed = /* @__PURE__ */ new Set();
 	cues.forEach((cue, cueIndex) => {
-		if (!isRecord$6(cue)) return;
+		if (!isRecord$8(cue)) return;
 		const at = (field, ...rest) => [
 			"timeline",
 			"cues",
@@ -1349,7 +2110,7 @@ function checkTimeline(draft) {
 	const chapters = Array.isArray(timeline.chapters) ? timeline.chapters : [];
 	let previousAt;
 	chapters.forEach((chapter, index) => {
-		if (!isRecord$6(chapter)) return;
+		if (!isRecord$8(chapter)) return;
 		if (isUnwritten(chapter.title)) issues.push(issue("ig_timeline_chapter_title", [
 			"timeline",
 			"chapters",
@@ -1410,14 +2171,14 @@ function checkStimulus(stimulus) {
 	if (isUnwritten(kind)) issues.push(issue("ig_stimulus_kind_required", at("kind"), "Choose what the questions are about: a text, a recording, a video, an image, or a mix."));
 	else if (typeof kind !== "string" || !KINDS$1.has(kind)) {
 		if (typeof kind === "string") issues.push(issue("ig_stimulus_kind_invalid", at("kind"), `"${kind}" is not a stimulus kind. Use text, audio, video, image or mixed.`));
-		if (isRecord$6(stimulus.media)) issues.push(...checkMedia(stimulus.media, at("media")));
+		if (isRecord$8(stimulus.media)) issues.push(...checkMedia(stimulus.media, at("media")));
 		return issues;
 	}
 	const hasBody = typeof stimulus.body === "string" && stimulus.body.trim() !== "";
 	const htmlPresent = !isUnset(stimulus.bodyHtml);
 	if (!hasBody && (kind === "text" || kind === "mixed" || htmlPresent)) issues.push(issue("ig_stimulus_body_required", at("body"), isUnwritten(stimulus.bodyHtml) ? "Write the passage." : "Write the passage as plain text too. The rich-text version is shown only where a sanitiser is supplied."));
 	if (kind !== "text" && isUnset(stimulus.media)) issues.push(issue("ig_stimulus_media_required", at("media"), "Add the recording, video or image."));
-	else if (isRecord$6(stimulus.media)) {
+	else if (isRecord$8(stimulus.media)) {
 		const allowed = MEDIA_FOR_KIND[kind];
 		const mediaType = stimulus.media.type;
 		if (allowed !== void 0 && typeof mediaType === "string" && !allowed.includes(mediaType)) issues.push(issue("ig_stimulus_media_kind", at("media", "type"), `A "${kind}" stimulus cannot carry ${mediaType} media. Use ${allowed.join(" or ")}.`));
@@ -1444,7 +2205,7 @@ function checkItems(draft) {
 	const seen = /* @__PURE__ */ new Set();
 	const repeated = /* @__PURE__ */ new Set();
 	for (const [index, item] of items.entries()) {
-		if (!isRecord$6(item)) continue;
+		if (!isRecord$8(item)) continue;
 		const ordinal = index + 1;
 		if (isMissingId(item.id)) issues.push(issue("ig_item_id_required", [
 			"items",
@@ -1540,7 +2301,7 @@ function validateDraft(type, draft) {
 function validateDraftInScope(type, draft) {
 	const descriptor = getActivityTypeDescriptor(type);
 	if (descriptor === void 0) throw new UnknownActivityTypeError(String(type));
-	const reported = isRecord$6(draft) && descriptor.authoring?.checkDraft !== void 0 ? descriptor.authoring.checkDraft(draft).map(normalise) : [];
+	const reported = isRecord$8(draft) && descriptor.authoring?.checkDraft !== void 0 ? descriptor.authoring.checkDraft(draft).map(normalise) : [];
 	const issues = [...reported];
 	const parsed = readSchema(descriptor.schema, draft, `Activity type "${descriptor.type}"`, { reportInput: true });
 	if (!parsed.success) {
@@ -1649,7 +2410,7 @@ function normalise(found) {
 function critiqueDraft(type, draft) {
 	const descriptor = getActivityTypeDescriptor(type);
 	if (descriptor === void 0) throw new UnknownActivityTypeError(String(type));
-	if (!isRecord$6(draft)) return [];
+	if (!isRecord$8(draft)) return [];
 	const critique = descriptor.authoring?.critique;
 	return withValidationScope(() => [...critique === void 0 ? [] : critique(draft), ...recordingFindings(draft)]).map(normaliseFinding);
 }
@@ -1752,7 +2513,7 @@ function aiCritiqueRequest(input) {
 		...authorLocale !== void 0 ? { authorLocale } : {}
 	};
 }
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const tooLong = (text) => [...text].length > 500;
 /**
 * Checks a critique a port returned for `request`, and turns it into findings
@@ -1772,7 +2533,7 @@ const tooLong = (text) => [...text].length > 500;
 *   kind the SDK does not name, or any other shape, is `malformed`.
 */
 function checkAiCritique(raw, request) {
-	if (!isRecord$2(raw) || !Array.isArray(raw.findings)) return {
+	if (!isRecord$3(raw) || !Array.isArray(raw.findings)) return {
 		ok: false,
 		refusal: "malformed"
 	};
@@ -1783,7 +2544,7 @@ function checkAiCritique(raw, request) {
 	const fields = new Map(request.facts.fields.map((field) => [JSON.stringify(field.path), field]));
 	const findings = [];
 	for (const entry of raw.findings) {
-		if (!isRecord$2(entry) || !Array.isArray(entry.path) || !entry.path.every((segment) => typeof segment === "string" || typeof segment === "number") || typeof entry.kind !== "string" || !KINDS.includes(entry.kind) || typeof entry.message !== "string" || entry.quote !== void 0 && entry.quote !== null && typeof entry.quote !== "string") return {
+		if (!isRecord$3(entry) || !Array.isArray(entry.path) || !entry.path.every((segment) => typeof segment === "string" || typeof segment === "number") || typeof entry.kind !== "string" || !KINDS.includes(entry.kind) || typeof entry.message !== "string" || entry.quote !== void 0 && entry.quote !== null && typeof entry.quote !== "string") return {
 			ok: false,
 			refusal: "malformed"
 		};
@@ -1838,8 +2599,8 @@ const DRAFT_TYPES = [
 	"read-aloud",
 	"written-response"
 ];
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const text = (description) => ({
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text$1 = (description) => ({
 	type: "string",
 	description
 });
@@ -1847,14 +2608,14 @@ const FEEDBACK = {
 	type: "object",
 	description: "Optional overall feedback, shown after answering.",
 	properties: {
-		correct: text("Shown when the learner passes."),
-		incorrect: text("Shown when the learner does not.")
+		correct: text$1("Shown when the learner passes."),
+		incorrect: text$1("Shown when the learner does not.")
 	}
 };
 /** Every field a model writes, and the shape of each. A name means one thing in every type that uses it. */
 const FIELDS = {
-	title: text("A short name for the item, shown to the learner above it. Never the answer, or any part of it."),
-	question: text("The question, as plain text."),
+	title: text$1("A short name for the item, shown to the learner above it. Never the answer, or any part of it."),
+	question: text$1("The question, as plain text."),
 	mode: {
 		type: "string",
 		enum: ["single", "multi"],
@@ -1868,13 +2629,13 @@ const FIELDS = {
 			type: "object",
 			required: ["text", "isCorrect"],
 			properties: {
-				text: text("The option as the learner reads it."),
+				text: text$1("The option as the learner reads it."),
 				isCorrect: { type: "boolean" },
-				feedback: text("Why this option is right or wrong, shown after answering.")
+				feedback: text$1("Why this option is right or wrong, shown after answering.")
 			}
 		}
 	},
-	passage: text("The passage as plain text, with {{1}}, {{2}}, … where each gap goes, numbered in the order they appear."),
+	passage: text$1("The passage as plain text, with {{1}}, {{2}}, … where each gap goes, numbered in the order they appear."),
 	blanks: {
 		type: "array",
 		minItems: 1,
@@ -1889,7 +2650,7 @@ const FIELDS = {
 					items: { type: "string" },
 					description: "Every answer that is right, spelled as a learner would type it."
 				},
-				hint: text("Optional. Helps without giving the answer or any of its words.")
+				hint: text$1("Optional. Helps without giving the answer or any of its words.")
 			}
 		}
 	},
@@ -1908,17 +2669,17 @@ const FIELDS = {
 					type: "object",
 					required: ["text", "isCorrect"],
 					properties: {
-						text: text("A choice."),
+						text: text$1("A choice."),
 						isCorrect: { type: "boolean" }
 					}
 				}
 			} }
 		}
 	},
-	transcript: text("What the learner hears and types: words from the source, as they are said there."),
-	referenceText: text("What the learner reads aloud: a sentence or two from the source."),
-	instructions: text("Optional. The task, shown to the learner before the item: what to do (\"Complete the sentence. Use ONE word.\"), or how to read it aloud. Never part of the text the learner answers."),
-	prompt: text("The writing task, as plain text."),
+	transcript: text$1("What the learner hears and types: words from the source, as they are said there."),
+	referenceText: text$1("What the learner reads aloud: a sentence or two from the source."),
+	instructions: text$1("Optional. The task, shown to the learner before the item: what to do (\"Complete the sentence. Use ONE word.\"), or how to read it aloud. Never part of the text the learner answers."),
+	prompt: text$1("The writing task, as plain text."),
 	minWords: {
 		type: "integer",
 		minimum: 0
@@ -1937,8 +2698,8 @@ const FIELDS = {
 				type: "object",
 				required: ["name"],
 				properties: {
-					name: text("A short name."),
-					description: text("What it looks for.")
+					name: text$1("A short name."),
+					description: text$1("What it looks for.")
 				}
 			}
 		} }
@@ -1946,7 +2707,7 @@ const FIELDS = {
 	feedback: FEEDBACK
 };
 /** The fields a model writes for each type: a draft's own names, never an id or a setting. */
-const WRITES = {
+const WRITES$1 = {
 	"multiple-choice": [
 		"title",
 		"instructions",
@@ -1997,9 +2758,9 @@ function itemShape(types, captions) {
 	const properties = { type: {
 		type: "string",
 		enum: [...types],
-		description: `The item's type, and the fields it fills. ${types.map((type) => `${type}: ${WRITES[type].filter((name) => name !== "title").join(", ")}`).join(". ")}.`
+		description: `The item's type, and the fields it fills. ${types.map((type) => `${type}: ${WRITES$1[type].filter((name) => name !== "title").join(", ")}`).join(". ")}.`
 	} };
-	for (const type of types) for (const name of WRITES[type]) properties[name] = FIELDS[name];
+	for (const type of types) for (const name of WRITES$1[type]) properties[name] = FIELDS[name];
 	if (captions) properties.caption = {
 		type: "integer",
 		minimum: 0,
@@ -2016,7 +2777,7 @@ function itemShape(types, captions) {
 	};
 }
 /** A reply of up to `max` drafts — exactly `exactly` on a repair. */
-function replyShape(types, captions, max, exactly) {
+function replyShape$1(types, captions, max, exactly) {
 	return {
 		type: "object",
 		required: ["drafts"],
@@ -2058,7 +2819,7 @@ function aiDraftsRequest(input) {
 	if (count !== void 0 && (!Number.isInteger(count) || count < 1 || count > 50)) throw new RangeError(`aiDraftsRequest: count must be a whole number from 1 to 50, or left out, not ${String(count)}.`);
 	let facts;
 	if (source.kind === "captions") {
-		const captions = (Array.isArray(source.cues) ? source.cues : []).flatMap((cue, index) => isRecord$1(cue) && typeof cue.text === "string" && cue.text.trim() !== "" && Number.isFinite(cue.start) && Number.isFinite(cue.end) ? [{
+		const captions = (Array.isArray(source.cues) ? source.cues : []).flatMap((cue, index) => isRecord$2(cue) && typeof cue.text === "string" && cue.text.trim() !== "" && Number.isFinite(cue.start) && Number.isFinite(cue.end) ? [{
 			index,
 			start: cue.start,
 			end: cue.end,
@@ -2086,17 +2847,17 @@ function aiDraftsRequest(input) {
 			...level !== void 0 ? { level } : {},
 			...instructions !== void 0 ? { instructions } : {}
 		},
-		shape: replyShape(types, facts.kind === "captions", count ?? 50),
+		shape: replyShape$1(types, facts.kind === "captions", count ?? 50),
 		...settings !== void 0 ? { settings } : {}
 	};
 }
-const stringOf = (value) => typeof value === "string" ? value : "";
-const listOf = (value) => Array.isArray(value) ? value : [];
-const written = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
+const stringOf$1 = (value) => typeof value === "string" ? value : "";
+const listOf$1 = (value) => Array.isArray(value) ? value : [];
+const written$1 = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
 function feedbackOf(entry) {
-	if (!isRecord$1(entry.feedback)) return {};
-	const correct = written(entry.feedback.correct);
-	const incorrect = written(entry.feedback.incorrect);
+	if (!isRecord$2(entry.feedback)) return {};
+	const correct = written$1(entry.feedback.correct);
+	const incorrect = written$1(entry.feedback.incorrect);
 	return correct === void 0 && incorrect === void 0 ? {} : { feedback: {
 		...correct !== void 0 ? { correct } : {},
 		...incorrect !== void 0 ? { incorrect } : {}
@@ -2104,7 +2865,7 @@ function feedbackOf(entry) {
 }
 /** The instructions a model wrote for the learner, when it wrote any. */
 function instructionsOf(entry) {
-	const instructions = written(entry.instructions);
+	const instructions = written$1(entry.instructions);
 	return instructions !== void 0 ? { instructions } : {};
 }
 /** A type's content, read from what a model wrote. */
@@ -2112,14 +2873,14 @@ function contentOf(type, entry, newId) {
 	switch (type) {
 		case "multiple-choice": return {
 			...instructionsOf(entry),
-			question: stringOf(entry.question),
+			question: stringOf$1(entry.question),
 			...typeof entry.mode === "string" ? { mode: entry.mode } : {},
-			options: listOf(entry.options).map((option) => {
-				const fields = isRecord$1(option) ? option : {};
-				const feedback = written(fields.feedback);
+			options: listOf$1(entry.options).map((option) => {
+				const fields = isRecord$2(option) ? option : {};
+				const feedback = written$1(fields.feedback);
 				return {
 					id: newId(),
-					text: stringOf(fields.text),
+					text: stringOf$1(fields.text),
 					isCorrect: fields.isCorrect === true,
 					...feedback !== void 0 ? { feedback } : {}
 				};
@@ -2128,13 +2889,13 @@ function contentOf(type, entry, newId) {
 		};
 		case "fill-in-the-blanks": return {
 			...instructionsOf(entry),
-			passage: stringOf(entry.passage),
-			blanks: listOf(entry.blanks).map((blank, index) => {
-				const fields = isRecord$1(blank) ? blank : {};
-				const hint = written(fields.hint);
+			passage: stringOf$1(entry.passage),
+			blanks: listOf$1(entry.blanks).map((blank, index) => {
+				const fields = isRecord$2(blank) ? blank : {};
+				const hint = written$1(fields.hint);
 				return {
 					id: String(index + 1),
-					acceptedAnswers: listOf(fields.acceptedAnswers).filter((answer) => typeof answer === "string"),
+					acceptedAnswers: listOf$1(fields.acceptedAnswers).filter((answer) => typeof answer === "string"),
 					...hint !== void 0 ? { hint } : {}
 				};
 			}),
@@ -2142,14 +2903,14 @@ function contentOf(type, entry, newId) {
 		};
 		case "gap-select": return {
 			...instructionsOf(entry),
-			passage: stringOf(entry.passage),
-			gaps: listOf(entry.gaps).map((gap, index) => {
-				const marked = listOf(isRecord$1(gap) ? gap.choices : void 0);
+			passage: stringOf$1(entry.passage),
+			gaps: listOf$1(entry.gaps).map((gap, index) => {
+				const marked = listOf$1(isRecord$2(gap) ? gap.choices : void 0);
 				const choices = marked.map((choice) => ({
 					id: newId(),
-					text: stringOf(isRecord$1(choice) ? choice.text : void 0)
+					text: stringOf$1(isRecord$2(choice) ? choice.text : void 0)
 				}));
-				const right = marked.flatMap((choice, at) => isRecord$1(choice) && choice.isCorrect === true ? [at] : []);
+				const right = marked.flatMap((choice, at) => isRecord$2(choice) && choice.isCorrect === true ? [at] : []);
 				return {
 					id: String(index + 1),
 					choices,
@@ -2159,25 +2920,25 @@ function contentOf(type, entry, newId) {
 			...feedbackOf(entry)
 		};
 		case "dictation": return {
-			transcript: stringOf(entry.transcript),
+			transcript: stringOf$1(entry.transcript),
 			...feedbackOf(entry)
 		};
 		case "read-aloud": return {
-			referenceText: stringOf(entry.referenceText),
+			referenceText: stringOf$1(entry.referenceText),
 			...instructionsOf(entry),
 			...feedbackOf(entry)
 		};
 		default: {
-			const criteria = listOf(isRecord$1(entry.rubric) ? entry.rubric.criteria : void 0);
+			const criteria = listOf$1(isRecord$2(entry.rubric) ? entry.rubric.criteria : void 0);
 			return {
-				prompt: stringOf(entry.prompt),
+				prompt: stringOf$1(entry.prompt),
 				...entry.minWords !== void 0 ? { minWords: entry.minWords } : {},
 				...entry.maxWords !== void 0 ? { maxWords: entry.maxWords } : {},
 				...criteria.length > 0 ? { rubric: { criteria: criteria.map((criterion) => {
-					const fields = isRecord$1(criterion) ? criterion : {};
-					const description = written(fields.description);
+					const fields = isRecord$2(criterion) ? criterion : {};
+					const description = written$1(fields.description);
 					return {
-						name: stringOf(fields.name),
+						name: stringOf$1(fields.name),
 						...description !== void 0 ? { description } : {},
 						weight: 1
 					};
@@ -2219,7 +2980,7 @@ function draftFrom(type, entry, id, newId, request) {
 		...startOf(type),
 		...locale !== void 0 ? { locale } : {},
 		...request.settings?.[type],
-		title: stringOf(entry.title),
+		title: stringOf$1(entry.title),
 		...contentOf(type, entry, newId),
 		schemaVersion: "1.0",
 		type,
@@ -2227,7 +2988,7 @@ function draftFrom(type, entry, id, newId, request) {
 	};
 }
 /** Ids from the host, checked as `createDraft` checks them. */
-function idSource(newId, caller) {
+function idSource$1(newId, caller) {
 	const issued = /* @__PURE__ */ new Set();
 	return () => {
 		const id = newId();
@@ -2243,7 +3004,7 @@ function inAuthorsOrder(drafts, types) {
 }
 function check(raw, request, newId, keep = []) {
 	const types = request.facts.activityTypes;
-	if (!isRecord$1(raw) || !Array.isArray(raw.drafts) || !raw.drafts.every((entry) => isRecord$1(entry) && types.includes(entry.type))) return {
+	if (!isRecord$2(raw) || !Array.isArray(raw.drafts) || !raw.drafts.every((entry) => isRecord$2(entry) && types.includes(entry.type))) return {
 		ok: false,
 		refusal: "malformed"
 	};
@@ -2259,7 +3020,7 @@ function check(raw, request, newId, keep = []) {
 		const type = entry.type;
 		const draft = draftFrom(type, entry, keep[position] ?? newId(), newId, request);
 		const caption = source.kind === "captions" && Number.isInteger(entry.caption) ? source.captions.find((one) => one.index === entry.caption) : void 0;
-		const said = fold(stringOf(entry.transcript));
+		const said = fold(stringOf$1(entry.transcript));
 		const clip = type === "dictation" && caption !== void 0 && containsWords(fold(caption.text), said) ? {
 			start: caption.start,
 			end: caption.end
@@ -2311,14 +3072,14 @@ function check(raw, request, newId, keep = []) {
 * @throws Error when `newId` returns an empty or repeated id.
 */
 function checkAiDrafts(raw, request, options) {
-	return check(raw, request, idSource(options.newId, "checkAiDrafts"));
+	return check(raw, request, idSource$1(options.newId, "checkAiDrafts"));
 }
 /**
 * Where a model wrote what a problem names: the draft's paths, but a gap's key
 * is its choices, and a reading too long for the host's recording time is the
 * text the model chose.
 */
-function pathForModel(type, problem) {
+function pathForModel$1(type, problem) {
 	const { path, code } = problem;
 	if (type === "gap-select" && path.length === 3 && path[0] === "gaps" && path[2] === "correctChoiceId") return [
 		"gaps",
@@ -2333,8 +3094,8 @@ function pathForModel(type, problem) {
 * dictation in a video with no recording, is the host's to finish, and is not
 * sent back.
 */
-function problemsOf(one) {
-	const writes = WRITES[one.type];
+function problemsOf$1(one) {
+	const writes = WRITES$1[one.type];
 	return [...one.validation.issues.map((found) => ({
 		path: found.path,
 		code: found.code,
@@ -2347,7 +3108,7 @@ function problemsOf(one) {
 		severity: "warning"
 	}))].map((problem) => ({
 		...problem,
-		path: pathForModel(one.type, problem)
+		path: pathForModel$1(one.type, problem)
 	})).filter((problem) => writes.includes(problem.path[0]));
 }
 /**
@@ -2361,7 +3122,7 @@ function problemsOf(one) {
 */
 function aiDraftsRepairRequest(request, drafts) {
 	const repair = ("drafts" in drafts ? drafts.drafts : drafts).flatMap((one) => {
-		const problems = problemsOf(one);
+		const problems = problemsOf$1(one);
 		return problems.length === 0 ? [] : [{
 			index: one.index,
 			draft: one.generated,
@@ -2372,20 +3133,20 @@ function aiDraftsRepairRequest(request, drafts) {
 	const { repair: _previous, ...first } = request;
 	return {
 		...first,
-		shape: replyShape(request.facts.activityTypes, request.facts.source.kind === "captions", repair.length, repair.length),
+		shape: replyShape$1(request.facts.activityTypes, request.facts.source.kind === "captions", repair.length, repair.length),
 		repair
 	};
 }
-const RANK = {
+const RANK$1 = {
 	complete: 2,
 	incomplete: 1,
 	invalid: 0
 };
 /** Whether a repaired draft is at least as good as the one it would replace. */
-function noWorse(repaired, before) {
+function noWorse$1(repaired, before) {
 	const warnings = (one) => one.findings.filter((found) => found.severity === "warning").length;
-	const now = RANK[repaired.validation.status];
-	const was = RANK[before.validation.status];
+	const now = RANK$1[repaired.validation.status];
+	const was = RANK$1[before.validation.status];
 	return now > was || now === was && warnings(repaired) <= warnings(before);
 }
 /**
@@ -2418,7 +3179,7 @@ async function generateDrafts(input) {
 	const repairs = input.repairs ?? 1;
 	if (!Number.isInteger(repairs) || repairs < 0 || repairs > 3) throw new RangeError(`generateDrafts: repairs must be a whole number from 0 to 3, not ${String(repairs)}.`);
 	const calls = [];
-	const ids = idSource(newId, "generateDrafts");
+	const ids = idSource$1(newId, "generateDrafts");
 	const ask = async (asked, keep) => {
 		let raw;
 		try {
@@ -2463,7 +3224,7 @@ async function generateDrafts(input) {
 		if (repaired === void 0) break;
 		current = current.map((before) => {
 			const after = repaired.drafts.find((one) => one.index === before.index);
-			return after !== void 0 && noWorse(after, before) ? after : before;
+			return after !== void 0 && noWorse$1(after, before) ? after : before;
 		});
 	}
 	return {
@@ -2498,7 +3259,7 @@ function sourceText(request) {
 */
 function interactiveVideoFromDrafts(input) {
 	const { request, drafts, video, durationSeconds, title } = input;
-	const ids = idSource(input.newId, "interactiveVideoFromDrafts");
+	const ids = idSource$1(input.newId, "interactiveVideoFromDrafts");
 	const types = request.facts.activityTypes;
 	const list = "drafts" in drafts ? drafts.drafts : drafts;
 	const end = typeof durationSeconds === "number" && Number.isFinite(durationSeconds) && durationSeconds >= 0 ? durationSeconds : void 0;
@@ -2609,7 +3370,7 @@ function textField(value, max) {
 		value: cleaned === "" ? void 0 : cleaned
 	};
 }
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** The corrections, each anchored in the draft, or why the reply is refused. */
 function checkCorrections(raw, text) {
 	if (raw === void 0 || raw === null) return {
@@ -2631,7 +3392,7 @@ function checkCorrections(raw, text) {
 	const taken = /* @__PURE__ */ new Set();
 	const corrections = [];
 	for (const entry of raw) {
-		if (!isRecord(entry) || typeof entry.original !== "string") return {
+		if (!isRecord$1(entry) || typeof entry.original !== "string") return {
 			ok: false,
 			refusal: "malformed"
 		};
@@ -2653,7 +3414,7 @@ function checkCorrections(raw, text) {
 		if (!category.ok) return category;
 		let claimed;
 		if (entry.range !== void 0 && entry.range !== null) {
-			if (!isRecord(entry.range)) return {
+			if (!isRecord$1(entry.range)) return {
 				ok: false,
 				refusal: "malformed"
 			};
@@ -2747,9 +3508,134 @@ function aiGradingRequest(input) {
 		}
 	};
 }
+const MEASURES = SPEAKING_MEASURES;
+/**
+* The request for a model's grade of a spoken answer (1.9), or why there is
+* none to make.
+*
+* Built as a written response's is, on the server and from the whole item, with
+* the take's evidence: the model reads `assessment.transcript` — the
+* transcriber's verbatim text, the same text the engine measured the take
+* against — and scores the criteria a judge scores: those that name no
+* `measure`, or every criterion when `judgeMeasures` is set. The measured
+* criteria go with it as context, with the engine's scores, so feedback can
+* speak of them; the model does not score them.
+*
+* The evidence is checked as `gradeSpeakingResponse` checks it — valid,
+* unscripted, for this item's locale and this response's recording — so a model
+* is never paid to judge a take the grade would refuse. Read the reply with
+* `checkAiGrading`, and grade with `gradeSpeakingResponse` under the same
+* `judgeMeasures`.
+*/
+function aiSpeakingGradingRequest(input) {
+	const { data, response, learnerLocale } = input;
+	if (data.type !== "speaking-response") return {
+		ok: false,
+		problem: "not-speaking-response"
+	};
+	if (data.redacted === true) return {
+		ok: false,
+		problem: "redacted"
+	};
+	const item = data;
+	const rubric = rubricFacts(item.rubric);
+	if (!rubric.ok) return rubric;
+	const authored = item.rubric.criteria;
+	const judged = [];
+	const measured = [];
+	for (const [index, fact] of rubric.criteria.entries()) {
+		const measure = authored[index].measure;
+		if (measure !== void 0 && !MEASURES.includes(measure)) return {
+			ok: false,
+			problem: "no-rubric",
+			path: [
+				"rubric",
+				"criteria",
+				index,
+				"measure"
+			]
+		};
+		if (measure === void 0 || input.judgeMeasures === true) judged.push({
+			...fact,
+			...measure !== void 0 ? { measure } : {}
+		});
+		else measured.push({
+			name: fact.name,
+			measure,
+			weight: fact.weight
+		});
+	}
+	if (judged.length === 0) return {
+		ok: false,
+		problem: "nothing-to-judge"
+	};
+	const recording = response?.type === "speaking-response" ? response.recording : null;
+	if (recording === null || recording === void 0) return {
+		ok: false,
+		problem: "empty-response"
+	};
+	const checked = input.assessment === null || input.assessment === void 0 ? void 0 : validateSpeechAssessment(input.assessment);
+	if (checked === void 0 || !checked.success) return {
+		ok: false,
+		problem: "invalid-assessment"
+	};
+	const evidence = checked.data;
+	if (evidence.status === "no_speech") return {
+		ok: false,
+		problem: "empty-response"
+	};
+	if (evidence.task !== "unscripted" || evidence.locale !== item.locale || evidence.recordingKey !== recording.key) return {
+		ok: false,
+		problem: "evidence-mismatch"
+	};
+	if (evidence.transcript === void 0) return {
+		ok: false,
+		problem: "no-transcript"
+	};
+	const text = evidence.transcript.text;
+	const scores = evidence.scores;
+	const scoreOf = {
+		pronunciation: scores.accuracy,
+		fluency: scores.fluency,
+		prosody: scores.prosody
+	};
+	const media = isRecord$1(item.media) && typeof item.media.type === "string" ? item.media : void 0;
+	const material = materialFacts(input.group);
+	return {
+		ok: true,
+		request: {
+			feature: "speaking-grading",
+			facts: {
+				activityType: "speaking-response",
+				activityId: data.id,
+				title: data.title,
+				locale: item.locale,
+				...typeof item.instructions === "string" ? { instructions: item.instructions } : {},
+				prompt: typeof item.prompt === "string" ? item.prompt : "",
+				...media !== void 0 ? { media: {
+					type: media.type,
+					...typeof media.alt === "string" ? { alt: media.alt } : {}
+				} } : {},
+				text,
+				wordCount: countWords(text),
+				rubric: judged,
+				measured: measured.map((fact) => {
+					const score = scoreOf[fact.measure];
+					return score !== void 0 ? {
+						...fact,
+						score
+					} : fact;
+				}),
+				...typeof item.languageTarget === "string" ? { languageTarget: item.languageTarget } : {}
+			},
+			...material !== null ? { material } : {},
+			...learnerLocale !== void 0 ? { learnerLocale } : {}
+		}
+	};
+}
 /** The rubric as a model is given it, each criterion's levels read. */
 function rubricFacts(rubric) {
-	const listed = isRecord(rubric) ? rubric.criteria : void 0;
+	const listed = isRecord$1(rubric) ? rubric.criteria : void 0;
 	if (!Array.isArray(listed) || listed.length === 0) return {
 		ok: false,
 		problem: "no-rubric"
@@ -2757,7 +3643,7 @@ function rubricFacts(rubric) {
 	const criteria = [];
 	const names = /* @__PURE__ */ new Set();
 	for (const [index, criterion] of listed.entries()) {
-		if (!isRecord(criterion)) return {
+		if (!isRecord$1(criterion)) return {
 			ok: false,
 			problem: "no-rubric",
 			path: [
@@ -2926,7 +3812,7 @@ function judgeCriterion(entry, criterion) {
 * `gradeFromRubric` computes every grade in the SDK.
 */
 function checkAiGrading(raw, request) {
-	if (!isRecord(raw)) return {
+	if (!isRecord$1(raw)) return {
 		ok: false,
 		refusal: "malformed"
 	};
@@ -2943,7 +3829,7 @@ function checkAiGrading(raw, request) {
 	const indexOf = criterionIndex(rubric);
 	const judged = rubric.map(() => void 0);
 	for (const entry of listed) {
-		if (!isRecord(entry)) return {
+		if (!isRecord$1(entry)) return {
 			ok: false,
 			refusal: "malformed"
 		};
@@ -3004,6 +3890,1498 @@ function checkAiGrading(raw, request) {
 		}
 	};
 }
+// src/ai-variants.ts
+/** The most exemplars one request may vary: a long section is sent in parts. */
+const AI_VARIANTS_MAX_EXEMPLARS = 20;
+/** The most repair passes `generateVariants` makes. */
+const AI_VARIANTS_MAX_REPAIRS = 3;
+/** The longest passage or script, in characters, an exemplar may carry into the facts. */
+const AI_VARIANTS_MAX_MATERIAL_LENGTH = AI_MATERIAL_MAX_LENGTH;
+/**
+* Every code a variant can be reported with, and its severity: a contract,
+* as the critic's codes are. `docs/ai.md` documents this table and a test
+* holds the two together.
+*/
+const AI_VARIANT_CODE_SEVERITY = {
+	variant_missing: "invalid",
+	variant_type: "invalid",
+	variant_structure: "invalid",
+	variant_length: "warning",
+	variant_near_copy: "warning",
+	variant_same_key: "warning"
+};
+/** The activity types the SDK writes variants of: the ones whose every field it knows. */
+const VARIANT_TYPES = [
+	"multiple-choice",
+	"fill-in-the-blanks",
+	"gap-select",
+	"dictation",
+	"read-aloud",
+	"written-response"
+];
+const DIFFICULTIES = [
+	"easier",
+	"same",
+	"harder"
+];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const listOf = (value) => Array.isArray(value) ? value : [];
+const stringOf = (value) => typeof value === "string" ? value : "";
+const written = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
+const textList = (value) => listOf(value).filter((one) => typeof one === "string");
+/** A copy of plain content, so a variant never shares an object with its exemplar. */
+const clone = (value) => JSON.parse(JSON.stringify(value));
+const isRecording = (media) => isRecord(media) && [
+	"audio",
+	"video",
+	"embed"
+].includes(stringOf(media.type));
+const isImage = (media) => isRecord(media) && media.type === "image";
+const RULES = [
+	"Write one variant for each exemplar, naming its exemplar index and its type.",
+	"Keep each exemplar's targets.structure exactly: the same number of options and of right options, blanks, gaps, choices and banks, items in the same order, and speakers.",
+	"Write every word a learner reads or hears, in new words: never the exemplar's sentences with a few words changed. Write nothing else: no ids, HTML, addresses or settings.",
+	"Keep each text within its targets.lengths, counted in words.",
+	"Test the same skill with the same kind of thinking at the same level: a literal question stays literal, an inference stays an inference, and wrong options stay as plausible as the exemplar's.",
+	"Give each item a right answer other than its exemplar's, and other than the answers in avoid, unless the skill tested leaves only one.",
+	"Keep the task in instructions as the exemplar's; change its wording only where the new item needs it.",
+	"Keep a title that is a label (Part 1) as it is; give a title that names the topic a new one that gives no answer away.",
+	"Do not repeat the flaws listed in targets.exemplarFindings.",
+	"A listening script keeps the number of speakers, with new names, and about as many turns."
+];
+const DESCRIBE_RULE = "Where an exemplar shows a picture, describe a new picture in its media alt, specific enough for a person to find or draw it, and ask about that picture.";
+const REUSE_RULE = "Where an exemplar shows a picture, keep it: write new questions about the same picture, which its alt describes.";
+const DIFFICULTY_RULE = "Where targets.difficulty is easier or harder, move one step, inside the level, using targets.levers. Never write for another level.";
+const LEVEL_FACTS_RULE = "Use only grammar and vocabulary that levelFacts lists as taught, and keep away from the topics it lists.";
+/** The ways a type is made easier or harder: one step inside a level. */
+const LEVERS = {
+	"multiple-choice": {
+		easier: [
+			"Make the wrong options clearly wrong to a learner who understood, though still plausible to one who did not.",
+			"Ask about what is said directly rather than what is implied.",
+			"Word the right option closer to the words of the text or recording."
+		],
+		harder: [
+			"Make the wrong options closer to the right one, each wrong for a reason the text or recording makes clear.",
+			"Ask for an inference rather than a fact stated directly.",
+			"Paraphrase the right option rather than repeat the words of the text or recording."
+		]
+	},
+	"fill-in-the-blanks": {
+		easier: ["Give more context around each blank that points to the answer."],
+		harder: ["Give less context around each blank, so the learner must know the form rather than infer it."]
+	},
+	"gap-select": {
+		easier: ["Give more context around each gap that points to the answer.", "Make the wrong choices clearly wrong in context."],
+		harder: ["Give less context around each gap.", "Make the wrong choices closer to the right one."]
+	},
+	dictation: {
+		easier: ["Use shorter sentences and more frequent words of the level, inside the length band."],
+		harder: ["Use longer sentences and less frequent words of the level, inside the length band.", "Use more connected-speech features: contractions, linking, weak forms."]
+	},
+	"read-aloud": {
+		easier: ["Use shorter sentences and more frequent words of the level, inside the length band."],
+		harder: ["Use longer sentences and less frequent words of the level, inside the length band.", "Use more words with sounds and stress the level finds hard."]
+	},
+	"written-response": {
+		easier: ["Make the task more specific, and supply more of the content to write about."],
+		harder: ["Make the task more open, so the learner supplies more of the content."]
+	},
+	reading: {
+		easier: ["Ask about what the passage says directly rather than what it implies.", "Use more frequent words of the level, and shorter sentences with simpler syntax."],
+		harder: ["Ask for inferences rather than facts stated directly.", "Use less frequent words of the level, and longer sentences."]
+	},
+	listening: {
+		easier: ["Describe a slower pace in the script, and have a speaker repeat the key information.", "Use more frequent words of the level."],
+		harder: ["Describe a natural pace in the script, and give the key information once.", "Use less frequent words of the level."]
+	}
+};
+function leversFor(entry, difficulty) {
+	if (difficulty === "same") return;
+	let kind = stringOf(entry.type);
+	if (kind === "item-group") {
+		const stimulus = isRecord(entry.stimulus) ? entry.stimulus : {};
+		kind = stimulus.kind === "audio" || stimulus.kind === "video" ? "listening" : "reading";
+	}
+	const levers = LEVERS[kind];
+	return levers !== void 0 ? [...levers[difficulty]] : void 0;
+}
+/** A passage with its placeholders numbered in order: `{{1}}`, `{{2}}`… — how a variant writes them. */
+function renumbered(passage) {
+	let position = 0;
+	return passage.replace(PLACEHOLDER_RE, () => {
+		position += 1;
+		return `{{${position}}}`;
+	});
+}
+const turnsOf = (holder) => listOf(holder.script).flatMap((turn) => isRecord(turn) ? [{
+	speaker: stringOf(turn.speaker),
+	text: stringOf(turn.text)
+}] : []);
+const hasScript = (holder) => listOf(holder.script).some(isRecord);
+/** What a model is shown of a media object: a picture's description, or what a recording says. */
+function mediaContent(media, ownText, ref) {
+	if (!isRecord(media)) return;
+	if (isImage(media)) return {
+		alt: stringOf(media.alt),
+		...ref !== void 0 ? { ref } : {}
+	};
+	if (ownText || !isRecording(media)) return;
+	if (hasScript(media)) return { script: turnsOf(media) };
+	return typeof media.transcript === "string" ? { transcript: media.transcript } : void 0;
+}
+function feedbackContent(holder) {
+	if (!isRecord(holder.feedback)) return {};
+	const { correct, incorrect } = holder.feedback;
+	return { feedback: {
+		...typeof correct === "string" ? { correct } : {},
+		...typeof incorrect === "string" ? { incorrect } : {}
+	} };
+}
+function itemContent(item, refOf, at) {
+	const type = stringOf(item.type);
+	const ownText = type === "dictation" || type === "read-aloud";
+	const media = mediaContent(item.media, ownText, refOf([...at, "media"]));
+	const content = {
+		type,
+		title: stringOf(item.title),
+		...typeof item.instructions === "string" ? { instructions: item.instructions } : {}
+	};
+	switch (type) {
+		case "multiple-choice":
+			Object.assign(content, {
+				question: stringOf(item.question),
+				options: listOf(item.options).map((option, index) => {
+					const fields = isRecord(option) ? option : {};
+					const optionMedia = mediaContent(fields.media, false, refOf([
+						...at,
+						"options",
+						index,
+						"media"
+					]));
+					return {
+						text: stringOf(fields.text),
+						isCorrect: fields.isCorrect === true,
+						...typeof fields.feedback === "string" ? { feedback: fields.feedback } : {},
+						...optionMedia !== void 0 ? { media: optionMedia } : {}
+					};
+				})
+			});
+			break;
+		case "fill-in-the-blanks":
+			Object.assign(content, {
+				passage: renumbered(stringOf(item.passage)),
+				blanks: inPassageOrder(item, "blanks").map(({ value }) => {
+					const blank = isRecord(value) ? value : {};
+					return {
+						acceptedAnswers: textList(blank.acceptedAnswers),
+						...typeof blank.hint === "string" ? { hint: blank.hint } : {},
+						...typeof blank.feedback === "string" ? { feedback: blank.feedback } : {}
+					};
+				})
+			});
+			break;
+		case "gap-select": {
+			const banks = listOf(item.banks).filter(isRecord);
+			Object.assign(content, {
+				passage: renumbered(stringOf(item.passage)),
+				gaps: inPassageOrder(item, "gaps").map(({ value }) => {
+					const gap = isRecord(value) ? value : {};
+					const feedback = typeof gap.feedback === "string" ? { feedback: gap.feedback } : {};
+					const bank = banks.find((one) => one.id === gap.bankId);
+					if (listOf(gap.choices).length === 0 && bank !== void 0) {
+						const right = listOf(bank.choices).find((choice) => isRecord(choice) && choice.id === gap.correctChoiceId);
+						return {
+							answer: isRecord(right) ? stringOf(right.text) : "",
+							...feedback
+						};
+					}
+					return {
+						choices: listOf(gap.choices).map((choice) => ({
+							text: isRecord(choice) ? stringOf(choice.text) : "",
+							isCorrect: isRecord(choice) && choice.id === gap.correctChoiceId
+						})),
+						...feedback
+					};
+				}),
+				...banks.length > 0 ? { banks: banks.map((bank) => ({ choices: listOf(bank.choices).map((choice) => isRecord(choice) ? stringOf(choice.text) : "") })) } : {}
+			});
+			break;
+		}
+		case "dictation":
+			Object.assign(content, {
+				transcript: stringOf(item.transcript),
+				...Array.isArray(item.acceptedTranscripts) ? { acceptedTranscripts: textList(item.acceptedTranscripts) } : {}
+			});
+			break;
+		case "read-aloud":
+			content.referenceText = stringOf(item.referenceText);
+			break;
+		default: content.prompt = stringOf(item.prompt);
+	}
+	return {
+		...content,
+		...media !== void 0 ? { media } : {},
+		...feedbackContent(item)
+	};
+}
+function entryContent(entry, refOf) {
+	if (entry.type !== "item-group") return itemContent(entry, refOf, []);
+	const stimulus = isRecord(entry.stimulus) ? entry.stimulus : {};
+	const ownText = hasScript(stimulus) || typeof stimulus.transcript === "string";
+	const media = mediaContent(stimulus.media, ownText, refOf(["stimulus", "media"]));
+	return {
+		type: "item-group",
+		...typeof entry.title === "string" ? { title: entry.title } : {},
+		stimulus: {
+			kind: stringOf(stimulus.kind),
+			...typeof stimulus.title === "string" ? { title: stimulus.title } : {},
+			...typeof stimulus.body === "string" ? { body: stimulus.body } : {},
+			...hasScript(stimulus) ? { script: turnsOf(stimulus) } : typeof stimulus.transcript === "string" ? { transcript: stimulus.transcript } : {},
+			...media ?? {}
+		},
+		items: listOf(entry.items).map((item, index) => isRecord(item) ? itemContent(item, refOf, ["items", index]) : {})
+	};
+}
+/** Every picture an entry shows: an item's, an option's, and a group's material's. */
+function imageSlots(entry) {
+	const ofItem = (item, at) => {
+		if (!isRecord(item)) return [];
+		return [...isImage(item.media) ? [{
+			path: [...at, "media"],
+			media: item.media
+		}] : [], ...listOf(item.options).flatMap((option, index) => isRecord(option) && isImage(option.media) ? [{
+			path: [
+				...at,
+				"options",
+				String(index),
+				"media"
+			],
+			media: option.media
+		}] : [])];
+	};
+	if (entry.type !== "item-group") return ofItem(entry, []);
+	const stimulus = isRecord(entry.stimulus) ? entry.stimulus : {};
+	return [...isImage(stimulus.media) ? [{
+		path: ["stimulus", "media"],
+		media: stimulus.media
+	}] : [], ...listOf(entry.items).flatMap((item, index) => ofItem(item, ["items", String(index)]))];
+}
+/** Whether a recording the item's meaning depends on says nothing the facts can carry. */
+function unheard(entry) {
+	const itemUnheard = (item) => {
+		if (!isRecord(item) || item.type === "dictation" || item.type === "read-aloud") return false;
+		return isRecording(item.media) && transcriptOf(item.media) === null || listOf(item.options).some((option) => isRecord(option) && isRecording(option.media) && transcriptOf(option.media) === null);
+	};
+	if (entry.type !== "item-group") return itemUnheard(entry);
+	const stimulus = isRecord(entry.stimulus) ? entry.stimulus : {};
+	return (stimulus.kind === "audio" || stimulus.kind === "video" || isRecording(stimulus.media)) && transcriptOf(stimulus) === null || listOf(entry.items).some(itemUnheard);
+}
+function skipOf(entry, exemplarIndex, imagePolicy) {
+	const skip = (code, message) => ({
+		exemplarIndex,
+		code,
+		message
+	});
+	const group = entry.type === "item-group";
+	if (group && entry.timeline !== void 0 && entry.timeline !== null) return skip("variant_exemplar_timeline", "An interactive video is not varied: its questions are timed to its video.");
+	const unsupported = (group ? listOf(entry.items).map((item) => isRecord(item) ? stringOf(item.type) : "") : [stringOf(entry.type)]).find((type) => getActivityTypeDescriptor(type) !== void 0 && !VARIANT_TYPES.includes(type));
+	if (unsupported !== void 0) return skip("variant_exemplar_unsupported", `The SDK does not write variants of ${unsupported}: it does not know which of its fields are words and which are settings.`);
+	if (imagePolicy === "reuse" && imageSlots(entry).some((slot) => written(slot.media.alt) === void 0)) return skip("variant_exemplar_unseen", "A picture this depends on has no description (alt), so a model cannot write questions about it.");
+	const validation = group ? validateItemGroupDraft(entry) : validateDraft(entry.type, entry);
+	if (validation.status !== "complete") {
+		const first = validation.issues[0];
+		return skip("variant_exemplar_incomplete", `This is not a finished item (${first !== void 0 ? `${first.code} at ${first.path.join(".") || "its root"}` : validation.status}), so it has no structure to copy.`);
+	}
+	if (unheard(entry)) return skip("variant_exemplar_unheard", "A recording this depends on has no transcript or script, so a model cannot know what it says.");
+	const long = textsOf(entry).find((text) => text.text.length > AI_VARIANTS_MAX_MATERIAL_LENGTH);
+	if (long !== void 0) return skip("variant_exemplar_too_long", `${long.path.join(".")} is longer than ${AI_VARIANTS_MAX_MATERIAL_LENGTH} characters. Send a shorter part.`);
+}
+const text = (description) => ({
+	type: "string",
+	description
+});
+const SCRIPT_SHAPE = {
+	type: "array",
+	minItems: 1,
+	description: "The recording as turns, in order: a new name for each speaker, as many speakers as the exemplar.",
+	items: {
+		type: "object",
+		required: ["speaker", "text"],
+		properties: {
+			speaker: text("Who speaks."),
+			text: text("What they say.")
+		}
+	}
+};
+const MEDIA_SHAPE = {
+	type: "object",
+	description: "Only where the exemplar's content has media: for a picture, its alt; for a recording, its script — or transcript where the exemplar has no script.",
+	properties: {
+		alt: text("What the picture shows."),
+		transcript: text("What the recording says."),
+		script: SCRIPT_SHAPE
+	}
+};
+const FEEDBACK_SHAPE = {
+	type: "object",
+	description: "Only where the exemplar has feedback: shown after answering.",
+	properties: {
+		correct: text("Shown when the learner passes."),
+		incorrect: text("Shown when the learner does not.")
+	}
+};
+const FIELD_SHAPES = {
+	title: text("A short name for the item, shown above it. Never the answer, or any part of it."),
+	instructions: text("Only where the exemplar has instructions: the same task, worded for the new item."),
+	question: text("The question, as plain text."),
+	options: {
+		type: "array",
+		description: "As many as the exemplar's, as many of them right.",
+		items: {
+			type: "object",
+			required: ["text", "isCorrect"],
+			properties: {
+				text: text("The option as the learner reads it."),
+				isCorrect: { type: "boolean" },
+				feedback: text("Only where the exemplar's options have feedback."),
+				media: MEDIA_SHAPE
+			}
+		}
+	},
+	passage: text("The passage as plain text, with {{1}}, {{2}}, … where each gap goes, in order."),
+	blanks: {
+		type: "array",
+		description: "One per gap, in the order the gaps appear: the first is {{1}}.",
+		items: {
+			type: "object",
+			required: ["acceptedAnswers"],
+			properties: {
+				acceptedAnswers: {
+					type: "array",
+					minItems: 1,
+					items: { type: "string" },
+					description: "Every answer that is right, spelled as a learner would type it."
+				},
+				hint: text("Only where the exemplar's blank has a hint. Never gives the answer away."),
+				feedback: text("Only where the exemplar's blank has feedback.")
+			}
+		}
+	},
+	gaps: {
+		type: "array",
+		description: "One per gap, in the order the gaps appear. A gap with its own choices writes `choices`, exactly one right; a gap drawing on a bank writes `answer`, the text of its right choice in that bank.",
+		items: {
+			type: "object",
+			properties: {
+				choices: {
+					type: "array",
+					items: {
+						type: "object",
+						required: ["text", "isCorrect"],
+						properties: {
+							text: text("A choice."),
+							isCorrect: { type: "boolean" }
+						}
+					}
+				},
+				answer: text("The right choice's text, exactly as its bank writes it."),
+				feedback: text("Only where the exemplar's gap has feedback.")
+			}
+		}
+	},
+	banks: {
+		type: "array",
+		description: "The shared choice lists, as many as the exemplar's, each with as many choices.",
+		items: {
+			type: "object",
+			required: ["choices"],
+			properties: { choices: {
+				type: "array",
+				items: { type: "string" }
+			} }
+		}
+	},
+	transcript: text("What the learner hears and types."),
+	acceptedTranscripts: {
+		type: "array",
+		items: { type: "string" },
+		description: "Only where the exemplar has them: other writings of the transcript that are right, of the same kind."
+	},
+	referenceText: text("What the learner reads aloud."),
+	prompt: text("The writing task, of the same genre and purpose as the exemplar's, about something new."),
+	media: MEDIA_SHAPE,
+	feedback: FEEDBACK_SHAPE
+};
+const WRITES = {
+	"multiple-choice": [
+		"title",
+		"instructions",
+		"question",
+		"options",
+		"media",
+		"feedback"
+	],
+	"fill-in-the-blanks": [
+		"title",
+		"instructions",
+		"passage",
+		"blanks",
+		"media",
+		"feedback"
+	],
+	"gap-select": [
+		"title",
+		"instructions",
+		"passage",
+		"gaps",
+		"banks",
+		"media",
+		"feedback"
+	],
+	dictation: [
+		"title",
+		"transcript",
+		"acceptedTranscripts",
+		"feedback"
+	],
+	"read-aloud": [
+		"title",
+		"instructions",
+		"referenceText",
+		"feedback"
+	],
+	"written-response": [
+		"title",
+		"prompt",
+		"media",
+		"feedback"
+	]
+};
+function itemProperties(types) {
+	const properties = {};
+	for (const type of types) for (const name of WRITES[type] ?? []) properties[name] = FIELD_SHAPES[name];
+	return properties;
+}
+/** The types an entry holds, a group's items included. */
+const typesIn = (entry) => entry.type === "item-group" ? listOf(entry.items).map((item) => isRecord(item) ? stringOf(item.type) : "") : [stringOf(entry.type)];
+function replyShape(entries, exactly) {
+	const top = [...new Set(entries.map((entry) => stringOf(entry.type)))];
+	const itemTypes = [...new Set(entries.filter((entry) => entry.type === "item-group").flatMap(typesIn))].filter((type) => VARIANT_TYPES.includes(type));
+	const properties = {
+		exemplar: {
+			type: "integer",
+			minimum: 0,
+			description: "The exemplar's index, as the facts give it."
+		},
+		type: {
+			type: "string",
+			enum: top,
+			description: "The exemplar's type."
+		},
+		...itemProperties(top.filter((type) => type !== "item-group"))
+	};
+	if (top.includes("item-group")) {
+		properties.title = FIELD_SHAPES.title;
+		properties.stimulus = {
+			type: "object",
+			description: "The new material: a passage, or what a recording says.",
+			properties: {
+				title: text("Only where the exemplar's material has a title."),
+				body: text("The passage, as plain text."),
+				transcript: text("What the recording says, where the exemplar has no script."),
+				script: SCRIPT_SHAPE,
+				alt: text("For a picture: what it shows.")
+			}
+		};
+		properties.items = {
+			type: "array",
+			description: "The questions about the new material: the exemplar's types, in its order.",
+			items: {
+				type: "object",
+				required: ["type"],
+				properties: {
+					type: {
+						type: "string",
+						enum: itemTypes
+					},
+					...itemProperties(itemTypes)
+				}
+			}
+		};
+	}
+	return {
+		type: "object",
+		required: ["variants"],
+		properties: { variants: {
+			type: "array",
+			minItems: exactly,
+			maxItems: exactly,
+			items: {
+				type: "object",
+				required: ["exemplar", "type"],
+				properties
+			}
+		} }
+	};
+}
+const facing = (path) => path.join(".").replace(/^stimulus\.media\./, "stimulus.");
+function targetsOf(entry, difficulty, reason, itemDifficulty, tolerance) {
+	const group = entry.type === "item-group";
+	const levers = leversFor(entry, difficulty);
+	const findings = group ? critiqueItemGroupDraft(entry) : critiqueDraft(entry.type, entry);
+	return {
+		type: stringOf(entry.type),
+		structure: structureTargets(entry),
+		lengths: Object.fromEntries(lengthTargets(entry, tolerance).map((target) => [facing(target.path), target.bounds])),
+		difficulty,
+		...difficulty !== "same" && reason !== void 0 ? { difficultyReason: reason } : {},
+		...levers !== void 0 ? { levers } : {},
+		...itemDifficulty !== void 0 ? { itemDifficulty } : {},
+		exemplarFindings: findings.map((found) => ({
+			code: found.code,
+			message: found.message
+		}))
+	};
+}
+const idOf = (value) => isRecord(value) && typeof value.id === "string" ? value.id : void 0;
+/**
+* What a model is given to write a variant of each exemplar — a parallel item:
+* the exemplar's type, structure, scoring and settings, with every word a
+* learner reads or hears new — and what `checkAiVariants` needs to check the
+* reply against.
+*
+* `exemplars` are loose activities and item groups as stored, answer keys and
+* author-only transcripts included, in paper order; one variant is written for
+* each that can be varied. An exemplar that cannot is left out of the facts
+* and listed in `skipped`: a recording with nothing to say what it says
+* (`variant_exemplar_unheard`), a picture with no description to reuse
+* (`variant_exemplar_unseen`), an unfinished item
+* (`variant_exemplar_incomplete`), an interactive video
+* (`variant_exemplar_timeline`), a type the SDK does not vary
+* (`variant_exemplar_unsupported`) or material over
+* {@link AI_VARIANTS_MAX_MATERIAL_LENGTH} characters
+* (`variant_exemplar_too_long`). When every exemplar is skipped the request has
+* none, and `generateVariants` makes no call.
+*
+* The facts give each exemplar's content in the shape a variant is written in,
+* and its `targets`: the structure to keep, the length of each text in words,
+* its difficulty with the levers to move it, and the critic's findings on it
+* not to repeat. `rules` are what every variant must respect, as sentences a
+* prompt can quote. Pictures are listed in `images`, for a host that attaches
+* them; no recording's address reaches the facts. `avoid` is the other forms'
+* items: compared with every variant, never varied.
+*
+* Nothing passed is changed.
+*
+* @throws RangeError when `exemplars` is empty or longer than
+*   {@link AI_VARIANTS_MAX_EXEMPLARS}, an exemplar is neither an item group nor
+*   a registered activity type, `level` is empty, a difficulty is not `easier`,
+*   `same` or `harder`, `images` is neither `describe` nor `reuse`, or
+*   `difficultyFor` names an id no exemplar has.
+*/
+function aiVariantsRequest(input) {
+	const { exemplars, level, locale, levelFacts, avoid, instructions, settings } = input;
+	const difficulty = input.difficulty ?? "same";
+	const imagePolicy = input.images ?? "describe";
+	if (!Array.isArray(exemplars) || exemplars.length === 0 || exemplars.length > 20) throw new RangeError(`aiVariantsRequest: exemplars must hold 1 to 20 entries; send a longer section in parts.`);
+	if (typeof level !== "string" || level.trim() === "") throw new RangeError("aiVariantsRequest: level is required: a variant must stay inside it.");
+	if (!DIFFICULTIES.includes(difficulty)) throw new RangeError(`aiVariantsRequest: difficulty must be easier, same or harder, not ${String(difficulty)}.`);
+	if (imagePolicy !== "describe" && imagePolicy !== "reuse") throw new RangeError(`aiVariantsRequest: images must be describe or reuse, not ${String(imagePolicy)}.`);
+	exemplars.forEach((entry, index) => {
+		const type = isRecord(entry) ? entry.type : void 0;
+		if (typeof type !== "string" || type !== "item-group" && getActivityTypeDescriptor(type) === void 0) throw new RangeError(`aiVariantsRequest: exemplar ${index} is neither an item group nor a registered activity type.`);
+	});
+	const entries = exemplars;
+	const ids = new Set(entries.flatMap((entry) => [idOf(entry), ...listOf(entry.items).map(idOf)]).filter((id) => id !== void 0));
+	for (const [id, wanted] of Object.entries(input.difficultyFor ?? {})) {
+		if (!ids.has(id)) throw new RangeError(`aiVariantsRequest: difficultyFor names "${id}", which no exemplar has.`);
+		if (!isRecord(wanted) || !DIFFICULTIES.includes(wanted.difficulty)) throw new RangeError(`aiVariantsRequest: difficultyFor["${id}"] must be easier, same or harder.`);
+	}
+	const moved = (id) => id !== void 0 ? input.difficultyFor?.[id] : void 0;
+	const skipped = [];
+	const images = [];
+	const facts = [];
+	entries.forEach((entry, exemplarIndex) => {
+		const skip = skipOf(entry, exemplarIndex, imagePolicy);
+		if (skip !== void 0) {
+			skipped.push(skip);
+			return;
+		}
+		const refs = /* @__PURE__ */ new Map();
+		for (const slot of imageSlots(entry)) {
+			const ref = `img-${images.length + 1}`;
+			refs.set(slot.path.join("."), ref);
+			images.push({
+				ref,
+				exemplarIndex,
+				path: slot.path,
+				...typeof slot.media.alt === "string" ? { alt: slot.media.alt } : {},
+				url: stringOf(slot.media.url)
+			});
+		}
+		const own = moved(idOf(entry));
+		const entryDifficulty = own?.difficulty ?? difficulty;
+		const items = entry.type === "item-group" ? listOf(entry.items) : [];
+		const perItem = items.map((item, at) => {
+			const wanted = moved(idOf(item));
+			return {
+				item: at,
+				difficulty: wanted?.difficulty ?? entryDifficulty,
+				...wanted?.reason !== void 0 ? { difficultyReason: wanted.reason } : {}
+			};
+		});
+		const itemDifficulty = perItem.some((one) => one.difficulty !== entryDifficulty || one.difficultyReason !== void 0) ? perItem.map((one) => {
+			const levers = leversFor(items[one.item], one.difficulty);
+			return {
+				...one,
+				...levers !== void 0 ? { levers } : {}
+			};
+		}) : void 0;
+		facts.push({
+			exemplar: exemplarIndex,
+			type: stringOf(entry.type),
+			content: entryContent(entry, (path) => refs.get(path.map(String).join("."))),
+			...Array.isArray(entry.learningObjectives) ? { learningObjectives: textList(entry.learningObjectives) } : {},
+			targets: targetsOf(entry, entryDifficulty, own?.reason, itemDifficulty, input.lengthTolerance)
+		});
+	});
+	const rules = [
+		...RULES,
+		...images.length > 0 ? [imagePolicy === "describe" ? DESCRIBE_RULE : REUSE_RULE] : [],
+		...facts.some((one) => one.targets.difficulty !== "same" || (one.targets.itemDifficulty ?? []).some((item) => item.difficulty !== "same")) ? [DIFFICULTY_RULE] : [],
+		...levelFacts !== void 0 ? [LEVEL_FACTS_RULE] : []
+	];
+	const varied = facts.map((one) => entries[one.exemplar]);
+	return {
+		feature: "variant-generation",
+		facts: {
+			exemplars: facts,
+			level,
+			...locale !== void 0 ? { locale } : typeof entries[0]?.locale === "string" ? { locale: entries[0].locale } : {},
+			difficulty,
+			...levelFacts !== void 0 ? { levelFacts: clone(levelFacts) } : {},
+			imagePolicy,
+			...images.length > 0 ? { images } : {},
+			...avoid !== void 0 && avoid.length > 0 ? { avoid: avoid.map((entry) => ({
+				texts: textsOf(entry).map((one) => one.text),
+				keys: (isRecord(entry) && entry.type === "item-group" ? listOf(entry.items) : [entry]).flatMap((item) => keysOf(item).map((slot) => slot.shown))
+			})) } : {},
+			...instructions !== void 0 ? { instructions } : {},
+			rules
+		},
+		shape: replyShape(varied, varied.length),
+		exemplars,
+		...avoid !== void 0 ? { avoid } : {},
+		...settings !== void 0 ? { settings } : {},
+		...input.lengthTolerance !== void 0 ? { lengthTolerance: { ...input.lengthTolerance } } : {},
+		...input.balanceKeyPositions !== void 0 ? { balanceKeyPositions: { seed: input.balanceKeyPositions.seed } } : {},
+		skipped
+	};
+}
+/** Fields every activity copies from its exemplar: what scores it, and what it tests. */
+const COPIED_COMMON = [
+	"scoringStrategy",
+	"shuffle",
+	"passThreshold",
+	"locale",
+	"ai",
+	"learningObjectives",
+	"slotKey"
+];
+const COPIED = {
+	"multiple-choice": ["mode"],
+	"fill-in-the-blanks": [],
+	"gap-select": ["presentation", "shuffleChoices"],
+	dictation: ["tolerance", "hints"],
+	"read-aloud": ["recording", "scoring"],
+	"written-response": [
+		"rubric",
+		"minWords",
+		"maxWords",
+		"languageTarget"
+	]
+};
+function pick(from, names) {
+	const out = {};
+	for (const name of names) if (from[name] !== void 0) out[name] = clone(from[name]);
+	return out;
+}
+/** The author's 1–5 difficulty, one step along with the variant's, inside the scale. */
+function steppedLevel(level, difficulty) {
+	if (typeof level !== "number") return {};
+	return { difficultyLevel: Math.min(5, Math.max(1, level + (difficulty === "easier" ? -1 : difficulty === "harder" ? 1 : 0))) };
+}
+const scriptFrom = (value) => listOf(value).flatMap((turn) => isRecord(turn) ? [{
+	speaker: stringOf(turn.speaker),
+	text: stringOf(turn.text)
+}] : []);
+/**
+* A variant's media in place of the exemplar's: a picture described anew, or
+* kept with `reuse`; a recording with no file yet — the host records it — its
+* playback policy, and the words the model wrote for it. An address, captions,
+* tracks and a poster belong to the old recording and are not copied.
+*/
+function variantMedia(exemplar, wrote, ownText, imagePolicy) {
+	const model = isRecord(wrote) ? wrote : {};
+	if (isImage(exemplar)) return imagePolicy === "reuse" ? pick(exemplar, [
+		"type",
+		"url",
+		"alt"
+	]) : {
+		type: "image",
+		url: null,
+		alt: stringOf(model.alt)
+	};
+	const media = {
+		type: exemplar.type,
+		url: null,
+		...pick(exemplar, ["playback"])
+	};
+	if (!ownText) {
+		if (hasScript(exemplar)) media.script = scriptFrom(model.script);
+		else if (typeof exemplar.transcript === "string") media.transcript = stringOf(model.transcript);
+	}
+	return media;
+}
+/** The feedback the model wrote, on the keys the exemplar's feedback has. */
+function feedbackFrom(exemplar, wrote) {
+	if (!isRecord(exemplar.feedback) || !isRecord(wrote.feedback)) return {};
+	const out = {};
+	for (const name of ["correct", "incorrect"]) {
+		const said = written(wrote.feedback[name]);
+		if (exemplar.feedback[name] !== void 0 && said !== void 0) out[name] = said;
+	}
+	return Object.keys(out).length > 0 ? { feedback: out } : {};
+}
+function difficultyFor(request, exemplarIndex, item) {
+	const targets = request.facts.exemplars.find((one) => one.exemplar === exemplarIndex)?.targets;
+	return (item !== void 0 ? targets?.itemDifficulty?.find((one) => one.item === item) : void 0)?.difficulty ?? targets?.difficulty ?? request.facts.difficulty;
+}
+function buildActivity(exemplar, wrote, type, build, difficulty, id) {
+	const { request, ids } = build;
+	const imagePolicy = request.facts.imagePolicy;
+	const alike = exemplar.type === type;
+	const content = { title: stringOf(wrote.title) };
+	if (typeof exemplar.instructions === "string") content.instructions = written(wrote.instructions) ?? exemplar.instructions;
+	switch (type) {
+		case "multiple-choice": {
+			const before = listOf(exemplar.options);
+			const withFeedback = before.some((option) => isRecord(option) && option.feedback !== void 0);
+			content.question = stringOf(wrote.question);
+			content.options = listOf(wrote.options).map((option, index) => {
+				const fields = isRecord(option) ? option : {};
+				const was = before[index];
+				const feedback = withFeedback ? written(fields.feedback) : void 0;
+				return {
+					id: ids(),
+					text: stringOf(fields.text),
+					isCorrect: fields.isCorrect === true,
+					...feedback !== void 0 ? { feedback } : {},
+					...isRecord(was) && isRecord(was.media) ? { media: variantMedia(was.media, fields.media, false, imagePolicy) } : {}
+				};
+			});
+			break;
+		}
+		case "fill-in-the-blanks": {
+			const before = alike ? inPassageOrder(exemplar, "blanks").map((one) => one.value) : [];
+			content.passage = stringOf(wrote.passage);
+			content.blanks = listOf(wrote.blanks).map((blank, index) => {
+				const fields = isRecord(blank) ? blank : {};
+				const was = isRecord(before[index]) ? before[index] : {};
+				const hint = was.hint !== void 0 ? written(fields.hint) : void 0;
+				const feedback = was.feedback !== void 0 ? written(fields.feedback) : void 0;
+				return {
+					id: String(index + 1),
+					acceptedAnswers: textList(fields.acceptedAnswers),
+					...hint !== void 0 ? { hint } : {},
+					...feedback !== void 0 ? { feedback } : {},
+					...pick(was, [
+						"match",
+						"caseSensitive",
+						"trimWhitespace"
+					])
+				};
+			});
+			break;
+		}
+		case "gap-select": {
+			const beforeGaps = alike ? inPassageOrder(exemplar, "gaps").map((one) => one.value) : [];
+			const beforeBanks = alike ? listOf(exemplar.banks) : [];
+			const banks = beforeBanks.length ? listOf(wrote.banks).map((bank) => ({
+				id: ids(),
+				choices: listOf(isRecord(bank) ? bank.choices : void 0).map((choice) => ({
+					id: ids(),
+					text: typeof choice === "string" ? choice : isRecord(choice) ? stringOf(choice.text) : ""
+				}))
+			})) : [];
+			content.passage = stringOf(wrote.passage);
+			content.gaps = listOf(wrote.gaps).map((gap, index) => {
+				const fields = isRecord(gap) ? gap : {};
+				const was = isRecord(beforeGaps[index]) ? beforeGaps[index] : {};
+				const feedback = was.feedback !== void 0 ? written(fields.feedback) : void 0;
+				const drawsOn = listOf(was.choices).length === 0 ? beforeBanks.findIndex((bank) => isRecord(bank) && bank.id === was.bankId) : -1;
+				const bank = drawsOn !== -1 ? banks[drawsOn] : void 0;
+				if (bank !== void 0) {
+					const answer = stringOf(fields.answer).trim().toLowerCase();
+					const right = bank.choices.find((choice) => choice.text.trim().toLowerCase() === answer);
+					return {
+						id: String(index + 1),
+						bankId: bank.id,
+						correctChoiceId: answer !== "" && right !== void 0 ? right.id : "",
+						...feedback !== void 0 ? { feedback } : {}
+					};
+				}
+				const marked = listOf(fields.choices);
+				const choices = marked.map((choice) => ({
+					id: ids(),
+					text: isRecord(choice) ? stringOf(choice.text) : ""
+				}));
+				const right = marked.flatMap((choice, at) => isRecord(choice) && choice.isCorrect === true ? [at] : []);
+				return {
+					id: String(index + 1),
+					choices,
+					correctChoiceId: right.length === 1 ? choices[right[0]]?.id : "",
+					...feedback !== void 0 ? { feedback } : {}
+				};
+			});
+			if (banks.length > 0) content.banks = banks;
+			break;
+		}
+		case "dictation":
+			content.transcript = stringOf(wrote.transcript);
+			if (Array.isArray(exemplar.acceptedTranscripts) && Array.isArray(wrote.acceptedTranscripts)) {
+				const accepted = textList(wrote.acceptedTranscripts).filter((one) => one.trim() !== "");
+				if (accepted.length > 0) content.acceptedTranscripts = accepted;
+			}
+			break;
+		case "read-aloud":
+			content.referenceText = stringOf(wrote.referenceText);
+			break;
+		default: content.prompt = stringOf(wrote.prompt);
+	}
+	const ownText = type === "dictation" || type === "read-aloud";
+	return {
+		...pick(exemplar, alike ? [...COPIED_COMMON, ...COPIED[type] ?? []] : COPIED_COMMON),
+		...steppedLevel(exemplar.difficultyLevel, difficulty),
+		...request.settings?.[type],
+		...content,
+		...isRecord(exemplar.media) ? { media: variantMedia(exemplar.media, wrote.media, ownText, imagePolicy) } : {},
+		...ownText && isRecord(exemplar.slowMedia) ? { slowMedia: {
+			type: "audio",
+			url: null
+		} } : {},
+		...feedbackFrom(exemplar, wrote),
+		schemaVersion: typeof exemplar.schemaVersion === "string" ? exemplar.schemaVersion : "1.0",
+		type,
+		id
+	};
+}
+function buildStimulus(exemplar, wrote, build) {
+	const model = isRecord(wrote) ? wrote : {};
+	const ownText = hasScript(exemplar) || typeof exemplar.transcript === "string";
+	const title = typeof exemplar.title === "string" ? written(model.title) : void 0;
+	return {
+		id: build.ids(),
+		kind: exemplar.kind,
+		...title !== void 0 ? { title } : {},
+		...typeof exemplar.body === "string" ? { body: stringOf(model.body) } : {},
+		...hasScript(exemplar) ? { script: scriptFrom(model.script) } : typeof exemplar.transcript === "string" ? { transcript: stringOf(model.transcript) } : {},
+		...isRecord(exemplar.media) ? { media: variantMedia(exemplar.media, model, ownText, build.request.facts.imagePolicy) } : {},
+		...pick(exemplar, ["locale"])
+	};
+}
+function buildEntry(exemplar, exemplarIndex, wrote, build, id) {
+	const difficulty = difficultyFor(build.request, exemplarIndex);
+	if (exemplar.type !== "item-group") return buildActivity(exemplar, wrote, stringOf(exemplar.type), build, difficulty, id);
+	const before = listOf(exemplar.items);
+	const title = typeof exemplar.title === "string" ? written(wrote.title) ?? exemplar.title : void 0;
+	return {
+		...pick(exemplar, ["slotKey", "shuffle"]),
+		...title !== void 0 ? { title } : {},
+		stimulus: buildStimulus(isRecord(exemplar.stimulus) ? exemplar.stimulus : {}, wrote.stimulus, build),
+		items: listOf(wrote.items).map((item, index) => {
+			const fields = isRecord(item) ? item : {};
+			const was = isRecord(before[index]) ? before[index] : {};
+			return buildActivity(was, fields, VARIANT_TYPES.includes(stringOf(fields.type)) ? stringOf(fields.type) : stringOf(was.type), build, difficultyFor(build.request, exemplarIndex, index), build.ids());
+		}),
+		schemaVersion: typeof exemplar.schemaVersion === "string" ? exemplar.schemaVersion : "1.0",
+		type: "item-group",
+		id
+	};
+}
+function variantFinding(code, path, message) {
+	return {
+		path: [...path],
+		message,
+		code,
+		severity: AI_VARIANT_CODE_SEVERITY[code]
+	};
+}
+/** The items of an entry with their paths: the entry itself, or a group's items. */
+const itemsWithPaths = (entry) => isRecord(entry) && entry.type === "item-group" ? listOf(entry.items).map((item, index) => ({
+	path: ["items", String(index)],
+	item
+})) : [{
+	path: [],
+	item: entry
+}];
+/** The other forms' entries in this exemplar's place: the same `slotKey`, or the same position in each form. */
+function avoidedFor(request, exemplarIndex) {
+	const avoid = request.avoid ?? [];
+	const exemplar = request.exemplars[exemplarIndex];
+	const slotKey = isRecord(exemplar) ? exemplar.slotKey : void 0;
+	const forms = avoid.length % request.exemplars.length === 0;
+	return avoid.flatMap((entry, index) => {
+		const theirs = isRecord(entry) ? entry.slotKey : void 0;
+		return (slotKey !== void 0 && theirs !== void 0 ? slotKey === theirs : slotKey === void 0 && theirs === void 0 && forms && index % request.exemplars.length === exemplarIndex) ? [{
+			entry,
+			label: `avoid[${index}]`
+		}] : [];
+	});
+}
+function nearCopies(entry, exemplar, request) {
+	const mine = new Map(textsOf(exemplar).map((one) => [one.path.join("."), one]));
+	const avoided = (request.avoid ?? []).flatMap((other, index) => textsOf(other).map((one) => ({
+		...one,
+		label: `avoid[${index}]`
+	})));
+	const findings = [];
+	for (const one of textsOf(entry)) {
+		let best;
+		const consider = (score, what) => {
+			if (score >= .5 && (best === void 0 || score > best.score)) best = {
+				score,
+				what
+			};
+		};
+		const theirs = mine.get(one.path.join("."));
+		if (theirs !== void 0) consider(textSimilarity(theirs.text, one.text), `the exemplar's ${theirs.path.join(".")}`);
+		for (const other of avoided) if (other.kind === one.kind) consider(textSimilarity(other.text, one.text), `${other.label} ${other.path.join(".") || "text"}`);
+		if (best !== void 0) findings.push(variantFinding("variant_near_copy", one.path, `This reads like ${best.what} (similarity ${shownScore(best.score)}). Write it in new words.`));
+	}
+	const exemplarItems = new Map(itemsWithPaths(exemplar).map((one) => [one.path.join("."), one.item]));
+	const avoidedOptions = (request.avoid ?? []).flatMap((other, index) => itemsWithPaths(other).map((one) => ({
+		set: optionSet(one.item),
+		label: `avoid[${index}]`
+	})));
+	for (const { path, item } of itemsWithPaths(entry)) {
+		const options = optionSet(item);
+		if (options === null) continue;
+		const sameAs = (other) => other !== null && other.join("\n") === options.join("\n");
+		const source = sameAs(optionSet(exemplarItems.get(path.join(".")))) ? "the exemplar's" : avoidedOptions.find((other) => sameAs(other.set))?.label;
+		if (source !== void 0) findings.push(variantFinding("variant_near_copy", [...path, "options"], `These are ${source === "the exemplar's" ? "the exemplar's options" : `${source}'s options`}, in another order. Write new options.`));
+	}
+	return findings;
+}
+function sameKeys(entry, exemplar, exemplarIndex, request) {
+	const against = [{
+		entry: exemplar,
+		label: "the exemplar"
+	}, ...avoidedFor(request, exemplarIndex)];
+	const findings = [];
+	for (const { path, item } of itemsWithPaths(entry)) {
+		const slots = keysOf(item);
+		const reported = /* @__PURE__ */ new Set();
+		for (const other of against) {
+			const theirSlots = keysOf(itemsWithPaths(other.entry).find((one) => one.path.join(".") === path.join("."))?.item);
+			for (const slot of slots) {
+				const match = theirSlots.find((one) => one.slot === slot.slot);
+				const shared = match !== void 0 ? sharedAnswers(slot, match) : [];
+				if (shared.length > 0 && !reported.has(slot.slot)) {
+					reported.add(slot.slot);
+					findings.push(variantFinding("variant_same_key", [...path, ...slot.path], `The right answer "${shared[0]}" is ${other.label === "the exemplar" ? "the exemplar's" : `${other.label}'s`} too: a learner who sat that form scores again by memory.`));
+				}
+			}
+		}
+	}
+	return findings;
+}
+/** Whether a recording the exemplar's item has words for came back with none. */
+function wordlessRecordings(exemplar, entry) {
+	const mismatch = (path, message) => ({
+		path,
+		message,
+		code: "variant_structure",
+		severity: "invalid"
+	});
+	const out = [];
+	const pairsOf = (a, b, at) => {
+		if (!isRecord(a) || !isRecord(b) || a.type === "dictation" || a.type === "read-aloud") return;
+		if (isRecording(a.media) && transcriptOf(a.media) !== null && transcriptOf(b.media) === null) out.push(mismatch([
+			...at,
+			"media",
+			hasScript(a.media) ? "script" : "transcript"
+		], "The recording has no words to record: write what it says."));
+	};
+	if (exemplar.type === "item-group") {
+		const before = isRecord(exemplar.stimulus) ? exemplar.stimulus : {};
+		const after = isRecord(entry.stimulus) ? entry.stimulus : {};
+		if (transcriptOf(before) !== null && transcriptOf(after) === null) out.push(mismatch(["stimulus", hasScript(before) || isRecord(before.media) && hasScript(before.media) ? "script" : "transcript"], "The recording has no words to record: write what it says."));
+		listOf(exemplar.items).forEach((item, index) => {
+			pairsOf(item, listOf(entry.items)[index], ["items", String(index)]);
+		});
+	} else pairsOf(exemplar, entry, []);
+	return out;
+}
+function pairsOf(exemplar, entry) {
+	const top = {
+		exemplarPath: [],
+		variantPath: [],
+		exemplarId: stringOf(exemplar.id),
+		variantId: stringOf(entry.id)
+	};
+	if (exemplar.type !== "item-group") return [top];
+	const theirs = listOf(entry.items);
+	return [top, ...listOf(exemplar.items).flatMap((item, index) => index < theirs.length ? [{
+		exemplarPath: ["items", String(index)],
+		variantPath: ["items", String(index)],
+		exemplarId: idOf(item) ?? "",
+		variantId: idOf(theirs[index]) ?? ""
+	}] : [])];
+}
+function evaluate(built, request) {
+	const exemplar = request.exemplars[built.exemplarIndex];
+	const type = stringOf(exemplar.type);
+	const { entry } = built;
+	const group = type === "item-group";
+	const validation = group ? validateItemGroupDraft(entry) : validateDraft(type, entry);
+	const mismatches = built.wroteType !== type ? [{
+		path: ["type"],
+		message: `This was written as ${built.wroteType || "no type"}; the exemplar is ${type}.`,
+		code: "variant_type",
+		severity: "invalid"
+	}] : [...structureMisses(exemplar, entry).map((miss) => ({
+		...miss,
+		code: "variant_structure",
+		severity: "invalid"
+	})), ...wordlessRecordings(exemplar, entry)];
+	const findings = [
+		...group ? critiqueItemGroupDraft(entry) : critiqueDraft(type, entry),
+		...lengthMisses(exemplar, entry, request.lengthTolerance).map((miss) => variantFinding("variant_length", miss.path, `${miss.words} words; the exemplar's has ${miss.exemplarWords}, so ${miss.bounds[0]} to ${miss.bounds[1]}.`)),
+		...nearCopies(entry, exemplar, request),
+		...sameKeys(entry, exemplar, built.exemplarIndex, request)
+	];
+	const status = validation.status === "invalid" || mismatches.length > 0 ? "invalid" : validation.status === "incomplete" ? "incomplete" : "complete";
+	return {
+		exemplarIndex: built.exemplarIndex,
+		type,
+		entry,
+		status,
+		validation,
+		mismatches,
+		findings,
+		pairs: pairsOf(exemplar, entry),
+		generated: built.generated
+	};
+}
+/**
+* Moves each single-answer, unshuffled multiple choice's right option to the
+* position used least so far across the variants, ties broken by an order
+* drawn from `seed`: as even as the counts allow, and the same every time.
+* An option moves with its id, text, feedback and media.
+*/
+function balanceKeys(built, seed) {
+	const counts = /* @__PURE__ */ new Map();
+	let slot = 0;
+	const visit = (item) => {
+		if (!isRecord(item) || item.type !== "multiple-choice" || item.mode !== "single" || item.shuffle === true) return item;
+		const options = listOf(item.options);
+		const keys = options.flatMap((option, index) => isRecord(option) && option.isCorrect === true ? [index] : []);
+		if (keys.length !== 1) return item;
+		const order = seededShuffle(options.map((_, index) => index), `${seed}:${slot}`, { version: 2 });
+		slot += 1;
+		let target = order[0];
+		for (const position of order) if ((counts.get(position) ?? 0) < (counts.get(target) ?? 0)) target = position;
+		counts.set(target, (counts.get(target) ?? 0) + 1);
+		const key = options[keys[0]];
+		const rest = options.filter((_, index) => index !== keys[0]);
+		return {
+			...item,
+			options: [
+				...rest.slice(0, target),
+				key,
+				...rest.slice(target)
+			]
+		};
+	};
+	return [...built].sort((a, b) => a.exemplarIndex - b.exemplarIndex).map((one) => ({
+		...one,
+		entry: one.entry.type === "item-group" ? {
+			...one.entry,
+			items: listOf(one.entry.items).map(visit)
+		} : visit(one.entry)
+	}));
+}
+/** Ids from the host, checked as `createDraft` checks them. */
+function idSource(newId, caller) {
+	const issued = /* @__PURE__ */ new Set();
+	return () => {
+		const id = newId();
+		if (typeof id !== "string" || id === "") throw new Error(`${caller}: newId() must return a non-empty string.`);
+		if (issued.has(id)) throw new Error(`${caller}: newId() returned "${id}" twice. Ids must differ — two options sharing an id cannot be scored apart.`);
+		issued.add(id);
+		return id;
+	};
+}
+function missingOf(exemplarIndex) {
+	return {
+		exemplarIndex,
+		code: "variant_missing",
+		message: `The reply has no variant of exemplar ${exemplarIndex}.`,
+		severity: "invalid"
+	};
+}
+function read(raw, request, ids, keep) {
+	if (!isRecord(raw) || !Array.isArray(raw.variants) || !raw.variants.every(isRecord)) return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const asked = request.repair ? request.repair.map((one) => one.exemplar) : request.facts.exemplars.map((one) => one.exemplar);
+	if (raw.variants.length > asked.length) return {
+		ok: false,
+		refusal: "too-long"
+	};
+	const seen = /* @__PURE__ */ new Set();
+	for (const variant of raw.variants) {
+		const index = variant.exemplar;
+		if (typeof index !== "number" || !asked.includes(index) || seen.has(index)) return {
+			ok: false,
+			refusal: "malformed"
+		};
+		seen.add(index);
+	}
+	const build = {
+		request,
+		ids
+	};
+	return {
+		ok: true,
+		built: raw.variants.map((variant) => {
+			const exemplarIndex = variant.exemplar;
+			const exemplar = request.exemplars[exemplarIndex];
+			return {
+				exemplarIndex,
+				wroteType: stringOf(variant.type),
+				entry: buildEntry(exemplar, exemplarIndex, variant, build, keep.get(exemplarIndex) ?? ids()),
+				generated: variant
+			};
+		}).sort((a, b) => a.exemplarIndex - b.exemplarIndex),
+		missing: asked.filter((index) => !seen.has(index)).sort((a, b) => a - b).map(missingOf),
+		raw
+	};
+}
+function setFindings(variants) {
+	const entries = variants.map((one) => one.entry);
+	return [...keyPositionFinding(entries, []), ...paperFindings(entries)];
+}
+/**
+* Reads a model's reply to {@link aiVariantsRequest} into variants an editor
+* can show for approval: each made from what the model wrote and what its
+* exemplar is — type, structure, scoring and settings copied from the
+* exemplar, whatever the reply says of them — with ids from `newId`, checked
+* by `validateDraft` (or `validateItemGroupDraft`), compared with its exemplar
+* (`mismatches`: `variant_type`, `variant_structure`), critiqued, and checked
+* for length, near copies and repeated keys against the exemplar and every
+* entry in `avoid` (`findings`: `variant_length`, `variant_near_copy`,
+* `variant_same_key`). `pairs` line each exemplar item up with its variant's.
+*
+* A recording comes back with no file — `url: null`, its playback policy, and
+* a new script or transcript — and a picture to describe with no file and a
+* new `alt`: `media_url_required` until the host attaches one.
+*
+* Variants are independent: one that is wrong comes back as such, beside the
+* others. An exemplar the reply wrote nothing for is listed in `missing`. The
+* whole reply is refused only when it is not `{ variants: [...] }` of objects
+* each naming an exemplar of the facts once (`malformed`), or holds more
+* variants than exemplars (`too-long`).
+*
+* With `balanceKeyPositions` the single-answer keys are spread across
+* positions, from its seed.
+*
+* @throws Error when `newId` returns an empty or repeated id.
+*/
+function checkAiVariants(raw, request, options) {
+	const result = read(raw, request, idSource(options.newId, "checkAiVariants"), /* @__PURE__ */ new Map());
+	if (!result.ok) return result;
+	const seed = request.balanceKeyPositions?.seed;
+	const variants = (seed !== void 0 ? balanceKeys(result.built, seed) : result.built).map((one) => evaluate(one, request));
+	const provenance = provenanceOf(result.raw.provenance);
+	const usage = usageOf(result.raw.usage);
+	return {
+		ok: true,
+		variants: {
+			variants,
+			missing: result.missing,
+			findings: setFindings(variants),
+			...provenance !== void 0 ? { provenance } : {},
+			...usage !== void 0 ? { usage } : {}
+		}
+	};
+}
+/** The fields a model writes, and inside media and material, the ones it writes there. */
+const WRITTEN_FIELDS = /* @__PURE__ */ new Set([
+	"type",
+	"title",
+	"instructions",
+	"question",
+	"options",
+	"passage",
+	"blanks",
+	"gaps",
+	"banks",
+	"transcript",
+	"acceptedTranscripts",
+	"referenceText",
+	"prompt",
+	"feedback",
+	"media",
+	"stimulus",
+	"items"
+]);
+const WRITTEN_IN_MEDIA = /* @__PURE__ */ new Set([
+	"alt",
+	"transcript",
+	"script"
+]);
+const WRITTEN_IN_STIMULUS = /* @__PURE__ */ new Set([
+	"title",
+	"body",
+	"transcript",
+	"script",
+	"media",
+	"alt"
+]);
+function writable(path) {
+	const rest = path[0] === "items" && path.length > 2 ? path.slice(2) : path;
+	const [first, second, third] = rest;
+	if (first === void 0 || !WRITTEN_FIELDS.has(first)) return false;
+	if (first === "media") return second !== void 0 && WRITTEN_IN_MEDIA.has(second);
+	if (first === "stimulus") {
+		if (second === "media") return third !== void 0 && WRITTEN_IN_MEDIA.has(third);
+		return second !== void 0 && WRITTEN_IN_STIMULUS.has(second);
+	}
+	if (first === "options" && rest[2] === "media") return rest[3] !== void 0 && WRITTEN_IN_MEDIA.has(rest[3]);
+	return true;
+}
+/** Where the model wrote what a problem names. */
+function pathForModel(variant, problem) {
+	const { path, code } = problem;
+	const prefix = path[0] === "items" && path.length > 2 ? path.slice(0, 2) : [];
+	const rest = path.slice(prefix.length);
+	if (code === "ra_text_long_for_time") return [...prefix, "referenceText"];
+	if (rest[0] === "gaps" && rest.length === 3 && rest[2] === "correctChoiceId") {
+		const item = prefix.length > 0 ? listOf(variant.entry.items)[Number(prefix[1])] : variant.entry;
+		const gap = isRecord(item) ? listOf(item.gaps)[Number(rest[1])] : void 0;
+		return [
+			...prefix,
+			"gaps",
+			rest[1],
+			isRecord(gap) && gap.bankId !== void 0 ? "answer" : "choices"
+		];
+	}
+	if (rest[0] === "stimulus" && rest[1] === "media" && (rest[2] === "script" || rest[2] === "transcript")) return ["stimulus", rest[2]];
+	return [...path];
+}
+function problemsOf(variant) {
+	return [
+		...variant.mismatches.map((found) => ({
+			path: found.path,
+			code: found.code,
+			message: found.message,
+			severity: "invalid"
+		})),
+		...variant.validation.issues.filter((found) => found.code !== "media_url_required").map((found) => ({
+			path: found.path,
+			code: found.code,
+			message: found.message,
+			severity: found.severity
+		})),
+		...variant.findings.filter((found) => found.severity === "warning").map((found) => ({
+			path: found.path,
+			code: found.code,
+			message: found.message,
+			severity: "warning"
+		}))
+	].map((problem) => ({
+		...problem,
+		path: pathForModel(variant, problem)
+	})).filter((problem) => writable(problem.path));
+}
+/**
+* A second request, for the variants with something the model can fix —
+* a wrong type or structure, an issue other than a missing file, or a warning
+* at a field the model writes — and the exemplars the reply wrote nothing for
+* (`variant_missing`). Each comes with its problems at the paths the model
+* wrote; the exemplar and its targets stay in the facts. `null` when there is
+* nothing to repair.
+*
+* The reply holds one variant for each, naming its exemplar;
+* {@link checkAiVariants} reads it.
+*/
+function aiVariantsRepairRequest(request, variants) {
+	const list = Array.isArray(variants) ? variants : variants.variants;
+	const missing = Array.isArray(variants) ? [] : variants.missing;
+	const repair = [...list.flatMap((one) => {
+		const problems = problemsOf(one);
+		return problems.length === 0 ? [] : [{
+			exemplar: one.exemplarIndex,
+			variant: one.generated,
+			problems
+		}];
+	}), ...missing.map((one) => ({
+		exemplar: one.exemplarIndex,
+		problems: [{
+			path: [],
+			code: one.code,
+			message: one.message,
+			severity: "invalid"
+		}]
+	}))].sort((a, b) => a.exemplar - b.exemplar);
+	if (repair.length === 0) return null;
+	const { repair: _previous, ...first } = request;
+	return {
+		...first,
+		shape: replyShape(repair.map((one) => request.exemplars[one.exemplar]), repair.length),
+		repair
+	};
+}
+const RANK = {
+	complete: 2,
+	incomplete: 1,
+	invalid: 0
+};
+const invalidCount = (one) => one.mismatches.length + one.validation.issues.filter((found) => found.severity === "invalid").length;
+const warningCount = (one) => one.findings.filter((found) => found.severity === "warning").length;
+/** Whether a repaired variant is at least as good as the one it would replace. */
+function noWorse(repaired, before) {
+	const now = RANK[repaired.status];
+	const was = RANK[before.status];
+	if (now !== was) return now > was;
+	if (invalidCount(repaired) !== invalidCount(before)) return invalidCount(repaired) < invalidCount(before);
+	return warningCount(repaired) <= warningCount(before);
+}
+/**
+* Writes variants of existing items, with a bounded repair loop: asks the port
+* with `request`, reads the reply as {@link checkAiVariants} does, then — up
+* to `repairs` times — sends back what the model can fix and what it did not
+* write ({@link aiVariantsRepairRequest}), keeping each variant's best pass:
+* by status, then fewer invalid problems, then fewer warnings. A repaired
+* variant keeps its id. With `balanceKeyPositions`, the keys are spread once,
+* over the variants as they end.
+*
+* Never throws for a model's failure: a port that throws or a reply the SDK
+* refuses ends the loop, and is recorded in `calls` beside the provenance and
+* usage of every call. A first call that fails leaves no variants. A request
+* with no exemplar to vary makes no call.
+*
+* ```ts
+* const run = await generateVariants({
+*   request: aiVariantsRequest({ exemplars: section, level: 'CEFR B1', avoid: otherForms }),
+*   port: (request) => callMyModel(VARIANTS_PROMPT, request),
+*   newId: () => crypto.randomUUID(),
+* });
+* // run.variants: store each as proposed, for a person to approve.
+* ```
+*
+* @throws RangeError when `repairs` is not a whole number from 0 to
+*   {@link AI_VARIANTS_MAX_REPAIRS} (default 1), and Error when `newId` returns
+*   an empty or repeated id.
+*/
+async function generateVariants(input) {
+	const { request, port, newId } = input;
+	const repairs = input.repairs ?? 1;
+	if (!Number.isInteger(repairs) || repairs < 0 || repairs > 3) throw new RangeError(`generateVariants: repairs must be a whole number from 0 to 3, not ${String(repairs)}.`);
+	const calls = [];
+	const skipped = request.skipped;
+	if (request.facts.exemplars.length === 0) return {
+		variants: [],
+		missing: [],
+		findings: [],
+		skipped,
+		calls
+	};
+	const ids = idSource(newId, "generateVariants");
+	const ask = async (asked, keep) => {
+		let raw;
+		try {
+			raw = await port(asked);
+		} catch (error) {
+			calls.push({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+		const result = read(raw, asked, ids, keep);
+		if (!result.ok) {
+			calls.push({
+				ok: false,
+				refusal: result.refusal
+			});
+			return;
+		}
+		const provenance = provenanceOf(result.raw.provenance);
+		const usage = usageOf(result.raw.usage);
+		calls.push({
+			ok: true,
+			...provenance !== void 0 ? { provenance } : {},
+			...usage !== void 0 ? { usage } : {}
+		});
+		return {
+			built: result.built,
+			variants: result.built.map((one) => evaluate(one, request)),
+			missing: result.missing
+		};
+	};
+	const first = await ask(request, /* @__PURE__ */ new Map());
+	if (first === void 0) return {
+		variants: [],
+		missing: [],
+		findings: [],
+		skipped,
+		calls
+	};
+	const best = /* @__PURE__ */ new Map();
+	first.variants.forEach((variant, index) => {
+		best.set(variant.exemplarIndex, {
+			built: first.built[index],
+			variant
+		});
+	});
+	const wanted = request.facts.exemplars.map((one) => one.exemplar);
+	const missingNow = () => wanted.filter((index) => !best.has(index)).map(missingOf);
+	for (let pass = 0; pass < repairs; pass += 1) {
+		const repairRequest = aiVariantsRepairRequest(request, {
+			variants: [...best.values()].map((one) => one.variant),
+			missing: missingNow(),
+			findings: []
+		});
+		if (repairRequest === null) break;
+		const repaired = await ask(repairRequest, new Map((repairRequest.repair ?? []).flatMap((one) => {
+			const before = best.get(one.exemplar);
+			return before !== void 0 ? [[one.exemplar, stringOf(before.variant.entry.id)]] : [];
+		})));
+		if (repaired === void 0) break;
+		repaired.variants.forEach((variant, index) => {
+			const before = best.get(variant.exemplarIndex);
+			if (before === void 0 || noWorse(variant, before.variant)) best.set(variant.exemplarIndex, {
+				built: repaired.built[index],
+				variant
+			});
+		});
+	}
+	const ended = [...best.values()].sort((a, b) => a.variant.exemplarIndex - b.variant.exemplarIndex);
+	const seed = request.balanceKeyPositions?.seed;
+	const variants = seed !== void 0 ? balanceKeys(ended.map((one) => one.built), seed).map((one) => evaluate(one, request)) : ended.map((one) => one.variant);
+	return {
+		variants,
+		missing: missingNow(),
+		findings: setFindings(variants),
+		skipped,
+		calls
+	};
+}
 // src/ai-writing.ts
 /**
 * The request for feedback on a draft, or `null` when there is none to give:
@@ -3085,7 +5463,7 @@ function checkCriteria(raw, rubric) {
 	const seen = /* @__PURE__ */ new Set();
 	const criteria = [];
 	for (const entry of raw) {
-		if (!isRecord(entry) || typeof entry.name !== "string") return {
+		if (!isRecord$1(entry) || typeof entry.name !== "string") return {
 			ok: false,
 			refusal: "malformed"
 		};
@@ -3174,6 +5552,6 @@ function checkAiWritingFeedback(raw, request) {
 		}
 	};
 }
-export { AI_COACHING_MAX_TIP_LENGTH as A, aiHintRequest as B, createItemGroupDraft as C, listMediaRefs as D, validateItemGroupDraft as E, AI_HINT_TYPES as F, hintRevealsAnswer as G, buildAiFacts as H, AI_TEXT_MAX_LENGTH as I, readAiTextResult as K, aiAllowedByContent as L, aiCoachingRequest as M, checkAiCoaching as N, mapMediaRefs as O, AI_EXPLANATION_TYPES as P, aiExplanationRequest as R, createInteractiveVideoDraft as S, critiqueItemGroupDraft as T, checkAiExplanation as U, aiSupports as V, checkAiHint as W, aiCritiqueRequest as _, checkAiGrading as a, critiqueDraft as b, AI_DRAFTS_MAX_COUNT as c, aiDraftsRequest as d, checkAiDrafts as f, AI_CRITIQUE_MAX_FINDINGS as g, AI_CRITIQUE_MAX_FIELD_LENGTH as h, aiGradingRequest as i, AI_COACHING_MAX_WORDS as j, transcriptOf as k, AI_DRAFTS_MAX_REPAIRS as l, interactiveVideoFromDrafts as m, checkAiWritingFeedback as n, AI_WRITING_MAX_CORRECTIONS as o, generateDrafts as p, AI_MATERIAL_MAX_LENGTH as q, AI_GRADING_PROBABILITY_TOLERANCE as r, AI_WRITING_MAX_FIELD_LENGTH as s, aiWritingFeedbackRequest as t, aiDraftsRepairRequest as u, checkAiCritique as v, critiqueDrafts as w, validateDraft as x, createDraft as y, aiGradeOf as z };
+export { AI_EXPLANATION_TYPES as $, validateDraft as A, optionSet as B, interactiveVideoFromDrafts as C, checkAiCritique as D, aiCritiqueRequest as E, validateItemGroupDraft as F, textsOf as G, shownScore as H, AI_VARIANT_LENGTH_BANDS as I, transcriptOf as J, listMediaRefs as K, AI_VARIANT_NEAR_COPY_THRESHOLD as L, createItemGroupDraft as M, critiqueDrafts as N, createDraft as O, critiqueItemGroupDraft as P, checkAiCoaching as Q, keysOf as R, generateDrafts as S, AI_CRITIQUE_MAX_FINDINGS as T, structureMisses as U, sharedAnswers as V, textSimilarity as W, AI_COACHING_MAX_WORDS as X, AI_COACHING_MAX_TIP_LENGTH as Y, aiCoachingRequest as Z, AI_DRAFTS_MAX_COUNT as _, AI_VARIANTS_MAX_REPAIRS as a, aiHintRequest as at, aiDraftsRequest as b, aiVariantsRequest as c, checkAiExplanation as ct, AI_GRADING_PROBABILITY_TOLERANCE as d, readAiTextResult as dt, AI_HINT_TYPES as et, aiGradingRequest as f, AI_MATERIAL_MAX_LENGTH as ft, AI_WRITING_MAX_FIELD_LENGTH as g, AI_WRITING_MAX_CORRECTIONS as h, AI_VARIANTS_MAX_MATERIAL_LENGTH as i, aiGradeOf as it, createInteractiveVideoDraft as j, critiqueDraft as k, checkAiVariants as l, checkAiHint as lt, checkAiGrading as m, checkAiWritingFeedback as n, aiAllowedByContent as nt, AI_VARIANT_CODE_SEVERITY as o, aiSupports as ot, aiSpeakingGradingRequest as p, mapMediaRefs as q, AI_VARIANTS_MAX_EXEMPLARS as r, aiExplanationRequest as rt, aiVariantsRepairRequest as s, buildAiFacts as st, aiWritingFeedbackRequest as t, AI_TEXT_MAX_LENGTH as tt, generateVariants as u, hintRevealsAnswer as ut, AI_DRAFTS_MAX_REPAIRS as v, AI_CRITIQUE_MAX_FIELD_LENGTH as w, checkAiDrafts as x, aiDraftsRepairRequest as y, lengthMisses as z };
 
-//# sourceMappingURL=ai-writing-B7oMCt66.js.map
+//# sourceMappingURL=ai-writing-DQjI9EFN.js.map