dsh-aha-tutor 1.5.0 → 1.7.0

package/lib/index.js

@@ -1,4 +1,4 @@
-import { $ as conceptIndex, A as generateText, B as readProgress, C as revisePrompt, D as TutorError, E as summaryPrompt, F as materialImages, G as applyEvidence, H as formatPassages, I as materialsSummary, J as recommendNext, K as createConceptState, L as passagesFor, M as EMPTY_PROFILE, N as emptyProgress, O as generateJson, P as masteryFor, Q as blueprintOutline, R as readMaterials, S as researchQueriesPrompt, T as shortPrompt, U as passageRange, V as documentParts, W as spreadPassages, X as boardToPlainText, Y as extractJson, Z as normalizeBoard, _ as projectReviewPrompt, _t as assertId, a as blueprintPrompt, at as lessonAfter, b as quizPrompt, c as detectLanguage, ct as normalizeCards, d as flashcardsPrompt, dt as normalizePractice, et as courseProgress, f as gradePrompt, ft as normalizeProject, g as profilePrompt, gt as text, h as practicePrompt, ht as safeRelativePath, i as assistPrompt, it as intakeSummary, j as streamCounter, k as generateSteps, l as digestPartPrompt, lt as normalizeCheatsheet, m as materialBriefPrompt, mt as outlineForPrompt, n as publishRuntime, nt as flattenLessons, o as cheatsheetPrompt, ot as nextLesson, p as lessonPrompt, pt as normalizeQuestionnaire, q as masteryPercent, r as askPrompt, rt as insertLesson, s as correctionPrompt, st as normalizeBlueprint, tt as findLesson, u as digestPrompt, ut as normalizeLesson, v as projectsPrompt, vt as newId, w as reworkPrompt, x as reexplainPrompt, y as questionnairePrompt, z as readProfile } from "./runtime-DqCjJ0yL.js";
+import { $ as passageRange, A as verifyItemPrompt, At as plotToText, B as materialImages, C as quizPrompt, Ct as normalizeLesson, D as reworkPrompt, Dt as outlineForPrompt, E as revisePrompt, Et as normalizeQuestionnaire, F as generateText, G as readProgress, H as passagesFor, I as streamCounter, J as masteryPercent, K as applyEvidence, L as EMPTY_PROFILE, M as TutorError, Mt as newId, N as generateJson, O as shortPrompt, Ot as safeRelativePath, P as generateSteps, Q as formatPassages, R as emptyProgress, S as questionnairePrompt, St as normalizeItem, T as researchQueriesPrompt, Tt as normalizeProject, U as readMaterials, V as materialsSummary, W as readProfile, X as buildIndex, Y as recommendNext, Z as documentParts, _ as materialsRevisePrompt, _t as nextLesson, a as blueprintPrompt, at as boardToPlainText, b as projectReviewPrompt, bt as normalizeCheatsheet, c as correctionPrompt, ct as normalizeOp, d as digestPrompt, dt as courseProgress, et as search, f as flashcardsPrompt, ft as findLesson, g as materialBriefPrompt, gt as lessonAfter, h as lessonPrompt, ht as intakeSummary, i as assistPrompt, it as BOARD_LIMITS, j as verifyStepPrompt, jt as assertId, k as summaryPrompt, kt as text, l as detectLanguage, lt as blueprintOutline, m as handoutPrompt, mt as insertLesson, n as publishRuntime, nt as spreadPassages, o as challengePrompt, ot as estimateSpeechMs, p as gradePrompt, pt as flattenLessons, q as createConceptState, r as askPrompt, rt as extractJson, s as cheatsheetPrompt, st as normalizeBoard, tt as snippetOf, u as digestPartPrompt, ut as conceptIndex, v as practicePrompt, vt as normalizeBlueprint, w as reexplainPrompt, wt as normalizePractice, x as projectsPrompt, xt as normalizeHandout, y as profilePrompt, yt as normalizeCards, z as masteryFor } from "./runtime-DfoeKFPj.js";
 import { createRequire } from "node:module";
 import { dirname, join, relative, sep } from "node:path";
 import { credentialKey } from "@deepseek-ai/dsh-credentials";
@@ -490,15 +490,76 @@ function createCourses({ store, llm, jobs, research, now = () => /* @__PURE__ */
 			meta: { courseId }
 		});
 	}
