@intellectif/lk-core 1.4.0 → 1.6.0

package/dist/{ai-writing-G6tnCGzw.cjs → ai-writing-C4YRVrFi.cjs}

@@ -1,6 +1,6 @@
-const require_registry = require("./registry-DVi0LR_i.cjs");
-const require_scoring = require("./scoring-B2_HEhMT.cjs");
-const require_item_group = require("./item-group-DroFXgLb.cjs");
+const require_registry = require("./registry-Ih5n4PVZ.cjs");
+const require_scoring = require("./scoring-CaPS6q8b.cjs");
+const require_item_group = require("./item-group-CQRbb8Rx.cjs");
 //#region 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$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$5 = (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$4(group)) return null;
+	if (!isRecord$5(group)) return null;
 	const stimulus = group.stimulus;
-	if (!isRecord$4(stimulus)) return null;
+	if (!isRecord$5(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$4(rawMedia) ? rawMedia.type : void 0;
-	const alt = isRecord$4(rawMedia) ? filled(rawMedia.alt) : void 0;
+	const mediaType = isRecord$5(rawMedia) ? rawMedia.type : void 0;
+	const alt = isRecord$5(rawMedia) ? filled(rawMedia.alt) : void 0;
 	const media = typeof mediaType === "string" && Object.hasOwn(MEDIA_TYPES, mediaType) ? {
 		type: mediaType,
 		...alt !== void 0 ? { alt } : {}
@@ -742,7 +742,7 @@ function aiCoachingRequest(input) {
 		...learnerLocale !== void 0 ? { learnerLocale } : {}
 	};
 }
-const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$4 = (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();
 /**
@@ -791,7 +791,7 @@ function checkAiCoaching(raw, request) {
 		});
 		const seen = /* @__PURE__ */ new Set();
 		for (const entry of entries) {
-			if (!isRecord$3(entry) || typeof entry.itemId !== "string" || typeof entry.tip !== "string") return {
+			if (!isRecord$4(entry) || typeof entry.itemId !== "string" || typeof entry.tip !== "string") return {
 				ok: false,
 				refusal: "malformed"
 			};
@@ -839,7 +839,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$3(raw) || typeof raw.expected !== "string" || raw.heard !== void 0 && raw.heard !== null && typeof raw.heard !== "string") return {
+	if (!isRecord$4(raw) || typeof raw.expected !== "string" || raw.heard !== void 0 && raw.heard !== null && typeof raw.heard !== "string") return {
 		ok: false,
 		refusal: "malformed"
 	};
@@ -866,6 +866,240 @@ function checkSound(raw, fact) {
 	};
 }
 //#endregion
+//#region src/media-refs.ts
+const MAIN_KINDS = [
+	"audio",
+	"video",
+	"image",
+	"embed"
+];
+function isRecord$3(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;
+		at = at[key];
+	}
+	return at;
+}
+/** Where `item` keeps its files: what its type declares, or its `media` alone. */
+function slotsOf(item) {
+	const declared = typeof item.type === "string" ? require_registry.getActivityTypeDescriptor(item.type)?.mediaSlots : void 0;
+	if (declared === void 0) return [{ path: ["media"] }];
+	const slots = declared(item);
+	return Array.isArray(slots) ? slots : [];
+}
+function holderRefs(holder, path, kindOfSlot, owner) {
+	if (!isRecord$3(holder)) return [];
+	const main = typeof holder.type === "string" && MAIN_KINDS.includes(holder.type) ? holder.type : kindOfSlot;
+	const refs = [];
+	const add = (field, kind, url) => {
+		refs.push({
+			path: [...path, ...field],
+			kind,
+			url,
+			holder,
+			...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({
+			path: [
+				...path,
+				"tracks",
+				index,
+				"src"
+			],
+			kind: "track",
+			url: track.src,
+			holder: track,
+			...owner,
+			...typeof track.srclang === "string" ? { srclang: track.srclang } : {}
+		});
+	});
+	if (typeof holder.poster === "string") add(["poster"], "poster", holder.poster);
+	return refs;
+}
+function activityRefs(item, base) {
+	if (!isRecord$3(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));
+}
+/**
+* Every media address in one piece of content: a loose activity or an item
+* group (its stimulus first, then each item in authored order), as a
+* `SequenceEntry` holds them. Drafts are read too.
+*
+* For each activity the walker reads the places its type keeps files: an
+* item's `media`, each multiple-choice option's `media`, and dictation's and
+* read-aloud's `slowMedia`. In each it lists the main file, `captionsUrl`,
+* every track's `src` and `poster`. A type you register declares its own with
+* `mediaSlots`; without that, its `media` is read.
+*
+* A main file with no address yet is listed with `url: null`, so a recording
+* still to be made has a place in the list. Not read: addresses inside an
+* `…Html` sidecar (the SDK does not parse HTML) and a learner's recordings,
+* which are responses rather than content.
+*
+* ```ts
+* const files = listMediaRefs(entry).filter((ref) => ref.url !== null);
+* ```
+*/
+function listMediaRefs(entry) {
+	if (!isRecord$3(entry)) return [];
+	if (entry.type !== "item-group") return activityRefs(entry, []);
+	const refs = [];
+	const stimulus = entry.stimulus;
+	if (isRecord$3(stimulus)) {
+		const owner = typeof stimulus.id === "string" ? { stimulusId: stimulus.id } : {};
+		refs.push(...holderRefs(stimulus.media, ["stimulus", "media"], void 0, owner));
+	}
+	if (Array.isArray(entry.items)) entry.items.forEach((item, index) => {
+		refs.push(...activityRefs(item, ["items", index]));
+	});
+	return refs;
+}
+/** A deep copy of a JSON value. Content is plain data; a cycle cannot be copied. */
+function copyOf(value, seen) {
+	if (typeof value !== "object" || value === null) return value;
+	if (seen.has(value)) throw new TypeError("mapMediaRefs: the content contains a circular reference.");
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) return value.map((element) => copyOf(element, seen));
+		const copy = {};
+		for (const [key, field] of Object.entries(value)) copy[key] = copyOf(field, seen);
+		return copy;
+	} finally {
+		seen.delete(value);
+	}
+}
+/**
+* A copy of `entry` with each address {@link listMediaRefs} finds replaced
+* by what `fn` returns for it: files moved into a new folder structure, or an
+* export's file names pointed at where an import stored them. Nothing else
+* changes, and `entry` is never modified: with `(ref) => ref.url`, the copy is
+* deep-equal to it, with the same `canonicalJson`.
+*
+* For a main file with no address yet (`url: null`), a string attaches one
+* and `null` leaves it empty. For an address that is there, `fn` must return
+* a string: removing a file is not mapping.
+*
+* The copy validates as the original did when every address `fn` returns is
+* one the media rule accepts: `https:`, `http:`, `data:`, `blob:`, or
+* root-relative (`/…`). A bundle-relative `media/part1.mp3` is refused.
+*
+* @throws TypeError when `fn` returns something other than a string or
+*   `null`, or `null` for an address that is there, or when `entry` is circular.
+*/
+function mapMediaRefs(entry, fn) {
+	const refs = listMediaRefs(entry);
+	const copy = copyOf(entry, /* @__PURE__ */ new Set());
+	for (const ref of refs) {
+		const next = fn(ref);
+		if (next === null) {
+			if (ref.url !== null) throw new TypeError(`mapMediaRefs: ${ref.path.join(".")} has a file; returning null would remove it, which is not mapping.`);
+			continue;
+		}
+		if (typeof next !== "string") throw new TypeError(`mapMediaRefs: the function must return a string or null for ${ref.path.join(".")}, not ${typeof next}.`);
+		if (next === ref.url) continue;
+		const holder = valueAt(copy, ref.path.slice(0, -1));
+		holder[ref.path[ref.path.length - 1]] = next;
+	}
+	return copy;
+}
+/** 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()}`] : []) : [];
+	return turns.length > 0 ? turns.join("\n") : null;
+}
+/**
+* The author-side text of a recording: its `transcript`, or else its
+* `script` as one "Speaker: text" line per turn. `null` when it has neither.
+*
+* `holder` is a media object, a stimulus, or an activity. A stimulus or an
+* activity is read for its own text first and then for its `media`'s; a
+* stimulus keeps both at its own level. Author-only: pass it to the author's
+* requests (`aiDraftsRequest`'s `source`, a critique), never to a learner's.
+*
+* ```ts
+* const text = transcriptOf(item.media);
+* if (text !== null) aiDraftsRequest({ types: ['multiple-choice'], source: { kind: 'transcript', text } });
+* ```
+*/
+function transcriptOf(holder) {
+	if (!isRecord$3(holder)) return null;
+	return ownText(holder) ?? (isRecord$3(holder.media) ? ownText(holder.media) : null);
+}
+//#endregion
+//#region src/authoring/recordings.ts
+const written$1 = (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) => require_registry.isRecord(turn) && typeof turn.speaker === "string" && written$1(turn.text) ? [{
+		speaker: turn.speaker,
+		text: turn.text
+	}] : []) : [];
+}
+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 unlabelled = labels.length === 0 ? transcript : transcript.replace(new RegExp(`(^|\\s)(?:${labels.map(escaped).join("|")})\\s*:`, "giu"), "$1");
+	return require_registry.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));
+	return turns.length > 0 ? require_registry.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 (!require_registry.isRecord(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(require_registry.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 fromTranscript = transcriptWords(holder.transcript, turns.map((turn) => turn.speaker));
+		if (!sameWords(fromTranscript, require_registry.fold(turns.map((turn) => turn.text).join(" ")))) findings.push(require_registry.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."));
+	}
+	return findings;
+}
+/** The field a type's own recording reads out, for the types that have one. */
+const SPOKEN_FIELD = {
+	dictation: "transcript",
+	"read-aloud": "referenceText"
+};
+/**
+* An item's recording rules, at every place its type keeps media. A
+* dictation's and a read-aloud's own text is what their recording says, so a
+* recording that says other words is reported too.
+*/
+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 || !require_registry.isRecord(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, require_registry.fold(text)))) findings.push(require_registry.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.`));
+	return findings;
+}
+/** A group's material: its own transcript against its script, and its media's rules. */
+function stimulusFindings(stimulus) {
+	if (!require_registry.isRecord(stimulus)) return [];
+	return [...holderFindings({
+		transcript: stimulus.transcript,
+		script: stimulus.script
+	}, ["stimulus"]), ...holderFindings(stimulus.media, ["stimulus", "media"])];
+}
+//#endregion
 //#region src/authoring/item-group.ts
 /**
 * A new, empty reading or listening testlet for an editor to start from.
@@ -963,7 +1197,11 @@ function createInteractiveVideoDraft(context) {
 function critiqueItemGroupDraft(draft) {
 	if (!require_registry.isRecord(draft)) return [];
 	const items = Array.isArray(draft.items) ? draft.items : [];
-	return require_registry.withValidationScope(() => [...items.flatMap((item, index) => repathed(critiqueItem(item), ["items", index])), ...require_registry.keyPositionFinding(items, ["items"])]);
+	return require_registry.withValidationScope(() => [
+		...stimulusFindings(draft.stimulus),
+		...items.flatMap((item, index) => repathed(critiqueItem(item), ["items", index])),
+		...require_registry.keyPositionFinding(items, ["items"])
+	]);
 }
 /**
 * The item critic over a question set, as `<ActivitySequence>` takes one: each
@@ -1410,9 +1648,9 @@ function normalise(found) {
 function critiqueDraft(type, draft) {
 	const descriptor = require_registry.getActivityTypeDescriptor(type);
 	if (descriptor === void 0) throw new require_registry.UnknownActivityTypeError(String(type));
+	if (!require_registry.isRecord(draft)) return [];
 	const critique = descriptor.authoring?.critique;
-	if (!require_registry.isRecord(draft) || critique === void 0) return [];
-	return require_registry.withValidationScope(() => critique(draft)).map(require_registry.normaliseFinding);
+	return require_registry.withValidationScope(() => [...critique === void 0 ? [] : critique(draft), ...recordingFindings(draft)]).map(require_registry.normaliseFinding);
 }
 //#endregion
 //#region src/ai-critique.ts
@@ -1448,6 +1686,10 @@ const NOT_WORDS = /* @__PURE__ */ new Set([
 	"bankId",
 	"url",
 	"captionsUrl",
+	"src",
+	"srclang",
+	"poster",
+	"speaker",
 	"match",
 	"playback",
 	"recording",
@@ -2289,65 +2531,19 @@ function interactiveVideoFromDrafts(input) {
 	};
 }
 //#endregion
-//#region src/ai-writing.ts
+//#region src/ai-written.ts
+/**
+* What the AI features about a written response share: reading a model's text
+* fields, and finding each correction's quote in the learner's text.
+*
+* Internal. `ai-writing.ts` (feedback on a draft) and `ai-grading.ts` (a
+* grade) are their public faces, and hold every correction to the same
+* anchoring.
+*/
 /** The most corrections one piece of writing feedback may carry. More is refused, not cut. */
 const AI_WRITING_MAX_CORRECTIONS = 20;
 /** The longest quote, correction, explanation or criterion comment, in code points. */
 const AI_WRITING_MAX_FIELD_LENGTH = 500;
-/** The longest `category` or `band`: a tag, not a sentence. */
-const MAX_TAG_LENGTH = 40;
-/**
-* The request for feedback on a draft, or `null` when there is none to give:
-* not a written response, an author who switched explanations off (writing
-* feedback reads `ai.explanations`), a redacted item — feedback is for
-* practice, where the item is whole — or a draft with nothing in it.
-*
-* The facts are the task as the learner saw it, the draft verbatim with its
-* word count recomputed as the grader will count it, and the rubric the answer
-* will be graded on. `previousFeedback` is the text of the feedback already
-* shown on earlier drafts, so a model can speak to what changed. `group` is the
-* item group the task sits in: its material, the text a summary is of, goes
-* with the request as `material`.
-*/
-function aiWritingFeedbackRequest(input) {
-	const { data, response, learnerLocale } = input;
-	if (!aiSupports(data.type, "writing-feedback") || !aiAllowedByContent(data, "writing-feedback") || data.redacted === true) return null;
-	const text = response?.type === "written-response" ? response.text : "";
-	if (typeof text !== "string" || text.trim() === "") return null;
-	const item = data;
-	const wordCount = require_registry.countWords(text);
-	const minWords = typeof item.minWords === "number" ? item.minWords : 0;
-	const maxWords = typeof item.maxWords === "number" ? item.maxWords : Number.POSITIVE_INFINITY;
-	const criteria = Array.isArray(item.rubric?.criteria) ? item.rubric.criteria : null;
-	const rubric = criteria === null || criteria.length === 0 ? null : criteria.map((criterion) => ({
-		name: criterion.name,
-		...typeof criterion.description === "string" ? { description: criterion.description } : {},
-		weight: criterion.weight
-	}));
-	const previousFeedback = [...input.previousFeedback ?? []];
-	const material = materialFacts(input.group);
-	return {
-		feature: "writing-feedback",
-		facts: {
-			activityType: "written-response",
-			activityId: data.id,
-			title: data.title,
-			...typeof data.locale === "string" ? { locale: data.locale } : {},
-			prompt: typeof item.prompt === "string" ? item.prompt : "",
-			text,
-			wordCount,
-			minWords,
-			maxWords,
-			withinWordBounds: wordCount >= minWords && wordCount <= maxWords,
-			rubric,
-			...typeof item.languageTarget === "string" ? { languageTarget: item.languageTarget } : {}
-		},
-		draftNumber: previousFeedback.length + 1,
-		previousFeedback,
-		...material !== null ? { material } : {},
-		...learnerLocale !== void 0 ? { learnerLocale } : {}
-	};
-}
 /**
 * Where `quote` sits in the draft: at `claimed`, when the model named a range —
 * which must then hold the quote — or else at its first occurrence not already
@@ -2446,7 +2642,7 @@ function checkCorrections(raw, text) {
 			refusal: "malformed"
 		};
 		const explanation = textField(entry.explanation, 500);
-		const category = textField(entry.category, MAX_TAG_LENGTH);
+		const category = textField(entry.category, 40);
 		if (!explanation.ok) return explanation;
 		if (!category.ok) return category;
 		let claimed;
@@ -2478,6 +2674,385 @@ function checkCorrections(raw, text) {
 		corrections
 	};
 }
+//#endregion
+//#region src/ai-grading.ts
+/**
+* How far a model's level probabilities may sum from 1 and still be a
+* distribution: rounding in a model's output, not a different judgement.
+*/
+const AI_GRADING_PROBABILITY_TOLERANCE = require_registry.LEVEL_PROBABILITY_TOLERANCE;
+/**
+* The request for a model's grade of a submitted written response, or why there
+* is none to make.
+*
+* Grading happens on the server, from the whole item: the rubric is what a
+* model is held to, so an item without one — or one whose criteria are not each
+* a name and a weight — gives no request, nor does a `redact()` projection or
+* an empty response. A criterion's `levels`, when there are any, must be ones
+* the grading functions can read; levels they cannot read give no request
+* rather than a grade on a scale the author did not mean. `group` is the item
+* group the task sits in: its material goes with the request as `material`, as
+* on feedback on writing.
+*
+* The author's AI switch (`ai.explanations`) is not read: grading is the
+* deployment's decision, made on the server, not help a learner asks for.
+*/
+function aiGradingRequest(input) {
+	const { data, response, learnerLocale } = input;
+	if (data.type !== "written-response") return {
+		ok: false,
+		problem: "not-written-response"
+	};
+	if (data.redacted === true) return {
+		ok: false,
+		problem: "redacted"
+	};
+	const item = data;
+	const rubric = rubricFacts(item.rubric);
+	if (!rubric.ok) return rubric;
+	const text = response?.type === "written-response" ? response.text : void 0;
+	if (typeof text !== "string" || text.trim() === "") return {
+		ok: false,
+		problem: "empty-response"
+	};
+	const wordCount = require_registry.countWords(text);
+	const minWords = typeof item.minWords === "number" ? item.minWords : 0;
+	const maxWords = typeof item.maxWords === "number" ? item.maxWords : Number.POSITIVE_INFINITY;
+	const material = materialFacts(input.group);
+	return {
+		ok: true,
+		request: {
+			feature: "grading",
+			facts: {
+				activityType: "written-response",
+				activityId: data.id,
+				title: data.title,
+				...typeof data.locale === "string" ? { locale: data.locale } : {},
+				prompt: typeof item.prompt === "string" ? item.prompt : "",
+				text,
+				wordCount,
+				minWords,
+				maxWords,
+				withinWordBounds: wordCount >= minWords && wordCount <= maxWords,
+				rubric: rubric.criteria,
+				...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;
+	if (!Array.isArray(listed) || listed.length === 0) return {
+		ok: false,
+		problem: "no-rubric"
+	};
+	const criteria = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [index, criterion] of listed.entries()) {
+		if (!isRecord(criterion)) return {
+			ok: false,
+			problem: "no-rubric",
+			path: [
+				"rubric",
+				"criteria",
+				index
+			]
+		};
+		const { name, description, weight } = criterion;
+		if (typeof name !== "string" || name.trim() === "" || typeof weight !== "number") return {
+			ok: false,
+			problem: "no-rubric",
+			path: [
+				"rubric",
+				"criteria",
+				index
+			]
+		};
+		if (names.has(require_registry.levelKey(name))) return {
+			ok: false,
+			problem: "duplicate-criteria",
+			path: [
+				"rubric",
+				"criteria",
+				index,
+				"name"
+			]
+		};
+		names.add(require_registry.levelKey(name));
+		const levels = require_registry.readRubricLevels(criterion.levels);
+		if (!levels.ok) return {
+			ok: false,
+			problem: "unreadable-levels",
+			path: [
+				"rubric",
+				"criteria",
+				index,
+				"levels"
+			]
+		};
+		criteria.push({
+			name,
+			...typeof description === "string" ? { description } : {},
+			weight,
+			levels: levels.levels
+		});
+	}
+	return {
+		ok: true,
+		criteria
+	};
+}
+/**
+* The rubric's criteria by name, folded as level labels are: composed, trimmed,
+* spaced once, lower-cased. A model that writes "task achievement" for "Task
+* achievement" judged that criterion. The request refused a rubric with two
+* names alike once folded, so a folded name is one criterion's alone.
+*/
+function criterionIndex(rubric) {
+	const folded = new Map(rubric.map((criterion, index) => [require_registry.levelKey(criterion.name), index]));
+	return (name) => folded.get(require_registry.levelKey(name));
+}
+/** A finite number. */
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+* One criterion's judgement, on that criterion's scale: a level it has, with
+* any probabilities a distribution over its levels whose likeliest is the
+* level chosen; or, without levels, a score from 0 to its `maxScore` (1 by
+* default).
+*/
+function judgeCriterion(entry, criterion) {
+	const { level, score, maxScore, probabilities } = entry;
+	const levels = criterion.levels;
+	if (levels === null) {
+		if (level !== void 0 || probabilities !== void 0) return {
+			ok: false,
+			refusal: "out-of-scale"
+		};
+		if (score === void 0) return {
+			ok: false,
+			refusal: "misses-criteria"
+		};
+		if (!isNumber(score) || maxScore !== void 0 && !isNumber(maxScore)) return {
+			ok: false,
+			refusal: "malformed"
+		};
+		const max = maxScore ?? 1;
+		if (!(max > 0) || score < 0 || score - max > max * 1e-9) return {
+			ok: false,
+			refusal: "out-of-scale"
+		};
+		return {
+			ok: true,
+			judged: {
+				name: criterion.name,
+				score: Math.min(1, score / max)
+			}
+		};
+	}
+	if (score !== void 0 || maxScore !== void 0) return {
+		ok: false,
+		refusal: "out-of-scale"
+	};
+	if (level === void 0) return {
+		ok: false,
+		refusal: "misses-criteria"
+	};
+	if (typeof level !== "string") return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const chosen = levels.findIndex((one) => require_registry.levelKey(one.label) === require_registry.levelKey(level));
+	if (chosen === -1) return {
+		ok: false,
+		refusal: "out-of-scale"
+	};
+	const judged = {
+		name: criterion.name,
+		level: levels[chosen].label,
+		score: chosen / (levels.length - 1)
+	};
+	if (probabilities === void 0) return {
+		ok: true,
+		judged
+	};
+	if (!Array.isArray(probabilities)) return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const values = require_registry.levelDistribution(probabilities, levels.length, chosen);
+	if (values === null) return {
+		ok: false,
+		refusal: "out-of-scale"
+	};
+	return {
+		ok: true,
+		judged: {
+			...judged,
+			probabilities: values
+		}
+	};
+}
+/**
+* Checks a grade a port returned for `request`. Whole or nothing, as every AI
+* text is: a reply the SDK doubts in any part is refused, and is no grade —
+* re-ask the model or send the response to a person; never record a 0.
+*
+* - **Every criterion of the rubric, once** (`misses-criteria`). Names match as
+*   written, or folded when the folded name is one criterion's alone. Leaving
+*   one out, inventing or renaming one, judging one twice or calling one not
+*   applicable refuses the reply: a total renormalised over fewer criteria
+*   is a grade of a different task.
+* - **On each criterion's own scale** (`out-of-scale`). With levels: a `level`
+*   the criterion has, as labelled (case and spacing aside), and any
+*   `probabilities` a distribution over its levels, lowest first, whose
+*   likeliest is the level chosen. Without levels: a `score` from 0 to its
+*   `maxScore`, 1 by default.
+* - **Every correction quotes the response** (`misquotes-answer`), anchored as
+*   feedback on writing anchors it.
+* - **Text fields** — a criterion's `comment` (at most
+*   `AI_WRITING_MAX_FIELD_LENGTH` code points), `feedback` and `rationale`
+*   (at most `AI_TEXT_MAX_LENGTH`) — are plain text, cleaned; longer is
+*   `too-long`. `requiresHumanReview` is a boolean.
+*
+* The total is not computed here: `gradeFromJudgement` computes it, as
+* `gradeFromRubric` computes every grade in the SDK.
+*/
+function checkAiGrading(raw, request) {
+	if (!isRecord(raw)) return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const { criteria: listed, feedback, corrections, rationale, requiresHumanReview } = raw;
+	if (listed === void 0) return {
+		ok: false,
+		refusal: "misses-criteria"
+	};
+	if (!Array.isArray(listed)) return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const rubric = request.facts.rubric;
+	const indexOf = criterionIndex(rubric);
+	const judged = rubric.map(() => void 0);
+	for (const entry of listed) {
+		if (!isRecord(entry)) return {
+			ok: false,
+			refusal: "malformed"
+		};
+		const name = entry.name;
+		const notApplicable = entry.notApplicable;
+		const written = entry.comment;
+		const scale = {
+			level: entry.level,
+			score: entry.score,
+			maxScore: entry.maxScore,
+			probabilities: entry.probabilities
+		};
+		if (typeof name !== "string" || notApplicable !== void 0 && typeof notApplicable !== "boolean") return {
+			ok: false,
+			refusal: "malformed"
+		};
+		const index = indexOf(name);
+		if (index === void 0 || judged[index] !== void 0 || notApplicable === true) return {
+			ok: false,
+			refusal: "misses-criteria"
+		};
+		const criterion = rubric[index];
+		const scaled = judgeCriterion(scale, criterion);
+		if (!scaled.ok) return scaled;
+		const comment = textField(written, 500);
+		if (!comment.ok) return comment;
+		judged[index] = {
+			...scaled.judged,
+			...comment.value !== void 0 ? { comment: comment.value } : {}
+		};
+	}
+	if (judged.some((one) => one === void 0)) return {
+		ok: false,
+		refusal: "misses-criteria"
+	};
+	const anchored = checkCorrections(corrections, request.facts.text);
+	if (!anchored.ok) return anchored;
+	const said = textField(feedback, AI_TEXT_MAX_LENGTH);
+	if (!said.ok) return said;
+	const why = textField(rationale, AI_TEXT_MAX_LENGTH);
+	if (!why.ok) return why;
+	if (requiresHumanReview !== void 0 && typeof requiresHumanReview !== "boolean") return {
+		ok: false,
+		refusal: "malformed"
+	};
+	const provenance = provenanceOf(raw.provenance);
+	const usage = usageOf(raw.usage);
+	return {
+		ok: true,
+		judgement: {
+			criteria: judged,
+			feedback: said.value ?? null,
+			corrections: anchored.corrections,
+			...why.value !== void 0 ? { rationale: why.value } : {},
+			requiresHumanReview: requiresHumanReview === true,
+			...provenance !== void 0 ? { provenance } : {},
+			...usage !== void 0 ? { usage } : {}
+		}
+	};
+}
+//#endregion
+//#region src/ai-writing.ts
+/**
+* The request for feedback on a draft, or `null` when there is none to give:
+* not a written response, an author who switched explanations off (writing
+* feedback reads `ai.explanations`), a redacted item — feedback is for
+* practice, where the item is whole — or a draft with nothing in it.
+*
+* The facts are the task as the learner saw it, the draft verbatim with its
+* word count recomputed as the grader will count it, and the rubric the answer
+* will be graded on. `previousFeedback` is the text of the feedback already
+* shown on earlier drafts, so a model can speak to what changed. `group` is the
+* item group the task sits in: its material, the text a summary is of, goes
+* with the request as `material`.
+*/
+function aiWritingFeedbackRequest(input) {
+	const { data, response, learnerLocale } = input;
+	if (!aiSupports(data.type, "writing-feedback") || !aiAllowedByContent(data, "writing-feedback") || data.redacted === true) return null;
+	const text = response?.type === "written-response" ? response.text : "";
+	if (typeof text !== "string" || text.trim() === "") return null;
+	const item = data;
+	const wordCount = require_registry.countWords(text);
+	const minWords = typeof item.minWords === "number" ? item.minWords : 0;
+	const maxWords = typeof item.maxWords === "number" ? item.maxWords : Number.POSITIVE_INFINITY;
+	const criteria = Array.isArray(item.rubric?.criteria) ? item.rubric.criteria : null;
+	const rubric = criteria === null || criteria.length === 0 ? null : criteria.map((criterion) => ({
+		name: criterion.name,
+		...typeof criterion.description === "string" ? { description: criterion.description } : {},
+		weight: criterion.weight
+	}));
+	const previousFeedback = [...input.previousFeedback ?? []];
+	const material = materialFacts(input.group);
+	return {
+		feature: "writing-feedback",
+		facts: {
+			activityType: "written-response",
+			activityId: data.id,
+			title: data.title,
+			...typeof data.locale === "string" ? { locale: data.locale } : {},
+			prompt: typeof item.prompt === "string" ? item.prompt : "",
+			text,
+			wordCount,
+			minWords,
+			maxWords,
+			withinWordBounds: wordCount >= minWords && wordCount <= maxWords,
+			rubric,
+			...typeof item.languageTarget === "string" ? { languageTarget: item.languageTarget } : {}
+		},
+		draftNumber: previousFeedback.length + 1,
+		previousFeedback,
+		...material !== null ? { material } : {},
+		...learnerLocale !== void 0 ? { learnerLocale } : {}
+	};
+}
 /** A criterion score a grade could be computed from: finite, 0 or more, and not above its maximum. */
 function isJudgedScore(score, maxScore) {
 	if (score === void 0) return maxScore === void 0 || typeof maxScore === "number" && maxScore > 0;
@@ -2524,7 +3099,7 @@ function checkCriteria(raw, rubric) {
 			ok: false,
 			refusal: "malformed"
 		};
-		const band = textField(entry.band, MAX_TAG_LENGTH);
+		const band = textField(entry.band, 40);
 		const comment = textField(entry.comment, 500);
 		if (!band.ok) return band;
 		if (!comment.ok) return comment;
@@ -2638,6 +3213,12 @@ Object.defineProperty(exports, "AI_EXPLANATION_TYPES", {
 		return AI_EXPLANATION_TYPES;
 	}
 });
+Object.defineProperty(exports, "AI_GRADING_PROBABILITY_TOLERANCE", {
+	enumerable: true,
+	get: function() {
+		return AI_GRADING_PROBABILITY_TOLERANCE;
+	}
+});
 Object.defineProperty(exports, "AI_HINT_TYPES", {
 	enumerable: true,
 	get: function() {
@@ -2710,6 +3291,12 @@ Object.defineProperty(exports, "aiGradeOf", {
 		return aiGradeOf;
 	}
 });
+Object.defineProperty(exports, "aiGradingRequest", {
+	enumerable: true,
+	get: function() {
+		return aiGradingRequest;
+	}
+});
 Object.defineProperty(exports, "aiHintRequest", {
 	enumerable: true,
 	get: function() {
@@ -2758,6 +3345,12 @@ Object.defineProperty(exports, "checkAiExplanation", {
 		return checkAiExplanation;
 	}
 });
+Object.defineProperty(exports, "checkAiGrading", {
+	enumerable: true,
+	get: function() {
+		return checkAiGrading;
+	}
+});
 Object.defineProperty(exports, "checkAiHint", {
 	enumerable: true,
 	get: function() {
@@ -2824,12 +3417,30 @@ Object.defineProperty(exports, "interactiveVideoFromDrafts", {
 		return interactiveVideoFromDrafts;
 	}
 });
+Object.defineProperty(exports, "listMediaRefs", {
+	enumerable: true,
+	get: function() {
+		return listMediaRefs;
+	}
+});
+Object.defineProperty(exports, "mapMediaRefs", {
+	enumerable: true,
+	get: function() {
+		return mapMediaRefs;
+	}
+});
 Object.defineProperty(exports, "readAiTextResult", {
 	enumerable: true,
 	get: function() {
 		return readAiTextResult;
 	}
 });
+Object.defineProperty(exports, "transcriptOf", {
+	enumerable: true,
+	get: function() {
+		return transcriptOf;
+	}
+});
 Object.defineProperty(exports, "validateDraft", {
 	enumerable: true,
 	get: function() {
@@ -2843,4 +3454,4 @@ Object.defineProperty(exports, "validateItemGroupDraft", {
 	}
 });
 
-//# sourceMappingURL=ai-writing-G6tnCGzw.cjs.map
+//# sourceMappingURL=ai-writing-C4YRVrFi.cjs.map