+	function addMaterials({ courseId, materialIds = [], instruction }) {
+		const wanted = [...new Set(materialIds)].filter((id) => /^mat_[a-z0-9]+$/u.test(id)).slice(0, 12);
+		if (!wanted.length) throw new TutorError("no-materials", "Choose at least one material");
+		const request = text(instruction, 600);
+		return jobs.start("craft/revise", async (api) => {
+			const course = await readCourse(courseId);
+			if (!course.units) throw new TutorError("no-blueprint", "There is no blueprint to revise yet");
+			const known = course.materialIds ?? [];
+			const added = (await readMaterials(store, wanted.filter((id) => !known.includes(id)))).slice(0, Math.max(0, 12 - known.length));
+			if (!added.length) throw new TutorError(wanted.every((id) => known.includes(id)) ? "materials-known" : known.length >= 12 ? "materials-full" : "not-found", "These materials cannot be added");
+			const current = {
+				title: course.title,
+				subtitle: course.subtitle,
+				emoji: course.emoji,
+				summary: course.summary,
+				level: course.level,
+				units: course.units,
+				projects: course.projects
+			};
+			const share = Math.floor(9e3 / added.length);
+			const passages = added.filter((item) => item.chunks.length).map((item) => formatPassages(spreadPassages(item.chunks, {
+				maxChars: share,
+				samples: 8
+			}), item.meta.title)).join("\n\n");
+			api.progress(0, 0, "blueprint");
+			const revised = await generateJson(llm, {
+				purpose: "teach",
+				prompt: materialsRevisePrompt({
+					blueprint: current,
+					materials: materialsSummary(added),
+					passages,
+					instruction: request,
+					language: course.language
+				}),
+				images: llm.supportsImages?.("teach") ? await materialImages(store, added) : void 0,
+				maxTokens: 16e3,
+				signal: api.signal,
+				onText: streamCounter("\"estMinutes\"", (count) => api.progress(count, 0, "blueprint")),
+				normalize: (raw) => attachProjectUnits(raw, normalizeBlueprint(raw, { language: course.language }))
+			});
+			const proposal = {
+				instruction: request,
+				materials: added.map((item) => ({
+					id: item.meta.id,
+					title: item.meta.title
+				})),
+				at: stamp(),
+				blueprint: revised
+			};
+			await store.writeJson(store.paths.proposal(courseId), proposal);
+			return {
+				course,
+				proposal
+			};
+		}, {
+			key: `blueprint:${courseId}`,
+			meta: { courseId }
+		});
+	}
 	async function applyProposal({ courseId }) {
 		const course = await readCourse(courseId);
 		const proposal = await store.readJson(store.paths.proposal(courseId), null);
 		if (!proposal?.blueprint?.units) throw new TutorError("no-proposal", "There is no proposed change");
+		const materialIds = [.../* @__PURE__ */ new Set([...course.materialIds ?? [], ...(proposal.materials ?? []).map((item) => item.id)])].slice(0, 12);
 		const next = {
 			...course,
 			...proposal.blueprint,
 			language: course.language,
-			status: course.status === "ready" ? "ready" : "blueprint"
+			status: course.status === "ready" ? "ready" : "blueprint",
+			...materialIds.length ? { materialIds } : {}
 		};
 		await saveCourse(next);
 		await store.removeDir(store.paths.proposal(courseId));
@@ -766,6 +827,7 @@ function createCourses({ store, llm, jobs, research, now = () => /* @__PURE__ */
 		startCraft,
 		submitIntake,
 		revise,
+		addMaterials,
 		applyProposal,
 		discardProposal,
 		reworkLesson,
@@ -932,7 +994,7 @@ function createJobs({ logger, now = Date.now } = {}) {
 		const aborted = new Promise((_, reject) => {
 			controller.signal.addEventListener("abort", () => reject(controller.signal.reason ?? /* @__PURE__ */ new Error("cancelled")), { once: true });
 		});
-		Promise.race([Promise.resolve().then(() => run(api)), aborted]).then((result) => {
+		job.settled = Promise.race([Promise.resolve().then(() => run(api)), aborted]).then((result) => {
 			job.status = "done";
 			job.result = result;
 		}).catch((error) => {
@@ -979,6 +1041,12 @@ function createJobs({ logger, now = Date.now } = {}) {
 		const job = id ? jobs.get(id) : void 0;
 		return job && !job.finishedAt && !job.controller.signal.aborted ? snapshot(job) : null;
 	}
+	async function wait(id) {
+		const job = jobs.get(id);
+		if (!job) return null;
+		await job.settled;
+		return snapshot(job);
+	}
 	function cancelKey(key) {
 		const job = running(key);
 		return job ? cancel(job.id) : null;
@@ -991,6 +1059,7 @@ function createJobs({ logger, now = Date.now } = {}) {
 	return Object.freeze({
 		start,
 		get,
+		wait,
 		cancel,
 		cancelKey,
 		running,
@@ -2037,10 +2106,10 @@ function neededWeeklyMinutes(course, start, deadline, studyDays) {
 	const perDay = remaining / studyDayCount / (1 - REVIEW_SHARE);
 	return Math.ceil(perDay * studyDays.length / 10) * 10;
 }
-const itemKey = (item) => `${item.kind}:${item.refId}`;
+const itemKey$1 = (item) => `${item.kind}:${item.refId}`;
 function mergeAgenda(saved = [], planned = []) {
-	const seen = new Set(saved.map(itemKey));
-	return [...saved, ...planned.filter((item) => !seen.has(itemKey(item)))];
+	const seen = new Set(saved.map(itemKey$1));
+	return [...saved, ...planned.filter((item) => !seen.has(itemKey$1(item)))];
 }
 function planCalendar({ today, agenda = {}, plan, done = {}, checks = [], ahead = 120 }) {
 	const lessonsDone = done.lessons ?? /* @__PURE__ */ new Map();
@@ -2049,7 +2118,7 @@ function planCalendar({ today, agenda = {}, plan, done = {}, checks = [], ahead
 	const days = /* @__PURE__ */ new Map();
 	const put = (day, item) => {
 		const list = days.get(day) ?? [];
-		if (!list.some((entry) => itemKey(entry) === itemKey(item))) list.push(item);
+		if (!list.some((entry) => itemKey$1(entry) === itemKey$1(item))) list.push(item);
 		days.set(day, list);
 	};
 	for (const [day, items] of Object.entries(agenda)) if (day <= today) for (const item of items) put(day, item);
@@ -2099,9 +2168,10 @@ function createLearner({ store, llm, now = () => /* @__PURE__ */ new Date(), log
 		return readProfile(store);
 	}
 	async function saveProfile(patch = {}) {
+		const given = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== void 0));
 		return store.updateJson(store.paths.profile(), { ...EMPTY_PROFILE }, (current) => cleanProfile({
 			...current,
-			...patch,
+			...given,
 			updatedAt: now().toISOString()
 		}));
 	}
@@ -2368,16 +2438,33 @@ function createLearner({ store, llm, now = () => /* @__PURE__ */ new Date(), log
 				const lesson = findLesson(course, concept.lessonId)?.lesson;
 				const set = await store.readJson(store.paths.practice(course.id, concept.lessonId), null);
 				const board = await store.readJson(store.paths.board(course.id, concept.lessonId), null);
-				const candidates = [...set?.items ?? [], ...(board?.steps ?? []).map((step) => step.check).filter(Boolean)].filter((item) => item.conceptIds?.includes(conceptId) && item.kind !== "short" && item.kind !== "work");
-				const item = candidates[Math.floor(Math.random() * candidates.length)];
-				if (item) items.push({
+				const candidates = [...(set?.items ?? []).map((item) => ({
+					item,
+					source: {
+						kind: "practice",
+						courseId: course.id,
+						lessonId: concept.lessonId,
+						itemId: item.id
+					}
+				})), ...(board?.steps ?? []).filter((step) => step.check).map((step) => ({
+					item: step.check,
+					source: {
+						kind: "check",
+						courseId: course.id,
+						lessonId: concept.lessonId,
+						stepId: step.id
+					}
+				}))].filter(({ item }) => item.conceptIds?.includes(conceptId) && item.kind !== "short" && item.kind !== "work");
+				const pick = candidates[Math.floor(Math.random() * candidates.length)];
+				if (pick) items.push({
 					courseId: course.id,
 					courseTitle: course.title,
 					lessonId: concept.lessonId,
 					lessonTitle: lesson?.title ?? "",
 					conceptId,
 					conceptName: concept.name,
-					item
+					item: pick.item,
+					source: pick.source
 				});
 			}
 		}
@@ -2404,6 +2491,7 @@ function list(value) {
 }
 function cleanProfile(profile) {
 	return {
+		name: text(profile.name, 20).replace(/[\r\n]+/gu, " "),
 		background: text(profile.background, 600),
 		goals: list(profile.goals) ?? [],
 		strengths: list(profile.strengths) ?? [],
@@ -2426,6 +2514,223 @@ function cleanProfile(profile) {
 	};
 }
 //#endregion
+//#region src/core/board-fix.js
+const VERDICTS = Object.freeze([
+	"wrong",
+	"right",
+	"unclear"
+]);
+const LAYOUT = /* @__PURE__ */ new Set([
+	"col",
+	"page",
+	"mark"
+]);
+function opPlain(op) {
+	switch (op?.t) {
+		case "title":
+		case "h":
+		case "p":
+		case "note": return op.text;
+		case "math": return op.text || op.tex;
+		case "list": return op.items.join("; ");
+		case "table": return [op.head, ...op.rows].filter((row) => row.length).map((row) => row.join(" | ")).join(" / ");
+		case "code": return op.code;
+		case "chart": return [
+			op.title,
+			...op.series.map((series) => `${series.name} ${series.points.slice(0, 6).map((point) => `(${point.join(", ")})`).join(" ")}`),
+			...op.data.map((item) => `${item.label} ${item.value}`)
+		].filter(Boolean).join("; ");
+		case "plot": return plotToText(op).replace(/\n/gu, "; ");
+		case "svg":
+		case "anim": return op.caption ?? "";
+		default: return "";
+	}
+}
+const withoutPlace = (op) => JSON.stringify({
+	...op,
+	id: void 0,
+	at: void 0,
+	fixed: void 0
+});
+function normalizeVerdict(raw, steps) {
+	const verdict = VERDICTS.includes(raw?.verdict) ? raw.verdict : null;
+	if (!verdict) throw new Error("the check names no verdict");
+	const summary = text(raw?.summary ?? raw?.reason, 400);
+	const fixes = [];
+	if (verdict !== "wrong") return {
+		verdict,
+		summary,
+		fixes
+	};
+	const byId = new Map(steps.map((step) => [step.id, step]));
+	const done = /* @__PURE__ */ new Set();
+	const keep = (key, fix) => {
+		if (done.has(key) || fixes.length >= 12) return;
+		done.add(key);
+		fixes.push(fix);
+	};
+	for (const fix of (Array.isArray(raw?.fixes) ? raw.fixes : []).slice(0, 36)) {
+		const step = byId.get(String(fix?.step ?? fix?.stepId ?? ""));
+		if (!step) continue;
+		const replacement = fix.replace ?? fix.with ?? fix.op_new;
+		if (replacement && typeof replacement === "object") {
+			const old = step.ops.find((op) => op.id === String(fix.op ?? fix.opId ?? ""));
+			const next = normalizeOp(replacement, 0);
+			if (old && next && !LAYOUT.has(old.t) && !LAYOUT.has(next.t) && withoutPlace(next) !== withoutPlace(old)) keep(`${step.id}:${old.id}`, {
+				step: step.id,
+				op: old.id,
+				replace: next
+			});
+		}
+		if (typeof fix.say === "string") {
+			const say = text(fix.say, BOARD_LIMITS.say);
+			if (say && say !== step.say) keep(`${step.id}:say`, {
+				step: step.id,
+				say
+			});
+		}
+		if (fix.check && typeof fix.check === "object" && step.check) {
+			const check = normalizeItem(fix.check, 0, step.check.conceptIds ?? []);
+			if (check && check.kind !== "order") {
+				const next = {
+					...check,
+					id: step.check.id,
+					conceptIds: step.check.conceptIds ?? []
+				};
+				if (JSON.stringify(next) !== JSON.stringify(step.check)) keep(`${step.id}:check`, {
+					step: step.id,
+					check: next
+				});
+			}
+		}
+	}
+	return {
+		verdict,
+		summary,
+		fixes
+	};
+}
+function applyFixes(steps, fixes, { at = (/* @__PURE__ */ new Date()).toISOString() } = {}) {
+	const applied = [];
+	return {
+		steps: steps.map((step) => {
+			const own = fixes.filter((fix) => fix.step === step.id);
+			if (!own.length) return step;
+			const copy = {
+				...step,
+				ops: [...step.ops]
+			};
+			for (const fix of own) {
+				if (fix.replace) {
+					const index = copy.ops.findIndex((op) => op.id === fix.op);
+					if (index < 0) continue;
+					const old = copy.ops[index];
+					const note = fix.replace.fixed;
+					const op = {
+						...fix.replace,
+						id: old.id,
+						...old.at !== void 0 ? { at: old.at } : {},
+						fixed: {
+							was: old.fixed?.was ?? note?.was ?? text(opPlain(old), 300),
+							at: note?.at ?? at
+						}
+					};
+					copy.ops[index] = op;
+					applied.push({
+						step: step.id,
+						op: old.id,
+						replace: op
+					});
+				}
+				if (fix.say !== void 0) {
+					copy.say = fix.say;
+					applied.push({
+						step: step.id,
+						say: fix.say
+					});
+				}
+				if (fix.check && copy.check) {
+					copy.check = {
+						...fix.check,
+						id: copy.check.id,
+						conceptIds: copy.check.conceptIds ?? []
+					};
+					applied.push({
+						step: step.id,
+						check: copy.check
+					});
+				}
+			}
+			return copy;
+		}),
+		applied
+	};
+}
+function sanitizeStep(raw) {
+	const id = String(raw?.id ?? "");
+	if (!/^[\w-]{1,48}$/u.test(id) || !Array.isArray(raw?.ops)) return null;
+	const ops = raw.ops.slice(0, BOARD_LIMITS.opsPerStep).map((op) => {
+		const clean = normalizeOp(op, 0);
+		if (!clean || typeof op.id !== "string" || !/^[\w-]{1,48}$/u.test(op.id)) return null;
+		return {
+			...clean,
+			id: op.id,
+			...Number.isInteger(op.at) && op.at >= 0 && op.at < 20 ? { at: op.at } : {}
+		};
+	}).filter(Boolean);
+	const say = text(raw.say, BOARD_LIMITS.say);
+	if (!say && !ops.length) return null;
+	return {
+		id,
+		say,
+		ops
+	};
+}
+function stepJson(step, { full = false } = {}) {
+	const ops = step.ops.map(({ fixed, ...op }) => {
+		if (op.t === "svg") return full ? {
+			...op,
+			svg: op.svg.slice(0, 16e3)
+		} : {
+			...op,
+			svg: "…"
+		};
+		if (op.t === "anim") return {
+			...op,
+			html: full ? op.html.slice(0, 8e3) : "…",
+			poster: "…"
+		};
+		return op;
+	});
+	return JSON.stringify({
+		id: step.id,
+		say: step.say,
+		ops,
+		...step.check ? { check: step.check } : {}
+	});
+}
+function boardForCheck(steps, stepId, { maxChars = 14e3 } = {}) {
+	const lines = steps.map((step) => stepJson(step));
+	const center = Math.max(0, steps.findIndex((step) => step.id === stepId));
+	const kept = /* @__PURE__ */ new Set([center]);
+	let used = lines[center]?.length ?? 0;
+	for (let distance = 1; distance < steps.length; distance += 1) for (const index of [center - distance, center + distance]) {
+		if (index < 0 || index >= steps.length || used + lines[index].length > maxChars) continue;
+		kept.add(index);
+		used += lines[index].length;
+	}
+	return lines.filter((line, index) => kept.has(index)).join("\n");
+}
+function describeFixes(fixes, steps) {
+	const byId = new Map(steps.map((step) => [step.id, step]));
+	return fixes.map((fix) => {
+		const step = byId.get(fix.step);
+		if (fix.replace) return `${fix.step} ${fix.op}: ${opPlain(step?.ops.find((op) => op.id === fix.op))} → ${opPlain(fix.replace)}`;
+		if (fix.say !== void 0) return `${fix.step} narration: ${step?.say ?? ""} → ${fix.say}`;
+		return `${fix.step} check answer: ${JSON.stringify(step?.check?.answer ?? "")} → ${JSON.stringify(fix.check?.answer ?? "")}`;
+	}).join("\n");
+}
+//#endregion
 //#region src/core/srs.js
 const GRADES$1 = Object.freeze([
 	"again",
@@ -2457,7 +2762,7 @@ function review(card, grade, now = Date.now()) {
 	if (!GRADES$1.includes(grade)) throw new TypeError(`grade must be one of ${GRADES$1.join(", ")}`);
 	const quality = GRADE_QUALITY[grade];
 	const next = { ...card };
-	next.ease = Math.max(MIN_EASE, round2(card.ease + .1 - (5 - quality) * (.08 + (5 - quality) * .02)));
+	next.ease = Math.max(MIN_EASE, round2$1(card.ease + .1 - (5 - quality) * (.08 + (5 - quality) * .02)));
 	if (grade === "again") {
 		next.reps = 0;
 		next.lapses = card.lapses + 1;
@@ -2483,10 +2788,412 @@ function gradeFromScore(score, confidence) {
 	if (score >= .95 && confidence === "sure") return "easy";
 	return "good";
 }
+function round2$1(value) {
+	return Math.round(value * 100) / 100;
+}
+//#endregion
+//#region src/core/evidence-log.js
+const scored = (evidence) => evidence?.kind !== "reexplain" && evidence?.kind !== "self" && Number.isFinite(Number(evidence?.score));
+const withoutHistory = ({ history, ...state }) => state;
+function takeEvidence(state, card, evidence, at) {
+	const next = applyEvidence(state, evidence, at);
+	if (!scored(evidence)) return {
+		state: next,
+		card
+	};
+	return {
+		state: next,
+		card: review(card ?? createCard(state.id, at), gradeFromScore(Number(evidence.score), evidence.confidence), at)
+	};
+}
+function stateBefore(state, card) {
+	return {
+		state: state ? withoutHistory(state) : null,
+		card: card ?? null
+	};
+}
+function logEvidence(progress, entry) {
+	progress.evidenceLog = [...Array.isArray(progress.evidenceLog) ? progress.evidenceLog : [], entry].slice(-50);
+}
+function itemKey(source) {
+	if (source?.kind === "practice") return `practice:${source.lessonId}:${source.itemId}`;
+	if (source?.kind === "quiz") return `quiz:${source.unitId}:${source.itemId}`;
+	if (source?.kind === "check") return `check:${source.lessonId}:${source.stepId}`;
+	return null;
+}
+function answersTo(progress, key, except = null) {
+	if (!key) return [];
+	return (Array.isArray(progress?.evidenceLog) ? progress.evidenceLog : []).filter((entry) => entry.item?.key === key && entry.id !== except && scored(entry.evidence));
+}
+function correctEvidence(progress, id, patch, { known = (conceptId) => conceptId, at = (/* @__PURE__ */ new Date()).toISOString() } = {}) {
+	const log = Array.isArray(progress.evidenceLog) ? progress.evidenceLog : [];
+	const index = log.findIndex((entry) => entry.id === id);
+	if (index < 0) return null;
+	const entry = log[index];
+	const evidence = {
+		...entry.evidence,
+		...patch
+	};
+	if (!scored(entry.evidence) || !scored(evidence)) return null;
+	const later = log.slice(index + 1);
+	progress.concepts ??= {};
+	progress.reviews ??= {};
+	const changed = [];
+	for (const conceptId of entry.conceptIds ?? []) {
+		const name = known(conceptId);
+		if (name === null || name === void 0) continue;
+		const after = later.filter((item) => item.conceptIds?.includes(conceptId));
+		const history = progress.concepts[conceptId]?.history ?? [];
+		const base = entry.before?.[conceptId];
+		let state = {
+			...base?.state ?? createConceptState(conceptId, name),
+			history: history.slice(0, Math.max(0, history.length - 1 - after.length))
+		};
+		let card = base?.card ?? null;
+		({state, card} = takeEvidence(state, card, evidence, Date.parse(entry.at)));
+		for (const item of after) {
+			item.before = {
+				...item.before,
+				[conceptId]: stateBefore(state, card)
+			};
+			({state, card} = takeEvidence(state, card, item.evidence, Date.parse(item.at)));
+		}
+		progress.concepts[conceptId] = state;
+		if (card) progress.reviews[conceptId] = card;
+		changed.push(conceptId);
+	}
+	entry.corrected = {
+		score: entry.corrected?.score ?? entry.evidence.score,
+		at
+	};
+	entry.evidence = evidence;
+	return { conceptIds: changed };
+}
+//#endregion
+//#region src/core/grading.js
+const OBJECTIVE_KINDS = Object.freeze([
+	"choice",
+	"multi",
+	"blank",
+	"number",
+	"order"
+]);
+const FULLWIDTH = /[！-～]/gu;
+function normalizeAnswerText(value) {
+	return String(value ?? "").normalize("NFKC").replace(FULLWIDTH, (char) => String.fromCharCode(char.charCodeAt(0) - 65248)).toLowerCase().replace(/[\s　]+/gu, " ").replace(/^[\s.,;:!?'"`，。；：！？、“”‘’]+|[\s.,;:!?'"`，。；：！？、“”‘’]+$/gu, "").trim();
+}
+function parseNumber(value) {
+	if (typeof value === "number") return value;
+	const text = normalizeAnswerText(value).replace(/,/gu, "").replace(/\s/gu, "");
+	const fraction = /^(-?\d+(?:\.\d+)?)\/(\d+(?:\.\d+)?)$/u.exec(text);
+	if (fraction) return Number(fraction[1]) / Number(fraction[2]);
+	const percent = /^(-?\d+(?:\.\d+)?)%$/u.exec(text);
+	if (percent) return Number(percent[1]) / 100;
+	const number = Number(text);
+	return Number.isFinite(number) ? number : NaN;
+}
+function gradeObjective(item, response) {
+	if (!item || !OBJECTIVE_KINDS.includes(item.kind)) return {
+		score: 0,
+		correct: false,
+		gradable: false
+	};
+	if (item.kind === "choice") {
+		const correct = String(response ?? "") === String(item.answer ?? "");
+		return {
+			score: correct ? 1 : 0,
+			correct,
+			gradable: true
+		};
+	}
+	if (item.kind === "multi") {
+		const expected = new Set((Array.isArray(item.answer) ? item.answer : [item.answer]).map(String));
+		const given = new Set((Array.isArray(response) ? response : []).map(String));
+		if (!expected.size) return {
+			score: 0,
+			correct: false,
+			gradable: false
+		};
+		let hits = 0;
+		let wrong = 0;
+		for (const id of given) if (expected.has(id)) hits += 1;
+		else wrong += 1;
+		const score = Math.max(0, (hits - wrong) / expected.size);
+		const correct = hits === expected.size && wrong === 0;
+		return {
+			score: round2(score),
+			correct,
+			gradable: true
+		};
+	}
+	if (item.kind === "order") {
+		const expected = (Array.isArray(item.answer) ? item.answer : []).map(String);
+		const given = (Array.isArray(response) ? response : []).map(String);
+		if (!expected.length) return {
+			score: 0,
+			correct: false,
+			gradable: false
+		};
+		let inPlace = 0;
+		expected.forEach((id, index) => {
+			if (given[index] === id) inPlace += 1;
+		});
+		return {
+			score: round2(inPlace / expected.length),
+			correct: inPlace === expected.length,
+			gradable: true
+		};
+	}
+	if (item.kind === "number") {
+		const expected = parseNumber(item.answer);
+		const given = parseNumber(response);
+		if (!Number.isFinite(expected)) return {
+			score: 0,
+			correct: false,
+			gradable: false
+		};
+		if (!Number.isFinite(given)) return {
+			score: 0,
+			correct: false,
+			gradable: true
+		};
+		const tolerance = Number.isFinite(Number(item.tolerance)) && Number(item.tolerance) >= 0 ? Number(item.tolerance) : Math.max(1e-9, Math.abs(expected) * .01);
+		const correct = Math.abs(given - expected) <= tolerance;
+		return {
+			score: correct ? 1 : 0,
+			correct,
+			gradable: true
+		};
+	}
+	const accepted = (Array.isArray(item.answer) ? item.answer : [item.answer]).map(normalizeAnswerText).filter(Boolean);
+	if (!accepted.length) return {
+		score: 0,
+		correct: false,
+		gradable: false
+	};
+	const given = normalizeAnswerText(response);
+	const correct = accepted.includes(given);
+	if (correct) return {
+		score: 1,
+		correct,
+		gradable: true
+	};
+	const asNumber = parseNumber(response);
+	const numeric = accepted.map(parseNumber).filter(Number.isFinite);
+	if (Number.isFinite(asNumber) && numeric.some((value) => Math.abs(value - asNumber) <= Math.max(1e-9, Math.abs(value) * .001))) return {
+		score: 1,
+		correct: true,
+		gradable: true
+	};
+	return {
+		score: 0,
+		correct: false,
+		gradable: true
+	};
+}
+function wrongLabel(item, response) {
+	if (item.kind === "choice") return `chose ${String(response).toUpperCase()}: ${(item.options?.find((option) => option.id === response)?.text ?? "").slice(0, 50)}`;
+	if (item.kind === "number" || item.kind === "blank") return `answered ${String(response).slice(0, 40)}`;
+	return "wrong";
+}
 function round2(value) {
 	return Math.round(value * 100) / 100;
 }
 //#endregion
+//#region src/core/item-fix.js
+const ITEM_VERDICTS = Object.freeze([
+	"wrong",
+	"unclear",
+	"misgraded",
+	"right"
+]);
+const MODEL_GRADED = Object.freeze(["short", "work"]);
+const FIELDS = [
+	"prompt",
+	"options",
+	"answer",
+	"tolerance",
+	"unit",
+	"explanation",
+	"hints",
+	"rubric",
+	"figure"
+];
+const modelGraded = (item) => MODEL_GRADED.includes(item?.kind);
+function cleanResponse(item, response) {
+	const ids = (item?.options ?? []).map((option) => option.id);
+	if (item?.kind === "choice") return ids.includes(response) ? response : "";
+	if (item?.kind === "multi" || item?.kind === "order") return [...new Set((Array.isArray(response) ? response : []).filter((id) => ids.includes(id)))];
+	return typeof response === "string" || typeof response === "number" ? text(response, 4e3) : "";
+}
+function responseText(item, response) {
+	const option = (id) => {
+		const found = item.options?.find((entry) => entry.id === id);
+		return found ? `${id.toUpperCase()}. ${found.text}` : String(id);
+	};
+	if (item.kind === "choice") return response ? option(response) : "";
+	if (item.kind === "multi") return response.map(option).join("; ");
+	if (item.kind === "order") return response.map(option).join(" → ");
+	if (item.kind === "number" && item.unit && response) return `${response} ${item.unit}`;
+	return String(response ?? "");
+}
+function itemForCheck(item) {
+	const { id, conceptIds, difficulty, fixed, svg, plot, ...rest } = item;
+	return JSON.stringify({
+		...rest,
+		...svg ? { svg: svg.slice(0, 8e3) } : {},
+		...plot ? { plot } : {}
+	});
+}
+function normalizeGrade(raw, kind) {
+	if (!raw || typeof raw !== "object" || !Number.isFinite(Number(raw.score))) return null;
+	const score = Math.min(1, Math.max(0, Number(raw.score)));
+	return {
+		score,
+		verdict: [
+			"correct",
+			"partial",
+			"incorrect"
+		].includes(raw.verdict) ? raw.verdict : score >= .8 ? "correct" : score >= .4 ? "partial" : "incorrect",
+		feedback: text(raw.feedback, 1200),
+		errorTag: text(raw.errorTag, 80),
+		...kind === "work" ? {
+			wrongStep: text(raw.wrongStep, 400),
+			why: text(raw.why, 400),
+			fix: text(raw.fix, 400)
+		} : {}
+	};
+}
+const figureOf = (item) => item.svg ? { svg: item.svg } : item.plot ? { plot: item.plot } : {};
+function correctedItem(old, raw) {
+	if (!raw || typeof raw !== "object" || raw.kind !== void 0 && raw.kind !== old.kind) return null;
+	const next = normalizeItem({
+		...raw,
+		kind: old.kind
+	}, 0);
+	if (!next || (old.options?.length ?? 0) !== (next.options?.length ?? 0)) return null;
+	const redrawn = [
+		"svg",
+		"figure",
+		"plot"
+	].some((key) => raw[key] !== void 0);
+	const { svg, plot, ...rest } = next;
+	return {
+		...rest,
+		...redrawn ? figureOf(next) : figureOf(old),
+		id: old.id,
+		conceptIds: old.conceptIds ?? [],
+		difficulty: old.difficulty ?? next.difficulty
+	};
+}
+const empty = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && !value.length;
+const same = (a, b) => empty(a) && empty(b) || JSON.stringify(a) === JSON.stringify(b);
+function changedParts(old, next) {
+	const was = {};
+	for (const field of FIELDS) if (field === "options") {
+		const options = Object.fromEntries((old.options ?? []).filter((option, index) => option.text !== next.options?.[index]?.text).map((option) => [option.id, option.text]));
+		if (Object.keys(options).length) was.options = options;
+	} else if (field === "figure") {
+		if (!same(figureOf(old), figureOf(next))) was.figure = true;
+	} else if (!same(old[field], next[field])) was[field] = empty(old[field]) ? null : old[field];
+	return was;
+}
+function normalizeItemVerdict(raw, item) {
+	const verdict = ITEM_VERDICTS.includes(raw?.verdict) ? raw.verdict : null;
+	if (!verdict) throw new Error("the check names no verdict");
+	if (verdict === "misgraded" && !modelGraded(item)) throw new Error("a choice, multi, blank, number or order question is graded by its answer key: when the key misjudged the answer, the verdict is \"wrong\" with the key corrected in \"item\"");
+	const summary = text(raw?.summary ?? raw?.reason, 400);
+	const explanation = text(raw?.explanation, 2e3);
+	const credit = verdict === "unclear" && raw?.credit === true;
+	let fixed = null;
+	if (verdict === "wrong" || verdict === "unclear") {
+		fixed = correctedItem(item, raw?.item);
+		if (!fixed) throw new Error(`a "${verdict}" verdict needs the whole corrected question in "item": the same kind, the same number of options`);
+		if (!Object.keys(changedParts(item, fixed)).length) throw new Error("the corrected question in \"item\" changes nothing");
+	}
+	const grade = modelGraded(item) && verdict !== "right" && !credit ? normalizeGrade(raw?.grade, item.kind) : null;
+	if (modelGraded(item) && verdict !== "right" && !credit && !grade) throw new Error("give the new \"grade\" of the learner's answer against the corrected question");
+	return {
+		verdict,
+		summary,
+		explanation,
+		item: fixed,
+		credit,
+		grade
+	};
+}
+function fixItem(stored, next, { at = (/* @__PURE__ */ new Date()).toISOString() } = {}) {
+	const { fixed: note, ...old } = stored;
+	const changed = changedParts(old, next);
+	const was = {
+		...changed,
+		...note?.was
+	};
+	if (changed.options && note?.was?.options) was.options = {
+		...changed.options,
+		...note.was.options
+	};
+	return {
+		...next,
+		id: stored.id,
+		conceptIds: stored.conceptIds ?? next.conceptIds ?? [],
+		fixed: {
+			was,
+			at: note?.at ?? at
+		}
+	};
+}
+function regrade(item, response, checked) {
+	if (checked.verdict === "right") return null;
+	if (checked.credit) return {
+		score: 1,
+		correct: true,
+		partial: false,
+		errorTag: ""
+	};
+	if (OBJECTIVE_KINDS.includes(item.kind)) {
+		const graded = gradeObjective(item, response);
+		return {
+			score: graded.score,
+			correct: graded.correct,
+			partial: !graded.correct && graded.score > 0
+		};
+	}
+	if (!checked.grade) return null;
+	const { verdict, ...grade } = checked.grade;
+	return {
+		...grade,
+		correct: verdict === "correct",
+		partial: verdict === "partial"
+	};
+}
+function earlierGrade(item, response, { verdict, score, grade = null }) {
+	if (verdict !== "wrong" && verdict !== "unclear") return null;
+	let next;
+	if (OBJECTIVE_KINDS.includes(item.kind)) {
+		const answer = cleanResponse(item, response);
+		const graded = gradeObjective(item, answer);
+		if (!graded.gradable) return null;
+		next = {
+			score: graded.score,
+			correct: graded.correct,
+			errorTag: graded.correct ? "" : wrongLabel(item, answer)
+		};
+	} else {
+		if (!grade || !Number.isFinite(Number(grade.score))) return null;
+		const value = Math.min(1, Math.max(0, Number(grade.score)));
+		const correct = grade.verdict ? grade.verdict === "correct" : value >= .8;
+		next = {
+			score: value,
+			correct,
+			errorTag: correct ? "" : text(grade.errorTag, 80)
+		};
+	}
+	const before = Math.min(1, Math.max(0, Number(score) || 0));
+	if (verdict === "unclear" && next.score <= before || Math.abs(next.score - before) < 1e-6) return null;
+	return next;
+}
+//#endregion
 //#region src/host/lessons.js
 const EVENTS_KEPT = 200;
 const STEP_ID = /^s\d{1,4}$/u;
@@ -2661,7 +3368,8 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 				course,
 				lesson: row.lesson,
 				board,
-				language: course.language
+				language: course.language,
+				writing
 			};
 		}
 		if (scope?.kind === "thread" || scope?.kind === "short") {
@@ -2678,7 +3386,8 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 					objectives: []
 				},
 				board,
-				language
+				language,
+				writing
 			};
 		}
 		throw new TutorError("invalid", "Unknown board");
@@ -2779,11 +3488,167 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 			};
 		});
 	}
-	async function record({ courseId, lessonId, conceptIds = [], evidence = {} }) {
+	async function challengedPlace(scope, board, target) {
+		const stepId = String(target?.stepId ?? "");
+		if (target?.asideId) {
+			const aside = (scope.kind === "lesson" ? await store.readJson(store.paths.asides(scope.courseId, scope.lessonId), null) : null)?.items?.find((item) => item.id === target.asideId);
+			const index = aside?.steps?.findIndex((item) => item.id === stepId) ?? -1;
+			if (index < 0) throw new TutorError("not-found", "Not found");
+			const anchor = board?.steps?.findIndex((step) => step.id === aside.anchorStepId) ?? -1;
+			return {
+				ref: { asideId: aside.id },
+				steps: aside.steps,
+				step: aside.steps[index],
+				context: [...(board?.steps ?? []).slice(0, anchor + 1), ...aside.steps.slice(0, index + 1)]
+			};
+		}
+		if (target?.step) {
+			const step = sanitizeStep(target.step);
+			if (!step) throw new TutorError("invalid", "Nothing to check");
+			const anchor = board?.steps?.findIndex((item) => item.id === target.anchorStepId) ?? -1;
+			return {
+				ref: { local: true },
+				steps: [step],
+				step,
+				context: [...(board?.steps ?? []).slice(0, anchor + 1), step]
+			};
+		}
+		const index = board?.steps?.findIndex((step) => step.id === stepId) ?? -1;
+		if (index < 0) throw new TutorError(board?.steps?.length ? "not-found" : "no-board", board?.steps?.length ? "Not found" : "The board is not written yet. Try again once its first step is up.");
+		return {
+			ref: { main: true },
+			steps: board.steps,
+			step: board.steps[index],
+			context: board.steps.slice(0, index + 1)
+		};
+	}
+	async function storeFixes(scope, place, fixes, writing) {
+		let applied = [];
+		const fix = (steps) => {
+			const result = applyFixes(Array.isArray(steps) ? steps : [], fixes);
+			applied = result.applied;
+			return result.steps;
+		};
+		if (place.ref.local) {
+			fix(place.steps);
+			return applied;
+		}
+		if (place.ref.asideId) {
+			await store.updateJson(store.paths.asides(scope.courseId, scope.lessonId), null, (value) => ({ items: (Array.isArray(value?.items) ? value.items : []).map((item) => item.id === place.ref.asideId ? {
+				...item,
+				steps: fix(item.steps)
+			} : item) }));
+			return applied;
+		}
+		if (writing && (await jobs.wait(writing.id))?.status !== "done") return applyFixes(place.steps, fixes).applied;
+		const missing = () => new TutorError("not-found", "Not found");
+		if (scope.kind === "lesson") await store.updateJson(store.paths.board(scope.courseId, scope.lessonId), null, (saved) => {
+			if (!saved) throw missing();
+			return {
+				...saved,
+				steps: fix(saved.steps)
+			};
+		});
+		else if (scope.kind === "thread") await store.updateJson(store.paths.item("assist", scope.id), null, (thread) => {
+			const turn = thread?.turns?.[Math.max(0, Math.min(thread.turns.length - 1, Number(scope.turn) || 0))];
+			if (!turn?.board) throw missing();
+			turn.board = {
+				...turn.board,
+				steps: fix(turn.board.steps)
+			};
+			return thread;
+		});
+		else await store.updateJson(store.paths.item("shorts", scope.id), null, (short) => {
+			if (!short?.board) throw missing();
+			return {
+				...short,
+				board: {
+					...short.board,
+					steps: fix(short.board.steps)
+				}
+			};
+		});
+		return applied;
+	}
+	function challenge({ scope, stepIndex = 0, anchorStepId, target = {}, note }) {
+		const doubt = text(note, 800);
+		return jobs.start("lesson/challenge", async (api) => {
+			const { course, lesson, board, language, writing } = await scopeBoard(scope);
+			const place = await challengedPlace(scope, board, {
+				...target,
+				anchorStepId
+			});
+			api.preview({ phase: "checking" });
+			const checked = await generateJson(llm, {
+				purpose: "teach",
+				effort: "low",
+				prompt: verifyStepPrompt({
+					course,
+					lesson,
+					language,
+					board: boardForCheck(place.steps, place.step.id),
+					step: stepJson(place.step, { full: true }),
+					stepId: place.step.id,
+					note: doubt
+				}),
+				maxTokens: 6e3,
+				signal: api.signal,
+				normalize: (raw) => normalizeVerdict(raw, place.steps)
+			});
+			api.preview({
+				phase: "answering",
+				verdict: checked.verdict
+			});
+			const answer = await generateSteps(llm, {
+				purpose: "teach",
+				effort: "lowest",
+				prompt: challengePrompt({
+					course,
+					lesson,
+					language,
+					boardSoFar: boardToPlainText({ steps: place.context }, { maxChars: 5e3 }),
+					step: boardToPlainText({ steps: [place.step] }, { maxChars: 3e3 }),
+					note: doubt,
+					verdict: checked.verdict,
+					summary: checked.summary,
+					fixes: describeFixes(checked.fixes, place.steps)
+				}),
+				maxTokens: 5e3,
+				signal: api.signal,
+				conceptIds: lesson?.concepts?.map((concept) => concept.id) ?? [],
+				onStep: (step) => api.push(step)
+			});
+			const fixes = checked.fixes.length ? await storeFixes(scope, place, checked.fixes, writing) : [];
+			const aside = await keepAside(scope, {
+				kind: "challenge",
+				verdict: checked.verdict,
+				note: doubt,
+				summary: checked.summary,
+				anchorStepId: anchorFor(board, stepIndex, anchorStepId),
+				steps: answer.steps
+			});
+			if (scope.kind === "lesson") await logEvent(scope.courseId, {
+				type: "challenge",
+				lessonId: scope.lessonId,
+				verdict: checked.verdict
+			});
+			return {
+				verdict: checked.verdict,
+				summary: checked.summary,
+				target: place.ref,
+				fixes,
+				steps: answer.steps,
+				aside
+			};
+		});
+	}
+	async function record({ courseId, lessonId, conceptIds = [], evidence = {}, item = null }) {
 		const course = await courses.readCourse(courseId);
 		const index = conceptIndex(course);
 		const ids = (Array.isArray(conceptIds) && conceptIds.length ? conceptIds : findLesson(course, lessonId)?.lesson.concepts.map((concept) => concept.id) ?? []).filter((id) => index.has(id)).slice(0, 8);
 		const at = now().getTime();
+		const evidenceId = newId("evd");
+		const key = item?.source?.courseId === courseId ? itemKey(item.source) : null;
 		const next = await store.updateJson(store.paths.progress(courseId), null, (progress) => {
 			const value = progress ?? {
 				courseId,
@@ -2796,14 +3661,25 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 			};
 			value.concepts ??= {};
 			value.reviews ??= {};
+			const before = {};
 			for (const id of ids) {
-				const state = value.concepts[id] ?? createConceptState(id, index.get(id).name);
-				value.concepts[id] = applyEvidence(state, evidence, at);
-				if (evidence.kind !== "reexplain" && evidence.kind !== "self" && Number.isFinite(Number(evidence.score))) {
-					const card = value.reviews[id] ?? createCard(id, at);
-					value.reviews[id] = review(card, gradeFromScore(Number(evidence.score), evidence.confidence), at);
-				}
+				before[id] = stateBefore(value.concepts[id], value.reviews[id]);
+				const taken = takeEvidence(value.concepts[id] ?? createConceptState(id, index.get(id).name), value.reviews[id], evidence, at);
+				value.concepts[id] = taken.state;
+				if (taken.card) value.reviews[id] = taken.card;
 			}
+			if (ids.length) logEvidence(value, {
+				id: evidenceId,
+				at: new Date(at).toISOString(),
+				lessonId: lessonId ?? null,
+				conceptIds: ids,
+				evidence: JSON.parse(JSON.stringify(evidence)),
+				before,
+				...key ? { item: {
+					key,
+					response: item.response ?? ""
+				} } : {}
+			});
 			pushEvent(value, {
 				type: "evidence",
 				lessonId: lessonId ?? null,
@@ -2816,12 +3692,233 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 			return value;
 		});
 		const states = ids.map((id) => next.concepts[id]).filter(Boolean);
+		return {
+			mastery: Object.fromEntries(states.map((state) => [state.id, masteryPercent(state)])),
+			recommendation: recommendNext(states),
+			evidenceId: ids.length ? evidenceId : null
+		};
+	}
+	async function regradeEvidence(course, evidenceId, patch) {
+		const index = conceptIndex(course);
+		let changed = null;
+		const next = await store.updateJson(store.paths.progress(course.id), null, (progress) => {
+			const value = progress ?? {
+				courseId: course.id,
+				lessons: {},
+				concepts: {},
+				reviews: {},
+				events: []
+			};
+			changed = correctEvidence(value, evidenceId, patch, {
+				known: (id) => index.get(id)?.name ?? null,
+				at: stamp()
+			});
+			if (changed) pushEvent(value, {
+				type: "regrade",
+				evidenceId,
+				conceptIds: changed.conceptIds,
+				score: patch.score,
+				at: stamp()
+			});
+			return value;
+		});
+		if (!changed?.conceptIds.length) return null;
+		const states = changed.conceptIds.map((id) => next.concepts[id]).filter(Boolean);
 		return {
 			mastery: Object.fromEntries(states.map((state) => [state.id, masteryPercent(state)])),
 			recommendation: recommendNext(states)
 		};
 	}
-	async function grade({ item, response, language = "zh-CN" }) {
+	async function itemPlace(source) {
+		const missing = () => new TutorError("not-found", "Not found");
+		const rewrite = (path, listOf) => async (change) => {
+			let saved = null;
+			await store.updateJson(path, null, (value) => {
+				const items = listOf(value);
+				const index = Array.isArray(items) ? items.findIndex((entry) => entry.id === source.itemId) : -1;
+				if (index < 0) throw missing();
+				saved = change(items[index]);
+				items[index] = saved;
+				return value;
+			});
+			return saved;
+		};
+		if (source.kind === "deck") {
+			const path = store.paths.item("decks", source.deckId);
+			const deck = await store.readJson(path, null);
+			const item = deck?.kind === "quiz" ? deck.items?.find((entry) => entry.id === source.itemId) : null;
+			if (!item) throw missing();
+			return {
+				item,
+				course: null,
+				lessonId: null,
+				language: deck.language,
+				scope: deck.title,
+				save: rewrite(path, (value) => value?.kind === "quiz" ? value.items : null)
+			};
+		}
+		const course = await courses.readCourse(source.courseId);
+		if (source.kind === "quiz") {
+			const unit = course.units?.find((entry) => entry.id === source.unitId);
+			const path = unit ? store.paths.unitQuiz(course.id, unit.id) : null;
+			const item = path ? (await store.readJson(path, null))?.items?.find((entry) => entry.id === source.itemId) : null;
+			if (!item) throw missing();
+			return {
+				item,
+				course,
+				lessonId: null,
+				language: course.language,
+				scope: `${course.title} — ${unit.title}`,
+				save: rewrite(path, (value) => value?.items)
+			};
+		}
+		const row = findLesson(course, source.lessonId);
+		if (!row) throw missing();
+		const scope = `${course.title} — ${row.lesson.title}`;
+		if (source.kind === "check") {
+			const path = store.paths.board(course.id, row.lesson.id);
+			const item = (await store.readJson(path, null))?.steps?.find((step) => step.id === source.stepId)?.check;
+			if (!item) throw missing();
+			const save = async (change) => {
+				let saved = null;
+				await store.updateJson(path, null, (board) => {
+					const step = board?.steps?.find((entry) => entry.id === source.stepId);
+					if (!step?.check) throw missing();
+					saved = change(step.check);
+					step.check = saved;
+					return board;
+				});
+				return saved;
+			};
+			return {
+				item,
+				course,
+				lessonId: row.lesson.id,
+				language: course.language,
+				scope,
+				save
+			};
+		}
+		const path = store.paths.practice(course.id, row.lesson.id);
+		const item = (await store.readJson(path, null))?.items?.find((entry) => entry.id === source.itemId);
+		if (!item) throw missing();
+		return {
+			item,
+			course,
+			lessonId: row.lesson.id,
+			language: course.language,
+			scope,
+			save: rewrite(path, (value) => value?.items)
+		};
+	}
+	async function regradeEarlier({ course, key, item, verdict, except, language, signal }) {
+		const answers = answersTo(await store.readJson(store.paths.progress(course.id), null), key, except);
+		const open = !OBJECTIVE_KINDS.includes(item.kind);
+		const graded = await Promise.all((open ? answers.slice(-3) : answers).map(async (entry) => {
+			const again = open ? await grade({
+				item,
+				response: entry.item.response,
+				language,
+				signal
+			}).catch((error) => {
+				if (signal?.aborted) throw error;
+				return null;
+			}) : null;
+			if (open && !again) return null;
+			return {
+				id: entry.id,
+				next: earlierGrade(item, entry.item.response, {
+					verdict,
+					score: entry.evidence.score,
+					grade: again
+				})
+			};
+		}));
+		let found = null;
+		for (const { id, next } of graded.filter((entry) => entry?.next)) {
+			const corrected = await regradeEvidence(course, id, {
+				score: next.score,
+				errorTag: next.errorTag
+			});
+			if (corrected) found = {
+				count: (found?.count ?? 0) + 1,
+				mastery: {
+					...found?.mastery,
+					...corrected.mastery
+				},
+				recommendation: corrected.recommendation
+			};
+		}
+		return found;
+	}
+	function challengeItem({ source, response, shown = {}, evidenceId, note }) {
+		const doubt = text(note, 800);
+		return jobs.start("item/challenge", async (api) => {
+			const place = await itemPlace(source);
+			const answer = cleanResponse(place.item, response);
+			const told = place.item.kind === "short" || place.item.kind === "work" ? [
+				`A grader gave this answer a score of ${shown.score} (${shown.correct ? "correct" : shown.partial ? "partial" : "incorrect"}).`,
+				shown.feedback ? `Feedback shown: ${shown.feedback}` : "",
+				shown.wrongStep ? `First wrong line found: ${shown.wrongStep}` : "",
+				shown.fix ? `Fix shown: ${shown.fix}` : ""
+			].filter(Boolean).join("\n") : `The answer key marked this answer ${shown.correct ? "correct" : shown.partial ? "partly correct" : "incorrect"}.`;
+			api.preview({ phase: "checking" });
+			const checked = await generateJson(llm, {
+				purpose: "teach",
+				effort: "low",
+				prompt: verifyItemPrompt({
+					scope: place.scope,
+					language: place.language,
+					item: itemForCheck(place.item),
+					kind: place.item.kind,
+					response: responseText(place.item, answer),
+					grading: told,
+					note: doubt
+				}),
+				maxTokens: 5e3,
+				signal: api.signal,
+				normalize: (raw) => normalizeItemVerdict(raw, place.item)
+			});
+			const item = checked.item ? await place.save((stored) => fixItem(stored, checked.item, { at: stamp() })) : place.item;
+			const result = regrade(item, answer, checked);
+			const changed = Boolean(result) && (result.correct !== Boolean(shown.correct) || Math.abs(result.score - (Number(shown.score) || 0)) > 1e-6);
+			const corrected = changed && evidenceId && place.course ? await regradeEvidence(place.course, evidenceId, {
+				score: result.score,
+				...result.correct ? { errorTag: "" } : result.errorTag ? { errorTag: result.errorTag } : {}
+			}) : null;
+			const earlier = checked.item && place.course ? await regradeEarlier({
+				course: place.course,
+				key: itemKey(source),
+				item,
+				verdict: checked.verdict,
+				except: evidenceId,
+				language: place.language,
+				signal: api.signal
+			}) : null;
+			if (place.course) await logEvent(place.course.id, {
+				type: "item-challenge",
+				lessonId: place.lessonId,
+				verdict: checked.verdict,
+				changed,
+				earlier: earlier?.count ?? 0
+			});
+			const mastery = corrected || earlier ? {
+				...corrected?.mastery,
+				...earlier?.mastery
+			} : null;
+			return {
+				verdict: checked.verdict,
+				summary: checked.summary,
+				explanation: checked.explanation,
+				item: checked.item ? item : null,
+				result: changed ? result : null,
+				earlier: earlier?.count ?? 0,
+				mastery,
+				recommendation: earlier?.recommendation ?? corrected?.recommendation ?? null
+			};
+		});
+	}
+	async function grade({ item, response, language = "zh-CN", signal }) {
 		if (!item?.prompt) throw new TutorError("invalid", "Missing question");
 		const work = item.kind === "work";
 		const answer = text(response, 4e3);
@@ -2850,6 +3947,7 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 				language
 			}),
 			maxTokens: work ? 1800 : 1200,
+			signal,
 			normalize: (raw) => ({
 				score: Math.min(1, Math.max(0, Number(raw?.score) || 0)),
 				verdict: [
@@ -3029,6 +4127,44 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 			if (!exists && !jobs.running(`practice:${course.id}:${row.lecture.id}`)) lecturePractice(course, row);
 		}).catch(() => void 0);
 	}
+	async function handout({ courseId, lessonId, force = false }) {
+		const { course, row } = await context(courseId, lessonId);
+		if (!force) {
+			const existing = await store.readJson(store.paths.handout(courseId, lessonId), null);
+			if (existing) return { handout: existing };
+		}
+		const board = await store.readJson(store.paths.board(courseId, lessonId), null);
+		if (!board?.steps?.length) throw new TutorError("no-board", "The board is not written yet. Try again once its first step is up.");
+		return { job: jobs.start("lesson/handout", async (api) => {
+			const made = await generateJson(llm, {
+				purpose: "teach",
+				effort: "lowest",
+				prompt: handoutPrompt({
+					course,
+					lesson: row.lesson,
+					language: course.language,
+					board: boardToPlainText(board, { maxChars: 12e3 })
+				}),
+				maxTokens: 5e3,
+				signal: api.signal,
+				normalize: normalizeHandout
+			});
+			const saved = {
+				...made,
+				title: made.title || row.lesson.title,
+				lessonId,
+				createdAt: stamp()
+			};
+			await store.writeJson(store.paths.handout(courseId, lessonId), saved);
+			return { handout: saved };
+		}, {
+			key: `handout:${courseId}:${lessonId}`,
+			meta: {
+				courseId,
+				lessonId
+			}
+		}) };
+	}
 	async function unitSheet({ courseId, unitId, force = false }) {
 		const course = await courses.readCourse(courseId);
 		const unit = course.units?.find((item) => item.id === assertId(unitId, "unt"));
@@ -3183,6 +4319,9 @@ function createLessons({ store, llm, jobs, courses, learner, now = () => /* @__P
 		prepare,
 		ask,
 		reexplain,
+		challenge,
+		challengeItem,
+		handout,
 		record,
 		grade,
 		correct,
@@ -3525,6 +4664,7 @@ function createStore({ root }) {
 		practice: (id, lessonId) => join(paths.courseDir(id), "practice", `${assertId(lessonId, "les")}.json`),
 		asides: (id, lessonId) => join(paths.courseDir(id), "asides", `${assertId(lessonId, "les")}.json`),
 		sheet: (id, unitId) => join(paths.courseDir(id), "sheets", `${assertId(unitId, "unt")}.json`),
+		handout: (id, lessonId) => join(paths.courseDir(id), "handouts", `${assertId(lessonId, "les")}.json`),
 		unitQuiz: (id, unitId) => join(paths.courseDir(id), "quizzes", `${assertId(unitId, "unt")}.json`),
 		materials: () => join(root, "materials"),
 		materialDir: (id) => join(root, "materials", assertId(id, "mat")),
@@ -4251,7 +5391,9 @@ const IDS = {
 	chs: ID("chs"),
 	dck: ID("dck"),
 	exm: ID("exm"),
-	nte: ID("nte")
+	nte: ID("nte"),
+	asd: ID("asd"),
+	evd: ID("evd")
 };
 function need(payload, key, prefix) {
 	const value = payload?.[key];
@@ -4287,6 +5429,78 @@ function scopeOf(payload) {
 	};
 	throw new TutorError("invalid", "Invalid board scope");
 }
+function challengeTarget(payload) {
+	const target = payload?.target && typeof payload.target === "object" ? payload.target : {};
+	if (target.step && typeof target.step === "object") return { step: target.step };
+	if (typeof target.stepId !== "string" || !/^s\d{1,4}$/u.test(target.stepId)) throw new TutorError("invalid", "Invalid step");
+	return {
+		stepId: target.stepId,
+		...target.asideId === void 0 ? {} : { asideId: need(target, "asideId", "asd") }
+	};
+}
+function itemSource(payload) {
+	const source = payload?.source && typeof payload.source === "object" ? payload.source : {};
+	const itemId = () => {
+		if (typeof source.itemId !== "string" || !/^[a-z0-9_-]{1,24}$/iu.test(source.itemId)) throw new TutorError("invalid", "Invalid question");
+		return source.itemId;
+	};
+	if (source.kind === "practice") return {
+		kind: "practice",
+		courseId: need(source, "courseId", "crs"),
+		lessonId: need(source, "lessonId", "les"),
+		itemId: itemId()
+	};
+	if (source.kind === "quiz") return {
+		kind: "quiz",
+		courseId: need(source, "courseId", "crs"),
+		unitId: need(source, "unitId", "unt"),
+		itemId: itemId()
+	};
+	if (source.kind === "deck") return {
+		kind: "deck",
+		deckId: need(source, "deckId", "dck"),
+		itemId: itemId()
+	};
+	if (source.kind === "check") {
+		if (typeof source.stepId !== "string" || !/^s\d{1,4}$/u.test(source.stepId)) throw new TutorError("invalid", "Invalid step");
+		return {
+			kind: "check",
+			courseId: need(source, "courseId", "crs"),
+			lessonId: need(source, "lessonId", "les"),
+			stepId: source.stepId
+		};
+	}
+	throw new TutorError("invalid", "Invalid question");
+}
+function answerOf(value) {
+	if (typeof value === "string") return value.slice(0, 4e3);
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	return Array.isArray(value) ? value.filter((id) => typeof id === "string" && /^[a-z]$/u.test(id)).slice(0, 12) : "";
+}
+function answeredItem(payload, courseId) {
+	if (!payload?.source || payload.source.kind === "deck") return null;
+	try {
+		const source = itemSource(payload);
+		return source.courseId === courseId ? {
+			source,
+			response: answerOf(payload.response)
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function shownGrade(value) {
+	const grade = value && typeof value === "object" ? value : {};
+	const words = (key, max) => typeof grade[key] === "string" ? grade[key].slice(0, max) : "";
+	return {
+		score: Math.min(1, Math.max(0, Number(grade.score) || 0)),
+		correct: grade.correct === true,
+		partial: grade.partial === true,
+		feedback: words("feedback", 1200),
+		wrongStep: words("wrongStep", 400),
+		fix: words("fix", 400)
+	};
+}
 const ITEM_KINDS = {
 	sheets: "chs",
 	decks: "dck",
@@ -4341,6 +5555,11 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 			courseId: need(payload, "courseId", "crs"),
 			instruction: payload.instruction
 		}) }),
+		"course/add-materials": (payload) => ({ job: courses.addMaterials({
+			courseId: need(payload, "courseId", "crs"),
+			materialIds: idList(payload.materialIds, "mat", 12),
+			instruction: payload.instruction
+		}) }),
 		"course/save-blueprint": (payload) => courses.saveBlueprint({
 			courseId: need(payload, "courseId", "crs"),
 			blueprint: payload.blueprint
@@ -4396,9 +5615,17 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 			style: STYLES.includes(payload.style) ? payload.style : "example",
 			anchorStepId: payload.anchorStepId
 		}) }),
+		"lesson/challenge": (payload) => ({ job: lessons.challenge({
+			scope: scopeOf(payload),
+			stepIndex: payload.stepIndex,
+			anchorStepId: payload.anchorStepId,
+			target: challengeTarget(payload),
+			note: typeof payload.note === "string" ? payload.note : ""
+		}) }),
 		"lesson/record": (payload) => lessons.record({
 			courseId: need(payload, "courseId", "crs"),
 			lessonId: optional(payload, "lessonId", "les"),
+			item: answeredItem(payload, need(payload, "courseId", "crs")),
 			conceptIds: (Array.isArray(payload.conceptIds) ? payload.conceptIds : []).filter((id) => /^cpt_[a-z0-9]{6,40}$/u.test(String(id))).slice(0, 8),
 			evidence: {
 				kind: payload.evidence?.kind,
@@ -4416,6 +5643,13 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 			response: payload.response,
 			language: typeof payload.language === "string" ? payload.language.slice(0, 12) : void 0
 		}),
+		"item/challenge": (payload) => ({ job: lessons.challengeItem({
+			source: itemSource(payload),
+			response: answerOf(payload.response),
+			shown: shownGrade(payload.shown),
+			evidenceId: optional(payload, "evidenceId", "evd"),
+			note: typeof payload.note === "string" ? payload.note : ""
+		}) }),
 		"lesson/correct": (payload) => ({ job: lessons.correct({
 			scope: scopeOf(payload),
 			stepIndex: payload.stepIndex,
@@ -4434,6 +5668,11 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 			lessonId: need(payload, "lessonId", "les"),
 			selfRating: Number(payload.selfRating) || void 0
 		}),
+		"lesson/handout": (payload) => lessons.handout({
+			courseId: need(payload, "courseId", "crs"),
+			lessonId: need(payload, "lessonId", "les"),
+			force: payload.force === true
+		}),
 		"lesson/practice": (payload) => lessons.practice({
 			courseId: need(payload, "courseId", "crs"),
 			lessonId: need(payload, "lessonId", "les")
@@ -4455,6 +5694,7 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 		}),
 		"profile/get": () => learner.getProfile(),
 		"profile/save": (payload) => learner.saveProfile({
+			name: payload.name,
 			background: payload.background,
 			goals: payload.goals,
 			strengths: payload.strengths,
@@ -4492,6 +5732,7 @@ function createRoutes({ courses, lessons, learner, studio, projects, jobs, setti
 		}) }),
 		"material/url": (payload) => ({ job: studio.addUrl({ url: payload.url }) }),
 		"material/list": () => studio.listMaterials(),
+		"material/search": (payload) => studio.searchMaterials({ query: typeof payload.query === "string" ? payload.query : "" }),
 		"material/get": (payload) => studio.getMaterial({ id: need(payload, "id", "mat") }),
 		"material/rename": (payload) => studio.renameMaterial({
 			id: need(payload, "id", "mat"),
@@ -4686,8 +5927,12 @@ const TTS_PROVIDERS = Object.freeze([
 	"minimax",
 	"azure"
 ]);
-const REQUEST_TIMEOUT_MS = 45e3;
+const TTS_LIMITS = Object.freeze({
+	totalMs: 45e3,
+	quietMs: 1e4
+});
 const MAX_AUDIO_BYTES = 12 * 1024 * 1024;
+const MAX_JSON_BYTES = 3 * MAX_AUDIO_BYTES;
 const CACHE_MAX_BYTES = 300 * 1024 * 1024;
 var TtsError = class extends Error {
 	constructor(code, message, status) {
@@ -4826,28 +6071,75 @@ function splitForTts(content, maxUnits) {
 	if (current) chunks.push(current);
 	return chunks;
 }
-async function boundedFetch(fetchImpl, url, init, signal) {
-	const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
-	const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
-	let response;
+function firstByteMs(text, limits = TTS_LIMITS) {
+	return Math.min(limits.totalMs, limits.quietMs + Math.round(estimateSpeechMs(text) / 10));
+}
+async function boundedFetch(fetchImpl, url, init, { text, signal, limits, maxBytes }) {
+	const limit = new AbortController();
+	let reason = null;
+	const stop = (code) => {
+		reason ??= code;
+		limit.abort();
+	};
+	const total = setTimeout(() => stop("timeout"), limits.totalMs);
+	let quiet = setTimeout(() => stop("stalled"), firstByteMs(text, limits));
+	const combined = signal ? AbortSignal.any([signal, limit.signal]) : limit.signal;
+	const failure = (error) => {
+		if (signal?.aborted) return signal.reason ?? error;
+		if (reason === "stalled") return new TtsError("stalled", "The TTS service is not responding");
+		if (reason === "timeout") return new TtsError("timeout", "TTS request timed out");
+		return null;
+	};
 	try {
-		response = await fetchImpl(url, {
-			...init,
-			redirect: "error",
-			signal: combined
-		});
-	} catch (error) {
-		if (signal?.aborted) throw signal.reason ?? error;
-		throw new TtsError(timeout.aborted ? "timeout" : "network", timeout.aborted ? "TTS request timed out" : "Could not reach the TTS service");
+		let response;
+		try {
+			response = await fetchImpl(url, {
+				...init,
+				redirect: "error",
+				signal: combined
+			});
+		} catch (error) {
+			throw failure(error) ?? new TtsError("network", "Could not reach the TTS service");
+		}
+		if (!response.ok) {
+			response.body?.cancel().catch(() => void 0);
+			throw httpError(response.status);
+		}
+		const length = Number(response.headers.get("content-length"));
+		if (Number.isFinite(length) && length > maxBytes) throw new TtsError("too-large", "TTS response is too large");
+		const parts = [];
+		let size = 0;
+		const reader = response.body?.getReader();
+		while (reader) {
+			let chunk;
+			try {
+				chunk = await reader.read();
+			} catch (error) {
+				throw failure(error) ?? error;
+			}
+			if (chunk.done) break;
+			if (!chunk.value?.byteLength) continue;
+			clearTimeout(quiet);
+			quiet = setTimeout(() => stop("stalled"), limits.quietMs);
+			size += chunk.value.byteLength;
+			if (size > maxBytes) {
+				reader.cancel().catch(() => void 0);
+				throw new TtsError("too-large", "TTS response is too large");
+			}
+			parts.push(chunk.value);
+		}
+		return Buffer.concat(parts);
+	} finally {
+		clearTimeout(total);
+		clearTimeout(quiet);
 	}
-	return response;
 }
-async function readBounded(response) {
-	const length = Number(response.headers.get("content-length"));
-	if (Number.isFinite(length) && length > MAX_AUDIO_BYTES) throw new TtsError("too-large", "TTS response is too large");
-	const buffer = Buffer.from(await response.arrayBuffer());
-	if (buffer.length > MAX_AUDIO_BYTES) throw new TtsError("too-large", "TTS response is too large");
-	return buffer;
+function parseJson(body, service) {
+	try {
+		return JSON.parse(body.toString("utf8"));
+	} catch {
+		throw new TtsError("response", `${service} returned an unreadable response`);
+	}
 }
 function httpError(status) {
 	if (status === 401 || status === 403) return new TtsError("auth", "The TTS service rejected the key", status);
@@ -4869,10 +6161,10 @@ function xmlEscape(value) {
 	})[char]);
 }
 const synthesizers = {
-	async openai({ text, config, secret, rate, fetchImpl, signal }) {
+	async openai({ text, config, secret, rate, send }) {
 		const base = checkEndpoint(config.baseUrl || "https://api.openai.com/v1");
 		const path = base.pathname.replace(/\/+$/u, "");
-		const response = await boundedFetch(fetchImpl, new URL(`${path}/audio/speech`, base), {
+		return send(new URL(`${path}/audio/speech`, base), {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${secret}`,
@@ -4886,13 +6178,11 @@ const synthesizers = {
 				response_format: "mp3",
 				speed: rateNumber(rate)
 			})
-		}, signal);
-		if (!response.ok) throw httpError(response.status);
-		return readBounded(response);
+		}, MAX_AUDIO_BYTES);
 	},
-	async volcengine({ text, config, secret, rate, fetchImpl, signal }) {
+	async volcengine({ text, config, secret, rate, send }) {
 		if (!config.appId) throw new TtsError("app-id", "Volcengine App ID is required");
-		const response = await boundedFetch(fetchImpl, "https://openspeech.bytedance.com/api/v1/tts", {
+		const body = parseJson(await send("https://openspeech.bytedance.com/api/v1/tts", {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer;${secret}`,
@@ -4916,24 +6206,17 @@ const synthesizers = {
 					operation: "query"
 				}
 			})
-		}, signal);
-		if (!response.ok) throw httpError(response.status);
-		let body;
-		try {
-			body = await response.json();
-		} catch {
-			throw new TtsError("response", "Volcengine returned an unreadable response");
-		}
+		}, MAX_JSON_BYTES), "Volcengine");
 		if (body?.code !== 3e3 || typeof body?.data !== "string") throw new TtsError(body?.code === 3001 || body?.code === 3003 ? "auth" : "request", `Volcengine TTS failed (${body?.code ?? "unknown"})`);
 		const audio = Buffer.from(body.data, "base64");
 		if (audio.length > MAX_AUDIO_BYTES) throw new TtsError("too-large", "TTS response is too large");
 		return audio;
 	},
-	async minimax({ text, config, secret, rate, fetchImpl, signal }) {
+	async minimax({ text, config, secret, rate, send }) {
 		const base = checkEndpoint(config.baseUrl || "https://api.minimaxi.com");
 		const url = new URL("/v1/t2a_v2", base);
 		if (config.groupId) url.searchParams.set("GroupId", config.groupId);
-		const response = await boundedFetch(fetchImpl, url, {
+		const body = parseJson(await send(url, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${secret}`,
@@ -4956,21 +6239,14 @@ const synthesizers = {
 					channel: 1
 				}
 			})
-		}, signal);
-		if (!response.ok) throw httpError(response.status);
-		let body;
-		try {
-			body = await response.json();
-		} catch {
-			throw new TtsError("response", "MiniMax returned an unreadable response");
-		}
+		}, MAX_JSON_BYTES), "MiniMax");
 		const status = body?.base_resp?.status_code;
 		if (status !== 0 || typeof body?.data?.audio !== "string") throw new TtsError(status === 1004 || status === 2049 ? "auth" : "request", `MiniMax TTS failed (${status ?? "unknown"})`);
 		const audio = Buffer.from(body.data.audio, "hex");
 		if (audio.length > MAX_AUDIO_BYTES) throw new TtsError("too-large", "TTS response is too large");
 		return audio;
 	},
-	async azure({ text, config, secret, rate, fetchImpl, signal }) {
+	async azure({ text, config, secret, rate, send }) {
 		const region = String(config.region || "").trim().toLowerCase();
 		if (!/^[a-z0-9]{2,30}$/u.test(region)) throw new TtsError("azure", "Azure region is invalid");
 		const voice = String(config.voice || "zh-CN-XiaoxiaoNeural");
@@ -4978,7 +6254,7 @@ const synthesizers = {
 		const lang = voice.split("-").slice(0, 2).join("-");
 		const percent = Math.round((rateNumber(rate) - 1) * 100);
 		const ssml = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="${lang}"><voice name="${voice}"><prosody rate="${percent >= 0 ? "+" : ""}${percent}%">${xmlEscape(text)}</prosody></voice></speak>`;
-		const response = await boundedFetch(fetchImpl, `https://${region}.tts.speech.microsoft.com/cognitiveservices/v1`, {
+		return send(`https://${region}.tts.speech.microsoft.com/cognitiveservices/v1`, {
 			method: "POST",
 			headers: {
 				"Ocp-Apim-Subscription-Key": secret,
@@ -4987,9 +6263,7 @@ const synthesizers = {
 				"User-Agent": "dsh-aha-tutor"
 			},
 			body: ssml
-		}, signal);
-		if (!response.ok) throw httpError(response.status);
-		return readBounded(response);
+		}, MAX_AUDIO_BYTES);
 	}
 };
 const CHUNK_UNITS = Object.freeze({
@@ -4998,7 +6272,7 @@ const CHUNK_UNITS = Object.freeze({
 	minimax: 9e3,
 	azure: 6e3
 });
-function createTts({ cacheDir, fetchImpl = globalThis.fetch, getSecret }) {
+function createTts({ cacheDir, fetchImpl = globalThis.fetch, getSecret, limits = TTS_LIMITS }) {
 	if (typeof getSecret !== "function") throw new TypeError("createTts needs getSecret");
 	let pruning;
 	const cacheKey = (provider, config, rate, text) => createHash("sha256").update(JSON.stringify([
@@ -5032,18 +6306,25 @@ function createTts({ cacheDir, fetchImpl = globalThis.fetch, getSecret }) {
 		const secret = await getSecret(provider);
 		if (!secret) throw new TtsError("no-key", "No key saved for this TTS provider");
 		const parts = [];
-		for (const chunk of splitForTts(content, CHUNK_UNITS[provider])) parts.push(await synthesizers[provider]({
-			text: chunk,
-			config: merged,
-			secret,
-			rate,
-			fetchImpl,
-			signal
-		}));
+		for (const chunk of splitForTts(content, CHUNK_UNITS[provider])) {
+			const send = (url, init, maxBytes) => boundedFetch(fetchImpl, url, init, {
+				text: chunk,
+				signal,
+				limits,
+				maxBytes
+			});
+			parts.push(await synthesizers[provider]({
+				text: chunk,
+				config: merged,
+				secret,
+				rate,
+				send
+			}));
+		}
 		const audio = Buffer.concat(parts);
 		if (!audio.length) throw new TtsError("response", "The TTS service returned no audio");
 		if (file) {
-			await writeFileAtomic(file, audio).catch(() => void 0);
+			await mkdir(cacheDir, { recursive: true }).then(() => writeFileAtomic(file, audio)).catch(() => void 0);
 			pruning ??= prune().finally(() => {
 				pruning = void 0;
 			});
@@ -5316,6 +6597,37 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 		const ids = await store.listIds(store.paths.materials(), "mat");
 		return (await Promise.all(ids.map((id) => store.readJson(store.paths.material(id), null)))).filter(Boolean).sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
 	}
+	let libraryIndex = null;
+	const SEARCH_CHUNKS = 3e4;
+	async function searchMaterials({ query }) {
+		const wanted = text(query, 200);
+		if (!wanted) return { results: [] };
+		const metas = (await listMaterials()).filter((meta) => meta.kind !== "image");
+		const key = metas.map((meta) => `${meta.id}:${meta.title}:${meta.chars ?? meta.pages ?? ""}`).join("|");
+		if (libraryIndex?.key !== key) {
+			const chunks = [];
+			for (const meta of metas) {
+				if (chunks.length >= SEARCH_CHUNKS) break;
+				const own = await store.readJson(store.paths.materialChunks(meta.id), []) ?? [];
+				for (const chunk of own.slice(0, SEARCH_CHUNKS - chunks.length)) chunks.push({
+					...chunk,
+					materialId: meta.id,
+					materialTitle: meta.title
+				});
+			}
+			libraryIndex = {
+				key,
+				index: buildIndex(chunks)
+			};
+		}
+		return { results: search(libraryIndex.index, wanted, { limit: 12 }).map(({ chunk }) => ({
+			materialId: chunk.materialId,
+			title: chunk.materialTitle,
+			page: chunk.page ?? null,
+			slide: chunk.slide ?? null,
+			snippet: snippetOf(chunk.text, wanted)
+		})) };
+	}
 	async function getMaterial({ id }) {
 		const meta = await store.readJson(store.paths.material(assertId(id, "mat")), null);
 		if (!meta) throw new TutorError("not-found", "Material not found");
@@ -5756,6 +7068,7 @@ function createStudio({ store, llm, jobs, now = () => /* @__PURE__ */ new Date()
 		upload,
 		addUrl,
 		listMaterials,
+		searchMaterials,
 		getMaterial,
 		renameMaterial,
 		removeMaterial,